Add binding support for Count property (ObservableKeyGroupsCollection) (

#538)

Softeq.XToolkit.Common.Tests/Collections/ObservableKeyGroupsCollectionTest/ObservableKeyGroupsCollectionTestsCountChanged.cs

@@ -0,0 +1,80 @@
+// Developed by Softeq Development Corporation
+// http://www.softeq.com
+
+using Xunit;
+using CollectionHelper = Softeq.XToolkit.Common.Tests.Collections.ObservableKeyGroupsCollectionTest.ObservableKeyGroupsCollectionHelper;
+
+namespace Softeq.XToolkit.Common.Tests.Collections.ObservableKeyGroupsCollectionTest;
+
+public class ObservableKeyGroupsCollectionTestsCountChanged
+{
+    [Fact]
+    public void AddGroups_KeysOnlyForbidEmptyGroupCorrectKeys_RaisesPropertyChangedForCount()
+    {
+        var collection = CollectionHelper.CreateFilledGroupsWithoutEmpty();
+        var pairs = CollectionHelper.PairNotContainedKeyWithItems;
+
+        Assert.PropertyChanged(collection, nameof(collection.Count), () =>
+        {
+            collection.AddGroups(pairs);
+        });
+    }
+
+    [Fact]
+    public void InsertGroups_KeysOnlyForbidEmptyGroupCorrectKeys_RaisesPropertyChangedForCount()
+    {
+        var collection = CollectionHelper.CreateFilledGroupsWithoutEmpty();
+        var pairs = CollectionHelper.PairNotContainedKeyWithItems;
+
+        Assert.PropertyChanged(collection, nameof(collection.Count), () =>
+        {
+            collection.InsertGroups(0, pairs);
+        });
+    }
+
+    [Fact]
+    public void ReplaceAllGroups_KeysOnlyAllowEmptyGroupCorrectKeys_RaisesPropertyChangedForCount()
+    {
+        var collection = CollectionHelper.CreateFilledGroupsWithEmpty();
+        var keys = CollectionHelper.KeysEmpty;
+
+        Assert.PropertyChanged(collection, nameof(collection.Count), () =>
+        {
+            collection.ReplaceAllGroups(keys);
+        });
+    }
+
+    [Fact]
+    public void ReplaceAllGroups_KeysOnlyAllowEmptyGroupEmptyCollection_RaisesPropertyChangedForCount()
+    {
+        var collection = CollectionHelper.CreateFilledGroupsWithEmpty();
+        var pairs = CollectionHelper.PairsEmpty;
+
+        Assert.PropertyChanged(collection, nameof(collection.Count), () =>
+        {
+            collection.ReplaceAllGroups(pairs);
+        });
+    }
+
+    [Fact]
+    public void RemoveGroups_KeysOnlyForbidEmptyGroupContainsKey_RaisesPropertyChangedForCount()
+    {
+        var collection = CollectionHelper.CreateFilledGroupsWithoutEmpty();
+
+        Assert.PropertyChanged(collection, nameof(collection.Count), () =>
+        {
+            collection.RemoveGroups(CollectionHelper.KeysOneFill);
+        });
+    }
+
+    [Fact]
+    public void Clear_FilledCollection_RaisesPropertyChangedForCount()
+    {
+        var collection = CollectionHelper.CreateFilledGroupsWithoutEmpty();
+
+        Assert.PropertyChanged(collection, nameof(collection.Count), () =>
+        {
+            collection.Clear();
+        });
+    }
+}

Softeq.XToolkit.Common/Collections/ObservableKeyGroupsCollection.cs

@@ -6,7 +6,9 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
+using System.ComponentModel;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using Softeq.XToolkit.Common.Collections.EventArgs;
 using Softeq.XToolkit.Common.Extensions;
 
@@ -21,7 +23,8 @@ namespace Softeq.XToolkit.Common.Collections
     public sealed class ObservableKeyGroupsCollection<TKey, TValue>
         : IObservableKeyGroupsCollection<TKey, TValue>,
             INotifyKeyGroupCollectionChanged<TKey, TValue>,
-            INotifyCollectionChanged
+            INotifyCollectionChanged,
+            INotifyPropertyChanged
         where TKey : notnull
         where TValue : notnull
     {
@@ -42,6 +45,7 @@ public ObservableKeyGroupsCollection(bool allowEmptyGroups = true)
 
         public event NotifyCollectionChangedEventHandler? CollectionChanged;
         public event EventHandler<NotifyKeyGroupCollectionChangedEventArgs<TKey, TValue>>? ItemsChanged;
+        public event PropertyChangedEventHandler? PropertyChanged;
 
         public IList<TKey> Keys => _groups.Select(item => item.Key).ToList();
 
@@ -161,14 +165,11 @@ public void ReplaceAllGroups(IEnumerable<KeyValuePair<TKey, IList<TValue>>> item
             _groups.Clear();
 
             var insertedGroups = InsertGroupsWithoutNotify(0, items, _emptyGroupsDisabled);
-            if (insertedGroups == null)
-            {
-                return;
-            }
+            var insertedGroupKeys = insertedGroups?.Select(x => x.Key).ToList() ?? new List<TKey>();
 
             var newItems = new Collection<(int, IReadOnlyList<TKey>)>
             {
-                (0, insertedGroups.Select(x => x.Key).ToList())
+                (0, insertedGroupKeys)
             };
 
             OnChanged(
@@ -534,6 +535,8 @@ private void RaiseEvents(NotifyKeyGroupCollectionChangedEventArgs<TKey, TValue>
             }
 
             ItemsChanged?.Invoke(this, args);
+
+            NotifyCountIfNeeded(args);
         }
 
         private IEnumerable<Group>? InsertGroupsWithoutNotify(
@@ -697,6 +700,29 @@ private void DecrementIndex<T>(IList<KeyValuePair<T, int>> indexes)
             }
         }
 
+        private void NotifyCountIfNeeded(NotifyKeyGroupCollectionChangedEventArgs<TKey, TValue> args)
+        {
+            var isCountOfGroupsChanged = IsActionCanModifyGroup(args.Action);
+            if (isCountOfGroupsChanged)
+            {
+                OnPropertyChanged(nameof(Count));
+            }
+        }
+
+        private bool IsActionCanModifyGroup(NotifyCollectionChangedAction? action)
+        {
+            return action
+                is NotifyCollectionChangedAction.Add
+                or NotifyCollectionChangedAction.Remove
+                or NotifyCollectionChangedAction.Replace
+                or NotifyCollectionChangedAction.Reset;
+        }
+
+        private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
         private class Group : List<TValue>, IGrouping<TKey, TValue>
         {
             public Group(KeyValuePair<TKey, IList<TValue>> keyValuePair)