From 8ef5d08bb4926769d9208032d86a7be483d61b70 Mon Sep 17 00:00:00 2001
From: Ze Groumf <zeGroumf@hotmail.com>
Date: Thu, 19 Mar 2020 22:01:34 +0100
Subject: [PATCH 01/13] first drop

---
 Microsoft.Toolkit/Microsoft.Toolkit.csproj    |   4 +
 .../Observables/ObservableGroup.cs            |  53 ++++++++
 .../ObservableGroupedCollection.cs            |  34 ++++++
 .../Observables/ReadOnlyObservableGroup.cs    |  41 +++++++
 .../ReadOnlyObservableGroupedCollection.cs    | 115 ++++++++++++++++++
 5 files changed, 247 insertions(+)
 create mode 100644 Microsoft.Toolkit/Observables/ObservableGroup.cs
 create mode 100644 Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs
 create mode 100644 Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs
 create mode 100644 Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs

diff --git a/Microsoft.Toolkit/Microsoft.Toolkit.csproj b/Microsoft.Toolkit/Microsoft.Toolkit.csproj
index 011f95377f7..fe2846fe086 100644
--- a/Microsoft.Toolkit/Microsoft.Toolkit.csproj
+++ b/Microsoft.Toolkit/Microsoft.Toolkit.csproj
@@ -67,4 +67,8 @@
     </Compile>
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Observables\" />
+  </ItemGroup>
+
 </Project>
\ No newline at end of file
diff --git a/Microsoft.Toolkit/Observables/ObservableGroup.cs b/Microsoft.Toolkit/Observables/ObservableGroup.cs
new file mode 100644
index 00000000000..0a901eb3da3
--- /dev/null
+++ b/Microsoft.Toolkit/Observables/ObservableGroup.cs
@@ -0,0 +1,53 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace Microsoft.Toolkit.Observables.Collections
+{
+    /// <summary>
+    /// An observable group. It associates a <see cref="Key"/> to an <see cref="ObservableCollection{T}"/>.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the group key.</typeparam>
+    /// <typeparam name="TValue">The type of the items in the collection.</typeparam>
+    public sealed class ObservableGroup<TKey, TValue> : ObservableCollection<TValue>, IGrouping<TKey, TValue>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ObservableGroup{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="key">The key for the group.</param>
+        public ObservableGroup(TKey key)
+        {
+            Key = key;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ObservableGroup{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="grouping">The grouping to fill the group.</param>
+        public ObservableGroup(IGrouping<TKey, TValue> grouping)
+            : base(grouping)
+        {
+            Key = grouping.Key;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ObservableGroup{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="key">The key for the group.</param>
+        /// <param name="collection">The initial collection of data to add to the group.</param>
+        public ObservableGroup(TKey key, IEnumerable<TValue> collection)
+            : base(collection)
+        {
+            Key = key;
+        }
+
+        /// <summary>
+        /// The key of the group.
+        /// </summary>
+        public TKey Key { get; }
+    }
+}
diff --git a/Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs b/Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs
new file mode 100644
index 00000000000..79e7ef7c5d0
--- /dev/null
+++ b/Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs
@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace Microsoft.Toolkit.Observables.Collections
+{
+    /// <summary>
+    /// An observable list of observable groups.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the group key.</typeparam>
+    /// <typeparam name="TValue">The type of the items in the collection.</typeparam>
+    public sealed class ObservableGroupedCollection<TKey, TValue> : ObservableCollection<ObservableGroup<TKey, TValue>>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ObservableGroupedCollection{TKey, TValue}"/> class.
+        /// </summary>
+        public ObservableGroupedCollection()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ObservableGroupedCollection{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="collection">The initial data to add in the grouped collection.</param>
+        public ObservableGroupedCollection(IEnumerable<IGrouping<TKey, TValue>> collection)
+            : base(collection.Select(c => new ObservableGroup<TKey, TValue>(c.Key, c)))
+        {
+        }
+    }
+}
diff --git a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs
new file mode 100644
index 00000000000..b0726e0b929
--- /dev/null
+++ b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs
@@ -0,0 +1,41 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace Microsoft.Toolkit.Observables.Collections
+{
+    /// <summary>
+    /// A read-only observable group. It associates a <see cref="Key"/> to a <see cref="ReadOnlyObservableCollection{T}"/>.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the group key.</typeparam>
+    /// <typeparam name="TValue">The type of the items in the collection.</typeparam>
+    public sealed class ReadOnlyObservableGroup<TKey, TValue> : ReadOnlyObservableCollection<TValue>, IGrouping<TKey, TValue>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReadOnlyObservableGroup{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="key">The key of the group.</param>
+        /// <param name="collection">The collection of items to add in the group.</param>
+        public ReadOnlyObservableGroup(TKey key, ObservableCollection<TValue> collection)
+            : base(collection)
+        {
+            Key = key;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReadOnlyObservableGroup{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="group">The <see cref="ObservableGroup{TKey, TValue}"/> to wrap.</param>
+        public ReadOnlyObservableGroup(ObservableGroup<TKey, TValue> group)
+            : base(group)
+        {
+            Key = group.Key;
+        }
+
+        /// <inheritdoc/>
+        public TKey Key { get; }
+    }
+}
diff --git a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
new file mode 100644
index 00000000000..74ca7c60fca
--- /dev/null
+++ b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
@@ -0,0 +1,115 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Microsoft.Toolkit.Observables.Collections
+{
+    /// <summary>
+    /// A read-only list of groups.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the group key.</typeparam>
+    /// <typeparam name = "TValue" > The type of the items in the collection.</typeparam>
+    public sealed class ReadOnlyObservableGroupedCollection<TKey, TValue> :
+        IReadOnlyCollection<ReadOnlyObservableGroup<TKey, TValue>>,
+        IReadOnlyList<ReadOnlyObservableGroup<TKey, TValue>>,
+        INotifyPropertyChanged,
+        INotifyCollectionChanged
+    {
+        private readonly ObservableGroupedCollection<TKey, TValue> _collection;
+        private readonly IDictionary<ObservableGroup<TKey, TValue>, ReadOnlyObservableGroup<TKey, TValue>> _mapping;
+
+        /// <inheritdoc/>
+        public event NotifyCollectionChangedEventHandler CollectionChanged;
+
+        /// <inheritdoc/>
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReadOnlyObservableGroupedCollection{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="collection">The source collection to wrap.</param>
+        public ReadOnlyObservableGroupedCollection(ObservableGroupedCollection<TKey, TValue> collection)
+        {
+            _collection = collection;
+            _mapping = new Dictionary<ObservableGroup<TKey, TValue>, ReadOnlyObservableGroup<TKey, TValue>>(capacity: _collection.Count);
+
+            ((INotifyPropertyChanged)_collection).PropertyChanged += OnCollectionPropertyChanged;
+            ((INotifyCollectionChanged)_collection).CollectionChanged += OnCollectionChanged;
+        }
+
+        /// <inheritdoc/>
+        public ReadOnlyObservableGroup<TKey, TValue> this[int index] => CreateOrGetReadOnlyObservableGroup(_collection[index]);
+
+        /// <inheritdoc/>
+        public int Count => _collection.Count;
+
+        /// <inheritdoc/>
+        public IEnumerator<ReadOnlyObservableGroup<TKey, TValue>> GetEnumerator() => _collection.Select(CreateOrGetReadOnlyObservableGroup).GetEnumerator();
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)_collection.Select(CreateOrGetReadOnlyObservableGroup)).GetEnumerator();
+
+        private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            // We force the evaluation to have all our instances ready before deleting the mapping.
+            var sourceOldItems = e.OldItems?.Cast<ObservableGroup<TKey, TValue>>() ?? Enumerable.Empty<ObservableGroup<TKey, TValue>>();
+            var oldItems = (IList)sourceOldItems.Select(CreateOrGetReadOnlyObservableGroup).ToList();
+            var newItems = (IList)(e.NewItems?.Cast<ObservableGroup<TKey, TValue>>().Select(CreateOrGetReadOnlyObservableGroup) ?? Enumerable.Empty<ReadOnlyObservableGroup<TKey, TValue>>()).ToList();
+
+            switch (e.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, newItems));
+                    break;
+                case NotifyCollectionChangedAction.Move:
+                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, newItems, e.NewStartingIndex, e.OldStartingIndex));
+                    break;
+                case NotifyCollectionChangedAction.Remove:
+                    // We unmap the removed or replaced items.
+                    foreach (var sourceOldItem in sourceOldItems)
+                    {
+                        _mapping.Remove(sourceOldItem);
+                    }
+                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, oldItems));
+                    break;
+                case NotifyCollectionChangedAction.Replace:
+                    // We unmap the removed or replaced items.
+                    foreach (var sourceOldItem in sourceOldItems)
+                    {
+                        _mapping.Remove(sourceOldItem);
+                    }
+                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, newItems, oldItems));
+                    break;
+                case NotifyCollectionChangedAction.Reset:
+                    _mapping.Clear();
+                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+                    break;
+                default:
+                    Debug.Fail("unsupported value");
+                    break;
+            }
+        }
+
+        private void OnCollectionPropertyChanged(object sender, PropertyChangedEventArgs e) => PropertyChanged?.Invoke(this, e);
+
+        private ReadOnlyObservableGroup<TKey, TValue> CreateOrGetReadOnlyObservableGroup(ObservableGroup<TKey, TValue> observableGroup)
+        {
+            if (_mapping.TryGetValue(observableGroup, out var readOnlyGroup))
+            {
+                return readOnlyGroup;
+            }
+
+            readOnlyGroup = new ReadOnlyObservableGroup<TKey, TValue>(observableGroup);
+            _mapping.Add(observableGroup, readOnlyGroup);
+
+            return readOnlyGroup;
+        }
+    }
+}

From 2b67afac4ccf1f1a2c133ec6280cebfaa698476d Mon Sep 17 00:00:00 2001
From: Ze Groumf <zeGroumf@hotmail.com>
Date: Thu, 19 Mar 2020 23:59:36 +0100
Subject: [PATCH 02/13] add unit tests

---
 .../Observables/ObservableGroup.cs            |   5 +-
 UnitTests/Observables/IntGroup.cs             |  20 ++
 UnitTests/Observables/ObservableGroupTests.cs | 111 ++++++++
 .../ObservableGroupedCollectionTests.cs       |  43 ++++
 .../ReadOnlyObservableGroupTests.cs           | 107 ++++++++
 ...eadOnlyObservableGroupedCollectionTests.cs | 240 ++++++++++++++++++
 UnitTests/UnitTests.csproj                    |   8 +
 7 files changed, 532 insertions(+), 2 deletions(-)
 create mode 100644 UnitTests/Observables/IntGroup.cs
 create mode 100644 UnitTests/Observables/ObservableGroupTests.cs
 create mode 100644 UnitTests/Observables/ObservableGroupedCollectionTests.cs
 create mode 100644 UnitTests/Observables/ReadOnlyObservableGroupTests.cs
 create mode 100644 UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs

diff --git a/Microsoft.Toolkit/Observables/ObservableGroup.cs b/Microsoft.Toolkit/Observables/ObservableGroup.cs
index 0a901eb3da3..f7a965d4965 100644
--- a/Microsoft.Toolkit/Observables/ObservableGroup.cs
+++ b/Microsoft.Toolkit/Observables/ObservableGroup.cs
@@ -9,7 +9,8 @@
 namespace Microsoft.Toolkit.Observables.Collections
 {
     /// <summary>
-    /// An observable group. It associates a <see cref="Key"/> to an <see cref="ObservableCollection{T}"/>.
+    /// An observable group.
+    /// It associates a <see cref="Key"/> to an <see cref="ObservableCollection{T}"/>.
     /// </summary>
     /// <typeparam name="TKey">The type of the group key.</typeparam>
     /// <typeparam name="TValue">The type of the items in the collection.</typeparam>
@@ -46,7 +47,7 @@ public ObservableGroup(TKey key, IEnumerable<TValue> collection)
         }
 
         /// <summary>
-        /// The key of the group.
+        /// Gets the key of the group.
         /// </summary>
         public TKey Key { get; }
     }
diff --git a/UnitTests/Observables/IntGroup.cs b/UnitTests/Observables/IntGroup.cs
new file mode 100644
index 00000000000..d0a6734c160
--- /dev/null
+++ b/UnitTests/Observables/IntGroup.cs
@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnitTests.Observables
+{
+    public class IntGroup : List<int>, IGrouping<string, int>
+    {
+        public IntGroup(string key, IEnumerable<int> collection)
+            : base(collection)
+        {
+            Key = key;
+        }
+
+        public string Key { get; }
+    }
+}
diff --git a/UnitTests/Observables/ObservableGroupTests.cs b/UnitTests/Observables/ObservableGroupTests.cs
new file mode 100644
index 00000000000..39e5cfd49a1
--- /dev/null
+++ b/UnitTests/Observables/ObservableGroupTests.cs
@@ -0,0 +1,111 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using FluentAssertions;
+using Microsoft.Toolkit.Observables.Collections;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Specialized;
+
+namespace UnitTests.Observables
+{
+    [TestClass]
+    public class ObservableGroupTests
+    {
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Ctor_ShouldHaveExpectedState()
+        {
+            var group = new ObservableGroup<string, int>("key");
+
+            group.Key.Should().Be("key");
+            group.Should().BeEmpty();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Ctor_WithGrouping_ShouldHaveExpectedState()
+        {
+            var source = new IntGroup("Key", new[] { 1, 2, 3 });
+            var group = new ObservableGroup<string, int>(source);
+
+            group.Key.Should().Be("Key");
+            group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Ctor_WithCollection_ShouldHaveExpectedState()
+        {
+            var source = new[] { 1, 2, 3 };
+            var group = new ObservableGroup<string, int>("key", source);
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Add_ShouldRaiseEvent()
+        {
+            var collectionChangedEventRaised = false;
+            var source = new[] { 1, 2, 3 };
+            var group = new ObservableGroup<string, int>("key", source);
+            ((INotifyCollectionChanged)group).CollectionChanged += (s, e) => collectionChangedEventRaised = true;
+
+            group.Add(4);
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 1, 2, 3, 4 }, option => option.WithStrictOrdering());
+            collectionChangedEventRaised.Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Update_ShouldRaiseEvent()
+        {
+            var collectionChangedEventRaised = false;
+            var source = new[] { 1, 2, 3 };
+            var group = new ObservableGroup<string, int>("key", source);
+            ((INotifyCollectionChanged)group).CollectionChanged += (s, e) => collectionChangedEventRaised = true;
+
+            group[1] = 4;
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 1, 4, 3 }, option => option.WithStrictOrdering());
+            collectionChangedEventRaised.Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Remove_ShouldRaiseEvent()
+        {
+            var collectionChangedEventRaised = false;
+            var source = new[] { 1, 2, 3 };
+            var group = new ObservableGroup<string, int>("key", source);
+            ((INotifyCollectionChanged)group).CollectionChanged += (s, e) => collectionChangedEventRaised = true;
+
+            group.Remove(1);
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 2, 3 }, option => option.WithStrictOrdering());
+            collectionChangedEventRaised.Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Clear_ShouldRaiseEvent()
+        {
+            var collectionChangedEventRaised = false;
+            var source = new[] { 1, 2, 3 };
+            var group = new ObservableGroup<string, int>("key", source);
+            ((INotifyCollectionChanged)group).CollectionChanged += (s, e) => collectionChangedEventRaised = true;
+
+            group.Clear();
+
+            group.Key.Should().Be("key");
+            group.Should().BeEmpty();
+            collectionChangedEventRaised.Should().BeTrue();
+        }
+    }
+}
diff --git a/UnitTests/Observables/ObservableGroupedCollectionTests.cs b/UnitTests/Observables/ObservableGroupedCollectionTests.cs
new file mode 100644
index 00000000000..c43d14dc072
--- /dev/null
+++ b/UnitTests/Observables/ObservableGroupedCollectionTests.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using FluentAssertions;
+using Microsoft.Toolkit.Observables.Collections;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnitTests.Observables
+{
+    [TestClass]
+    public class ObservableGroupedCollectionTests
+    {
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Ctor_ShouldHaveExpectedValues()
+        {
+            var groupCollection = new ObservableGroupedCollection<string, int>();
+
+            groupCollection.Should().BeEmpty();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Ctor_WithGroups_ShouldHaveExpectedValues()
+        {
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", new[] { 1, 3, 5 }),
+                new IntGroup("B", new[] { 2, 4, 6 }),
+            };
+            var groupCollection = new ObservableGroupedCollection<string, int>(groups);
+
+            groupCollection.Should().HaveCount(2);
+            groupCollection.ElementAt(0).Key.Should().Be("A");
+            groupCollection.ElementAt(0).Should().BeEquivalentTo(new[] { 1, 3, 5 }, o => o.WithStrictOrdering());
+            groupCollection.ElementAt(1).Key.Should().Be("B");
+            groupCollection.ElementAt(1).Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithStrictOrdering());
+        }
+    }
+}
diff --git a/UnitTests/Observables/ReadOnlyObservableGroupTests.cs b/UnitTests/Observables/ReadOnlyObservableGroupTests.cs
new file mode 100644
index 00000000000..667a4a4db88
--- /dev/null
+++ b/UnitTests/Observables/ReadOnlyObservableGroupTests.cs
@@ -0,0 +1,107 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using FluentAssertions;
+using Microsoft.Toolkit.Observables.Collections;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+
+namespace UnitTests.Observables
+{
+    [TestClass]
+    public class ReadOnlyObservableGroupTests
+    {
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Ctor_WithKeyAndCollection_ShouldHaveExpectedInitialState()
+        {
+            var source = new ObservableCollection<int>(new[] { 1, 2, 3 });
+            var group = new ReadOnlyObservableGroup<string, int>("key", source);
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Ctor_ObservableGroup_ShouldHaveExpectedInitialState()
+        {
+            var source = new[] { 1, 2, 3 };
+            var sourceGroup = new ObservableGroup<string, int>("key", source);
+            var group = new ReadOnlyObservableGroup<string, int>(sourceGroup);
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Add_ShouldRaiseEvent()
+        {
+            var collectionChangedEventRaised = false;
+            var source = new[] { 1, 2, 3 };
+            var sourceGroup = new ObservableGroup<string, int>("key", source);
+            var group = new ReadOnlyObservableGroup<string, int>(sourceGroup);
+            ((INotifyCollectionChanged)group).CollectionChanged += (s, e) => collectionChangedEventRaised = true;
+
+            sourceGroup.Add(4);
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 1, 2, 3, 4 }, option => option.WithStrictOrdering());
+            collectionChangedEventRaised.Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Update_ShouldRaiseEvent()
+        {
+            var collectionChangedEventRaised = false;
+            var source = new[] { 1, 2, 3 };
+            var sourceGroup = new ObservableGroup<string, int>("key", source);
+            var group = new ReadOnlyObservableGroup<string, int>(sourceGroup);
+            ((INotifyCollectionChanged)group).CollectionChanged += (s, e) => collectionChangedEventRaised = true;
+
+            sourceGroup[1] = 4;
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 1, 4, 3 }, option => option.WithStrictOrdering());
+            collectionChangedEventRaised.Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Remove_ShouldRaiseEvent()
+        {
+            var collectionChangedEventRaised = false;
+            var source = new[] { 1, 2, 3 };
+            var sourceGroup = new ObservableGroup<string, int>("key", source);
+            var group = new ReadOnlyObservableGroup<string, int>(sourceGroup);
+            ((INotifyCollectionChanged)group).CollectionChanged += (s, e) => collectionChangedEventRaised = true;
+
+            sourceGroup.Remove(1);
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 2, 3 }, option => option.WithStrictOrdering());
+            collectionChangedEventRaised.Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Clear_ShouldRaiseEvent()
+        {
+            var collectionChangedEventRaised = false;
+            var source = new[] { 1, 2, 3 };
+            var sourceGroup = new ObservableGroup<string, int>("key", source);
+            var group = new ReadOnlyObservableGroup<string, int>(sourceGroup);
+            ((INotifyCollectionChanged)group).CollectionChanged += (s, e) => collectionChangedEventRaised = true;
+
+            sourceGroup.Clear();
+
+            group.Key.Should().Be("key");
+            group.Should().BeEmpty();
+            collectionChangedEventRaised.Should().BeTrue();
+        }
+    }
+}
diff --git a/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs b/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
new file mode 100644
index 00000000000..8395f96e822
--- /dev/null
+++ b/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
@@ -0,0 +1,240 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using FluentAssertions;
+using Microsoft.Toolkit.Observables.Collections;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Linq;
+
+namespace UnitTests.Observables
+{
+    [TestClass]
+    public class ReadOnlyObservableGroupedCollectionTests
+    {
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Ctor_WithEmptySource_ShoudInitializeObject()
+        {
+            var source = new ObservableGroupedCollection<string, int>();
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+
+            readOnlyGroup.Should().BeEmpty();
+            readOnlyGroup.Count.Should().Be(0);
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void Ctor_WithSource_ShoudInitializeObject()
+        {
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", new[] { 1, 3, 5 }),
+                new IntGroup("B", new[] { 2, 4, 6 }),
+            };
+            var source = new ObservableGroupedCollection<string, int>(groups);
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+
+            readOnlyGroup.Should().HaveCount(2);
+            readOnlyGroup.Count.Should().Be(2);
+            readOnlyGroup.ElementAt(0).Key.Should().Be("A");
+            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(new[] { 1, 3, 5 }, o => o.WithoutStrictOrdering());
+            readOnlyGroup.ElementAt(1).Key.Should().Be("B");
+            readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithoutStrictOrdering());
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void AddGroupInSource_ShouldAddGroup()
+        {
+            NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var isCountPropertyChangedEventRaised = false;
+            var itemsList = new[] { 1, 2, 3 };
+            var source = new ObservableGroupedCollection<string, int>();
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
+
+            source.Add(new ObservableGroup<string, int>("Add", itemsList));
+
+            readOnlyGroup.Should().ContainSingle();
+            readOnlyGroup.Count.Should().Be(1);
+            readOnlyGroup.ElementAt(0).Key.Should().Be("Add");
+            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(itemsList, o => o.WithoutStrictOrdering());
+
+            isCountPropertyChangedEventRaised.Should().BeTrue();
+            collectionChangedEventArgs.Should().NotBeNull();
+            IsAddEventValid(collectionChangedEventArgs, itemsList).Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void RemoveGroupInSource_ShoudRemoveGroup()
+        {
+            NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var isCountPropertyChangedEventRaised = false;
+            var aItemsList = new[] { 1, 2, 3 };
+            var bItemsList = new[] { 2, 4, 6 };
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", aItemsList),
+                new IntGroup("B", bItemsList),
+            };
+            var source = new ObservableGroupedCollection<string, int>(groups);
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
+
+            source.RemoveAt(0);
+
+            readOnlyGroup.Should().ContainSingle();
+            readOnlyGroup.Count.Should().Be(1);
+            readOnlyGroup.ElementAt(0).Key.Should().Be("B");
+            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(bItemsList, o => o.WithoutStrictOrdering());
+
+            isCountPropertyChangedEventRaised.Should().BeTrue();
+            collectionChangedEventArgs.Should().NotBeNull();
+            IsRemoveEventValid(collectionChangedEventArgs, aItemsList).Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void MoveGroupInSource_ShoudMoveGroup()
+        {
+            NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var isCountPropertyChangedEventRaised = false;
+            var aItemsList = new[] { 1, 2, 3 };
+            var bItemsList = new[] { 2, 4, 6 };
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", aItemsList),
+                new IntGroup("B", bItemsList),
+            };
+            var source = new ObservableGroupedCollection<string, int>(groups);
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
+
+            source.Move(1, 0);
+
+            readOnlyGroup.Should().HaveCount(2);
+            readOnlyGroup.Count.Should().Be(2);
+            readOnlyGroup.ElementAt(0).Key.Should().Be("B");
+            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(bItemsList, o => o.WithoutStrictOrdering());
+            readOnlyGroup.ElementAt(1).Key.Should().Be("A");
+            readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(aItemsList, o => o.WithoutStrictOrdering());
+
+            isCountPropertyChangedEventRaised.Should().BeFalse();
+            collectionChangedEventArgs.Should().NotBeNull();
+            IsMoveEventValid(collectionChangedEventArgs, bItemsList, 1, 0).Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void ClearSource_ShoudClear()
+        {
+            NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var isCountPropertyChangedEventRaised = false;
+            var aItemsList = new[] { 1, 2, 3 };
+            var bItemsList = new[] { 2, 4, 6 };
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", aItemsList),
+                new IntGroup("B", bItemsList),
+            };
+            var source = new ObservableGroupedCollection<string, int>(groups);
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
+
+            source.Clear();
+
+            readOnlyGroup.Should().BeEmpty();
+            readOnlyGroup.Count.Should().Be(0);
+
+            isCountPropertyChangedEventRaised.Should().BeTrue();
+            collectionChangedEventArgs.Should().NotBeNull();
+            IsResetEventValid(collectionChangedEventArgs).Should().BeTrue();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void ReplaceGroupInSource_ShoudReplaceGroup()
+        {
+            NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var isCountPropertyChangedEventRaised = false;
+            var aItemsList = new[] { 1, 2, 3 };
+            var bItemsList = new[] { 2, 4, 6 };
+            var cItemsList = new[] { 7, 8, 9 };
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", aItemsList),
+                new IntGroup("B", bItemsList),
+            };
+            var source = new ObservableGroupedCollection<string, int>(groups);
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
+
+            source[0] = new ObservableGroup<string, int>("C", cItemsList);
+
+            readOnlyGroup.Should().HaveCount(2);
+            readOnlyGroup.Count.Should().Be(2);
+            readOnlyGroup.ElementAt(0).Key.Should().Be("C");
+            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(cItemsList, o => o.WithoutStrictOrdering());
+            readOnlyGroup.ElementAt(1).Key.Should().Be("B");
+            readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(bItemsList, o => o.WithoutStrictOrdering());
+
+            isCountPropertyChangedEventRaised.Should().BeFalse();
+            collectionChangedEventArgs.Should().NotBeNull();
+            IsReplaceEventValid(collectionChangedEventArgs, aItemsList, cItemsList).Should().BeTrue();
+        }
+
+        private static bool IsAddEventValid(NotifyCollectionChangedEventArgs args, IEnumerable<int> expectedGroupItems)
+        {
+            var newItems = args.NewItems?.Cast<IEnumerable<int>>();
+            return args.Action == NotifyCollectionChangedAction.Add &&
+                    args.OldItems == null &&
+                    newItems?.Count() == 1 &&
+                    Enumerable.SequenceEqual(newItems.ElementAt(0), expectedGroupItems);
+        }
+
+        private static bool IsRemoveEventValid(NotifyCollectionChangedEventArgs args, IEnumerable<int> expectedGroupItems)
+        {
+            var oldItems = args.OldItems?.Cast<IEnumerable<int>>();
+            return args.Action == NotifyCollectionChangedAction.Remove &&
+                args.NewItems == null &&
+                    oldItems?.Count() == 1 &&
+                    Enumerable.SequenceEqual(oldItems.ElementAt(0), expectedGroupItems);
+        }
+
+        private static bool IsMoveEventValid(NotifyCollectionChangedEventArgs args, IEnumerable<int> expectedGroupItems, int oldIndex, int newIndex)
+        {
+            var oldItems = args.OldItems?.Cast<IEnumerable<int>>();
+            var newItems = args.NewItems?.Cast<IEnumerable<int>>();
+            return args.Action == NotifyCollectionChangedAction.Move &&
+                    args.OldStartingIndex == oldIndex &&
+                    args.NewStartingIndex == newIndex &&
+                    oldItems?.Count() == 1 &&
+                    Enumerable.SequenceEqual(oldItems.ElementAt(0), expectedGroupItems) &&
+                    newItems?.Count() == 1 &&
+                    Enumerable.SequenceEqual(newItems.ElementAt(0), expectedGroupItems);
+        }
+
+        private static bool IsReplaceEventValid(NotifyCollectionChangedEventArgs args, IEnumerable<int> expectedRemovedItems, IEnumerable<int> expectedAddItems)
+        {
+            var oldItems = args.OldItems?.Cast<IEnumerable<int>>();
+            var newItems = args.NewItems?.Cast<IEnumerable<int>>();
+            return args.Action == NotifyCollectionChangedAction.Replace &&
+                    oldItems?.Count() == 1 &&
+                    Enumerable.SequenceEqual(oldItems.ElementAt(0), expectedRemovedItems) &&
+                    newItems?.Count() == 1 &&
+                    Enumerable.SequenceEqual(newItems.ElementAt(0), expectedAddItems);
+        }
+
+        private static bool IsResetEventValid(NotifyCollectionChangedEventArgs args) => args.Action == NotifyCollectionChangedAction.Reset && args.NewItems == null && args.OldItems == null;
+    }
+}
diff --git a/UnitTests/UnitTests.csproj b/UnitTests/UnitTests.csproj
index b4208dc4fef..8e11eafd391 100644
--- a/UnitTests/UnitTests.csproj
+++ b/UnitTests/UnitTests.csproj
@@ -113,6 +113,9 @@
     <SDKReference Include="TestPlatform.Universal, Version=$(UnitTestPlatformVersion)" />
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="FluentAssertions">
+      <Version>5.10.2</Version>
+    </PackageReference>
     <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform">
       <Version>6.2.9</Version>
     </PackageReference>
@@ -168,6 +171,11 @@
     <Compile Include="Markdown\Parse\SuperscriptTests.cs" />
     <Compile Include="Markdown\Parse\TableTests.cs" />
     <Compile Include="Markdown\TestBase.cs" />
+    <Compile Include="Observables\IntGroup.cs" />
+    <Compile Include="Observables\ObservableGroupedCollectionTests.cs" />
+    <Compile Include="Observables\ObservableGroupTests.cs" />
+    <Compile Include="Observables\ReadOnlyObservableGroupedCollectionTests.cs" />
+    <Compile Include="Observables\ReadOnlyObservableGroupTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Helpers\Test_WeakEventListener.cs" />
     <Compile Include="UI\Controls\Test_UniformGrid_AutoLayout.cs" />

From 3ac2a8c67b31c9308c2c2a5c9448fd3493e6bbbe Mon Sep 17 00:00:00 2001
From: Ze Groumf <zeGroumf@hotmail.com>
Date: Wed, 25 Mar 2020 00:08:51 +0100
Subject: [PATCH 03/13] First drop of sample page

---
 .../Microsoft.Toolkit.Uwp.SampleApp.csproj    |  8 ++++
 .../ObservableGroup/ObservableGroup.bind      | 46 +++++++++++++++++++
 .../ObservableGroup/ObservableGroupPage.xaml  | 15 ++++++
 .../ObservableGroupPage.xaml.cs               | 29 ++++++++++++
 .../SamplePages/samples.json                  | 10 ++++
 5 files changed, 108 insertions(+)
 create mode 100644 Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind
 create mode 100644 Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
 create mode 100644 Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs

diff --git a/Microsoft.Toolkit.Uwp.SampleApp/Microsoft.Toolkit.Uwp.SampleApp.csproj b/Microsoft.Toolkit.Uwp.SampleApp/Microsoft.Toolkit.Uwp.SampleApp.csproj
index d95e24c902f..c3dbbecb531 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/Microsoft.Toolkit.Uwp.SampleApp.csproj
+++ b/Microsoft.Toolkit.Uwp.SampleApp/Microsoft.Toolkit.Uwp.SampleApp.csproj
@@ -528,6 +528,9 @@
     <Compile Include="SamplePages\ImageEx\ImageExLazyLoadingControl.xaml.cs">
       <DependentUpon>ImageExLazyLoadingControl.xaml</DependentUpon>
     </Compile>
+    <Compile Include="SamplePages\ObservableGroup\ObservableGroupPage.xaml.cs">
+      <DependentUpon>ObservableGroupPage.xaml</DependentUpon>
+    </Compile>
     <Compile Include="SamplePages\OnDevice\OnDevicePage.xaml.cs">
       <DependentUpon>OnDevicePage.xaml</DependentUpon>
     </Compile>
@@ -552,6 +555,7 @@
     <Content Include="SamplePages\Eyedropper\EyedropperXaml.bind" />
     <Content Include="SamplePages\Eyedropper\EyedropperCode.bind" />
     <Content Include="SamplePages\TokenizingTextBox\TokenizingTextBoxCode.bind" />
+    <Content Include="SamplePages\ObservableGroup\ObservableGroup.bind" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="App.xaml.cs">
@@ -942,6 +946,10 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="SamplePages\ObservableGroup\ObservableGroupPage.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="SamplePages\OnDevice\OnDevicePage.xaml">
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind
new file mode 100644
index 00000000000..08a38a9fea5
--- /dev/null
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind
@@ -0,0 +1,46 @@
+// Creates a CollectionView that can sort and filter items.
+using Microsoft.Toolkit.Uwp.UI;
+
+// Grab a sample type
+public class Person
+{
+    public string Name { get; set; }
+}
+
+// Set up the original list with a few sample items
+
+var oc = new ObservableCollection<Person>
+{
+    new Person { Name = "Staff" },
+    new Person { Name = "42" },
+    new Person { Name = "Swan" },
+    new Person { Name = "Orchid" },
+    new Person { Name = "15" },
+    new Person { Name = "Flame" },
+    new Person { Name = "16" },
+    new Person { Name = "Arrow" },
+    new Person { Name = "Tempest" },
+    new Person { Name = "23" },
+    new Person { Name = "Pearl" },
+    new Person { Name = "Hydra" },
+    new Person { Name = "Lamp Post" },
+    new Person { Name = "4" },
+    new Person { Name = "Looking Glass" },
+    new Person { Name = "8" },
+};
+
+// Set up the AdvancedCollectionView to filter and sort the original list
+
+var acv = new AdvancedCollectionView(oc);
+
+// Let's filter out the integers
+int nul;
+acv.Filter = x => !int.TryParse(((Person)x).Name, out nul);
+
+// And sort ascending by the property "Name"
+acv.SortDescriptions.Add(new SortDescription("Name", SortDirection.Ascending));
+
+// AdvancedCollectionView can be bound to anything that uses collections. In this case there are two ListViews, one for the original and one for the filtered-sorted list.
+
+LeftList.ItemsSource = oc;
+RightList.ItemsSource = acv;
\ No newline at end of file
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
new file mode 100644
index 00000000000..62bca0c4a8e
--- /dev/null
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
@@ -0,0 +1,15 @@
+<Page x:Class="Microsoft.Toolkit.Uwp.SampleApp.SamplePages.ObservableGroupPage"
+      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+      xmlns:local="using:Microsoft.Toolkit.Uwp.SampleApp.SamplePages"
+      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+      Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
+      mc:Ignorable="d">
+
+    <Grid>
+        <TextBlock HorizontalAlignment="Center"
+                   VerticalAlignment="Center"
+                   Text="My page" />
+    </Grid>
+</Page>
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
new file mode 100644
index 00000000000..29ce002291f
--- /dev/null
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices.WindowsRuntime;
+using Windows.Foundation;
+using Windows.Foundation.Collections;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Controls.Primitives;
+using Windows.UI.Xaml.Data;
+using Windows.UI.Xaml.Input;
+using Windows.UI.Xaml.Media;
+using Windows.UI.Xaml.Navigation;
+
+namespace Microsoft.Toolkit.Uwp.SampleApp.SamplePages
+{
+    /// <summary>
+    /// The sample page for the observable group collections.
+    /// </summary>
+    public sealed partial class ObservableGroupPage : Page
+    {
+        public ObservableGroupPage() => InitializeComponent();
+    }
+}
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/samples.json b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/samples.json
index 22cef444cca..c69aa6bed36 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/samples.json
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/samples.json
@@ -810,6 +810,16 @@
         "Icon": "/SamplePages/AdvancedCollectionView/AdvancedCollectionView.png",
         "DocumentationUrl": "https://raw.githubusercontent.com/MicrosoftDocs/WindowsCommunityToolkitDocs/master/docs/helpers/AdvancedCollectionView.md"
       },
+      {
+        "Name": "ObservableGroup",
+        "Type": "ObservableGroupPage",
+        "Subcategory": "Data",
+        "About": "Allows you to easily create observable grouped collections.",
+        "CodeUrl": "https://github.com/windows-toolkit/WindowsCommunityToolkit/tree/master/Microsoft.Toolkit/ObservableGroup",
+        "CodeFile": "ObservableGroup.bind",
+        "Icon": "/Assets/Helpers.png",
+        "DocumentationUrl": "https://raw.githubusercontent.com/MicrosoftDocs/WindowsCommunityToolkitDocs/master/docs/helpers/ObservableGroup.md"
+      },
       {
         "Name": "CameraHelper",
         "Type": "CameraHelperPage",

From b84328811bf7037df3c4cfc5e006dc3f7a5babfb Mon Sep 17 00:00:00 2001
From: Ze Groumf <zeGroumf@hotmail.com>
Date: Thu, 26 Mar 2020 00:18:16 +0100
Subject: [PATCH 04/13] updated sample and fixed ReadOnlyGroupedCollection
 implementation

---
 .../ObservableGroup/ObservableGroupPage.xaml  | 54 ++++++++++++-
 .../ObservableGroupPage.xaml.cs               | 81 ++++++++++++++++---
 .../ReadOnlyObservableGroupedCollection.cs    | 57 ++++++++++++-
 ...eadOnlyObservableGroupedCollectionTests.cs | 13 +--
 4 files changed, 180 insertions(+), 25 deletions(-)

diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
index 62bca0c4a8e..5b5228183cf 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
@@ -7,9 +7,57 @@
       Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
       mc:Ignorable="d">
 
+    <Page.Resources>
+        <Style TargetType="Button">
+            <Setter Property="Margin" Value="8,0" />
+        </Style>
+
+        <DataTemplate x:Key="PersonDataTemplate">
+            <TextBlock Text="{Binding Name}" />
+        </DataTemplate>
+
+        <DataTemplate x:Key="GroupDataTemplate">
+            <TextBlock Style="{StaticResource SubtitleTextBlockStyle}"
+                       Text="{Binding Key}" />
+        </DataTemplate>
+
+        <CollectionViewSource x:Key="cvs"
+                              x:Name="cvs"
+                              IsSourceGrouped="True"
+                              Source="{x:Bind Contacts}" />
+    </Page.Resources>
+
     <Grid>
-        <TextBlock HorizontalAlignment="Center"
-                   VerticalAlignment="Center"
-                   Text="My page" />
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+        </Grid.RowDefinitions>
+
+        <StackPanel Margin="0,4"
+                    HorizontalAlignment="Center"
+                    Orientation="Horizontal">
+            <TextBox x:Name="NewContact"
+                     PlaceholderText="New contact"
+                     TextChanged="OnNewContactTextChanged" />
+            <Button x:Name="AddContact"
+                    Click="OnAddContactClick"
+                    Content="Add"
+                    IsEnabled="False" />
+            <Button x:Name="RemoveContact"
+                    Click="OnRemoveButtonClick"
+                    Content="Remove selected"
+                    IsEnabled="False" />
+        </StackPanel>
+
+        <ListView x:Name="ContactsListView"
+                  Grid.Row="1"
+                  ItemTemplate="{StaticResource PersonDataTemplate}"
+                  ItemsSource="{x:Bind cvs.View}"
+                  SelectionChanged="OnContactsListViewSelectionChanged"
+                  SelectionMode="Single">
+            <ListView.GroupStyle>
+                <GroupStyle HeaderTemplate="{StaticResource GroupDataTemplate}" />
+            </ListView.GroupStyle>
+        </ListView>
     </Grid>
 </Page>
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
index 29ce002291f..b43166cd929 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
@@ -2,20 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
-using System.Collections.Generic;
-using System.IO;
+using Microsoft.Toolkit.Observables.Collections;
 using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
-using Windows.Foundation;
-using Windows.Foundation.Collections;
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;
-using Windows.UI.Xaml.Controls.Primitives;
-using Windows.UI.Xaml.Data;
-using Windows.UI.Xaml.Input;
-using Windows.UI.Xaml.Media;
-using Windows.UI.Xaml.Navigation;
 
 namespace Microsoft.Toolkit.Uwp.SampleApp.SamplePages
 {
@@ -24,6 +14,73 @@ namespace Microsoft.Toolkit.Uwp.SampleApp.SamplePages
     /// </summary>
     public sealed partial class ObservableGroupPage : Page
     {
-        public ObservableGroupPage() => InitializeComponent();
+        private readonly ObservableGroupedCollection<string, Person> _contactsSource;
+
+        public ObservableGroupPage()
+        {
+            var contacts = new[]
+            {
+                new Person { Name = "Staff" },
+                new Person { Name = "Swan" },
+                new Person { Name = "Orchid" },
+                new Person { Name = "Flame" },
+                new Person { Name = "Arrow" },
+                new Person { Name = "Tempest" },
+                new Person { Name = "Pearl" },
+                new Person { Name = "Hydra" },
+                new Person { Name = "Lamp Post" },
+                new Person { Name = "Looking Glass" },
+            };
+            var grouped = contacts.GroupBy(GetGroupName).OrderBy(g => g.Key);
+            _contactsSource = new ObservableGroupedCollection<string, Person>(grouped);
+            Contacts = new ReadOnlyObservableGroupedCollection<string, Person>(_contactsSource);
+
+            InitializeComponent();
+        }
+
+        public ReadOnlyObservableGroupedCollection<string, Person> Contacts { get; }
+
+        private static string GetGroupName(Person person) => person.Name.First().ToString().ToUpper();
+
+        private void OnContactsListViewSelectionChanged(object sender, SelectionChangedEventArgs e) => RemoveContact.IsEnabled = ContactsListView.SelectedItem is Person;
+
+        private void OnRemoveButtonClick(object sender, RoutedEventArgs e)
+        {
+            var selectedContact = (Person)ContactsListView.SelectedItem;
+            var selectedGroupName = GetGroupName(selectedContact);
+            var selectedGroup = _contactsSource.FirstOrDefault(group => group.Key == selectedGroupName);
+            if (selectedGroup != null)
+            {
+                selectedGroup.Remove(selectedContact);
+                if (!selectedGroup.Any())
+                {
+                    // The group is empty. We can remove it.
+                    _contactsSource.Remove(selectedGroup);
+                }
+            }
+        }
+
+        private void OnAddContactClick(object sender, RoutedEventArgs e)
+        {
+            var newContact = new Person
+            {
+                Name = NewContact.Text.Trim(),
+            };
+
+            var groupName = GetGroupName(newContact);
+            var targetGroup = _contactsSource.FirstOrDefault(group => group.Key == groupName);
+            if (targetGroup is null)
+            {
+                _contactsSource.Add(new ObservableGroup<string, Person>(groupName, new[] { newContact }));
+            }
+            else
+            {
+                targetGroup.Add(newContact);
+            }
+
+            NewContact.Text = string.Empty;
+        }
+
+        private void OnNewContactTextChanged(object sender, TextChangedEventArgs e) => AddContact.IsEnabled = !string.IsNullOrEmpty(NewContact.Text.Trim());
     }
 }
diff --git a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
index 74ca7c60fca..d4f855226df 100644
--- a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
+++ b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
@@ -20,7 +21,9 @@ public sealed class ReadOnlyObservableGroupedCollection<TKey, TValue> :
         IReadOnlyCollection<ReadOnlyObservableGroup<TKey, TValue>>,
         IReadOnlyList<ReadOnlyObservableGroup<TKey, TValue>>,
         INotifyPropertyChanged,
-        INotifyCollectionChanged
+        INotifyCollectionChanged,
+        ICollection,    // Implementing IColletion and IList is needed to allow ListView to monitor the INotifyCollectionChanged events...
+        IList
     {
         private readonly ObservableGroupedCollection<TKey, TValue> _collection;
         private readonly IDictionary<ObservableGroup<TKey, TValue>, ReadOnlyObservableGroup<TKey, TValue>> _mapping;
@@ -59,14 +62,14 @@ public ReadOnlyObservableGroupedCollection(ObservableGroupedCollection<TKey, TVa
         private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
             // We force the evaluation to have all our instances ready before deleting the mapping.
-            var sourceOldItems = e.OldItems?.Cast<ObservableGroup<TKey, TValue>>() ?? Enumerable.Empty<ObservableGroup<TKey, TValue>>();
+            var sourceOldItems = (e.OldItems?.Cast<ObservableGroup<TKey, TValue>>() ?? Enumerable.Empty<ObservableGroup<TKey, TValue>>()).ToList();
             var oldItems = (IList)sourceOldItems.Select(CreateOrGetReadOnlyObservableGroup).ToList();
             var newItems = (IList)(e.NewItems?.Cast<ObservableGroup<TKey, TValue>>().Select(CreateOrGetReadOnlyObservableGroup) ?? Enumerable.Empty<ReadOnlyObservableGroup<TKey, TValue>>()).ToList();
 
             switch (e.Action)
             {
                 case NotifyCollectionChangedAction.Add:
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, newItems));
+                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, newItems, e.NewStartingIndex));
                     break;
                 case NotifyCollectionChangedAction.Move:
                     CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, newItems, e.NewStartingIndex, e.OldStartingIndex));
@@ -77,7 +80,8 @@ private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs
                     {
                         _mapping.Remove(sourceOldItem);
                     }
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, oldItems));
+
+                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, oldItems, e.OldStartingIndex));
                     break;
                 case NotifyCollectionChangedAction.Replace:
                     // We unmap the removed or replaced items.
@@ -85,6 +89,7 @@ private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs
                     {
                         _mapping.Remove(sourceOldItem);
                     }
+
                     CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, newItems, oldItems));
                     break;
                 case NotifyCollectionChangedAction.Reset:
@@ -111,5 +116,49 @@ private ReadOnlyObservableGroup<TKey, TValue> CreateOrGetReadOnlyObservableGroup
 
             return readOnlyGroup;
         }
+
+        int ICollection.Count => _collection.Count;
+
+        bool ICollection.IsSynchronized => ((ICollection)_collection).IsSynchronized;
+
+        object ICollection.SyncRoot
+        {
+            get
+            {
+                var sourceSyncRoot = ((ICollection)_collection).SyncRoot;
+                if (sourceSyncRoot is null)
+                {
+                    return null;
+                }
+
+                return CreateOrGetReadOnlyObservableGroup((ObservableGroup<TKey, TValue>)sourceSyncRoot);
+            }
+        }
+
+        bool IList.IsFixedSize => ((IList)_collection).IsFixedSize;
+
+        bool IList.IsReadOnly => true;
+
+        object IList.this[int index]
+        {
+            get => CreateOrGetReadOnlyObservableGroup(_collection[index]);
+            set => throw new NotImplementedException();
+        }
+
+        void ICollection.CopyTo(Array array, int index) => throw new NotImplementedException();
+
+        int IList.Add(object value) => throw new NotImplementedException();
+
+        void IList.Clear() => throw new NotImplementedException();
+
+        bool IList.Contains(object value) => this.Any(group => group == value);
+
+        int IList.IndexOf(object value) => this.Select((group, i) => (group == value) ? i : -1).Max();
+
+        void IList.Insert(int index, object value) => throw new NotImplementedException();
+
+        void IList.Remove(object value) => throw new NotImplementedException();
+
+        void IList.RemoveAt(int index) => throw new NotImplementedException();
     }
 }
diff --git a/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs b/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
index 8395f96e822..ff249086895 100644
--- a/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
+++ b/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
@@ -88,16 +88,16 @@ public void RemoveGroupInSource_ShoudRemoveGroup()
             ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
             ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
 
-            source.RemoveAt(0);
+            source.RemoveAt(1);
 
             readOnlyGroup.Should().ContainSingle();
             readOnlyGroup.Count.Should().Be(1);
-            readOnlyGroup.ElementAt(0).Key.Should().Be("B");
-            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(bItemsList, o => o.WithoutStrictOrdering());
+            readOnlyGroup.ElementAt(0).Key.Should().Be("A");
+            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(aItemsList, o => o.WithoutStrictOrdering());
 
             isCountPropertyChangedEventRaised.Should().BeTrue();
             collectionChangedEventArgs.Should().NotBeNull();
-            IsRemoveEventValid(collectionChangedEventArgs, aItemsList).Should().BeTrue();
+            IsRemoveEventValid(collectionChangedEventArgs, bItemsList, 1).Should().BeTrue();
         }
 
         [TestCategory("Observables")]
@@ -202,11 +202,12 @@ private static bool IsAddEventValid(NotifyCollectionChangedEventArgs args, IEnum
                     Enumerable.SequenceEqual(newItems.ElementAt(0), expectedGroupItems);
         }
 
-        private static bool IsRemoveEventValid(NotifyCollectionChangedEventArgs args, IEnumerable<int> expectedGroupItems)
+        private static bool IsRemoveEventValid(NotifyCollectionChangedEventArgs args, IEnumerable<int> expectedGroupItems, int oldIndex)
         {
             var oldItems = args.OldItems?.Cast<IEnumerable<int>>();
             return args.Action == NotifyCollectionChangedAction.Remove &&
-                args.NewItems == null &&
+                    args.NewItems == null &&
+                    args.OldStartingIndex == oldIndex &&
                     oldItems?.Count() == 1 &&
                     Enumerable.SequenceEqual(oldItems.ElementAt(0), expectedGroupItems);
         }

From 578bee90a8b3ec395c9132c6ecf4474185c9d364 Mon Sep 17 00:00:00 2001
From: Ze Groumf <zeGroumf@hotmail.com>
Date: Thu, 26 Mar 2020 22:40:04 +0100
Subject: [PATCH 05/13] add IList tests

---
 .../ReadOnlyObservableGroupedCollection.cs    |  22 +---
 ...eadOnlyObservableGroupedCollectionTests.cs | 115 ++++++++++++++++++
 2 files changed, 121 insertions(+), 16 deletions(-)

diff --git a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
index d4f855226df..09e391761f5 100644
--- a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
+++ b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
@@ -48,7 +48,7 @@ public ReadOnlyObservableGroupedCollection(ObservableGroupedCollection<TKey, TVa
         }
 
         /// <inheritdoc/>
-        public ReadOnlyObservableGroup<TKey, TValue> this[int index] => CreateOrGetReadOnlyObservableGroup(_collection[index]);
+        public ReadOnlyObservableGroup<TKey, TValue> this[int index] => GetGroupAt(index);
 
         /// <inheritdoc/>
         public int Count => _collection.Count;
@@ -117,23 +117,13 @@ private ReadOnlyObservableGroup<TKey, TValue> CreateOrGetReadOnlyObservableGroup
             return readOnlyGroup;
         }
 
-        int ICollection.Count => _collection.Count;
+        private ReadOnlyObservableGroup<TKey, TValue> GetGroupAt(int index) => CreateOrGetReadOnlyObservableGroup(_collection[index]);
 
-        bool ICollection.IsSynchronized => ((ICollection)_collection).IsSynchronized;
+        int ICollection.Count => _collection.Count;
 
-        object ICollection.SyncRoot
-        {
-            get
-            {
-                var sourceSyncRoot = ((ICollection)_collection).SyncRoot;
-                if (sourceSyncRoot is null)
-                {
-                    return null;
-                }
+        bool ICollection.IsSynchronized => false;
 
-                return CreateOrGetReadOnlyObservableGroup((ObservableGroup<TKey, TValue>)sourceSyncRoot);
-            }
-        }
+        object ICollection.SyncRoot => this;
 
         bool IList.IsFixedSize => ((IList)_collection).IsFixedSize;
 
@@ -141,7 +131,7 @@ object ICollection.SyncRoot
 
         object IList.this[int index]
         {
-            get => CreateOrGetReadOnlyObservableGroup(_collection[index]);
+            get => GetGroupAt(index);
             set => throw new NotImplementedException();
         }
 
diff --git a/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs b/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
index ff249086895..99f0598da46 100644
--- a/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
+++ b/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
@@ -5,7 +5,10 @@
 using FluentAssertions;
 using Microsoft.Toolkit.Observables.Collections;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Linq;
@@ -46,6 +49,118 @@ public void Ctor_WithSource_ShoudInitializeObject()
             readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithoutStrictOrdering());
         }
 
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void IListImplementation_Properties_ShoudReturnExpectedValues()
+        {
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", new[] { 1, 3, 5 }),
+                new IntGroup("B", new[] { 2, 4, 6 }),
+            };
+            var source = new ObservableGroupedCollection<string, int>(groups);
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            var list = (IList)readOnlyGroup;
+
+            list.Count.Should().Be(2);
+            var group0 = (ReadOnlyObservableGroup<string, int>)list[0];
+            group0.Key.Should().Be("A");
+            group0.Should().BeEquivalentTo(new[] { 1, 3, 5 }, o => o.WithoutStrictOrdering());
+            var group1 = (ReadOnlyObservableGroup<string, int>)list[1];
+            group1.Key.Should().Be("B");
+            group1.Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithoutStrictOrdering());
+
+            list.SyncRoot.Should().BeSameAs(readOnlyGroup);
+            list.IsFixedSize.Should().BeFalse();
+            list.IsReadOnly.Should().BeTrue();
+            list.IsSynchronized.Should().BeFalse();
+        }
+
+        [TestCategory("Observables")]
+        [TestMethod]
+        public void IListImplementation_MutableMethods_ShoudThrow()
+        {
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", new[] { 1, 3, 5 }),
+                new IntGroup("B", new[] { 2, 4, 6 }),
+            };
+            var source = new ObservableGroupedCollection<string, int>(groups);
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            var list = (IList)readOnlyGroup;
+
+            var testGroup = new ReadOnlyObservableGroup<string, int>("test", new ObservableCollection<int>());
+            Action add = () => list.Add(testGroup);
+            add.Should().Throw<NotImplementedException>();
+
+            Action clear = () => list.Clear();
+            clear.Should().Throw<NotImplementedException>();
+
+            Action insert = () => list.Insert(2, testGroup);
+            insert.Should().Throw<NotImplementedException>();
+
+            Action remove = () => list.Remove(testGroup);
+            remove.Should().Throw<NotImplementedException>();
+
+            Action removeAt = () => list.RemoveAt(2);
+            removeAt.Should().Throw<NotImplementedException>();
+
+            Action set = () => list[2] = testGroup;
+            set.Should().Throw<NotImplementedException>();
+
+            var array = new object[5];
+            Action copyTo = () => list.CopyTo(array, 0);
+            copyTo.Should().Throw<NotImplementedException>();
+        }
+
+        [TestCategory("Observables")]
+        [DataTestMethod]
+        [DataRow(-1)]
+        [DataRow(0)]
+        [DataRow(1)]
+        [DataRow(2)]
+        public void IListImplementation_IndexOf_ShoudReturnExpectedValue(int groupIndex)
+        {
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", new[] { 1, 3, 5 }),
+                new IntGroup("B", new[] { 2, 4, 6 }),
+                new IntGroup("C", new[] { 7, 8, 9 }),
+            };
+            var source = new ObservableGroupedCollection<string, int>(groups);
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            var list = (IList)readOnlyGroup;
+
+            var groupToSearch = groupIndex >= 0 ? list[groupIndex] : null;
+
+            var index = list.IndexOf(groupToSearch);
+
+            index.Should().Be(groupIndex);
+        }
+
+        [TestCategory("Observables")]
+        [DataTestMethod]
+        [DataRow(-1, false)]
+        [DataRow(0, true)]
+        [DataRow(1, true)]
+        public void IListImplementation_Contains_ShoudReturnExpectedValue(int groupIndex, bool expectedResult)
+        {
+            var groups = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", new[] { 1, 3, 5 }),
+                new IntGroup("B", new[] { 2, 4, 6 }),
+            };
+            var source = new ObservableGroupedCollection<string, int>(groups);
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            var list = (IList)readOnlyGroup;
+
+            var groupToSearch = groupIndex >= 0 ? list[groupIndex] : null;
+
+            var result = list.Contains(groupToSearch);
+
+            result.Should().Be(expectedResult);
+        }
+
         [TestCategory("Observables")]
         [TestMethod]
         public void AddGroupInSource_ShouldAddGroup()

From 98b4a1cc208cda4ff5998d0fcb9779122f53d4ea Mon Sep 17 00:00:00 2001
From: Ze Groumf <zeGroumf@hotmail.com>
Date: Thu, 26 Mar 2020 23:08:11 +0100
Subject: [PATCH 06/13] Update page layout + sample code.bind

---
 .../ObservableGroup/ObservableGroup.bind      | 39 ++++++++-----------
 .../ObservableGroup/ObservableGroupPage.xaml  |  3 +-
 2 files changed, 18 insertions(+), 24 deletions(-)

diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind
index 08a38a9fea5..2e46d3f0e56 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind
@@ -1,46 +1,39 @@
-// Creates a CollectionView that can sort and filter items.
-using Microsoft.Toolkit.Uwp.UI;
-
-// Grab a sample type
+// Grab a sample type
 public class Person
 {
     public string Name { get; set; }
 }
 
 // Set up the original list with a few sample items
-
-var oc = new ObservableCollection<Person>
+var contacts = new[]
 {
     new Person { Name = "Staff" },
-    new Person { Name = "42" },
     new Person { Name = "Swan" },
     new Person { Name = "Orchid" },
-    new Person { Name = "15" },
     new Person { Name = "Flame" },
-    new Person { Name = "16" },
     new Person { Name = "Arrow" },
     new Person { Name = "Tempest" },
-    new Person { Name = "23" },
     new Person { Name = "Pearl" },
     new Person { Name = "Hydra" },
     new Person { Name = "Lamp Post" },
-    new Person { Name = "4" },
     new Person { Name = "Looking Glass" },
-    new Person { Name = "8" },
 };
 
-// Set up the AdvancedCollectionView to filter and sort the original list
-
-var acv = new AdvancedCollectionView(oc);
+// Group the contacts by first letter
+var grouped = contacts.GroupBy(GetGroupName).OrderBy(g => g.Key);
 
-// Let's filter out the integers
-int nul;
-acv.Filter = x => !int.TryParse(((Person)x).Name, out nul);
+// Create an observable grouped collection
+var contactsSource = new ObservableGroupedCollection<string, Person>(grouped);
 
-// And sort ascending by the property "Name"
-acv.SortDescriptions.Add(new SortDescription("Name", SortDirection.Ascending));
+// Create a read-only observable grouped collection
+var readonlyContacts = new ReadOnlyObservableGroupedCollection<string, Person>(contactsSource);
 
-// AdvancedCollectionView can be bound to anything that uses collections. In this case there are two ListViews, one for the original and one for the filtered-sorted list.
+// Set up the CollectionViewSource
+var cvs = new CollectionViewSource
+{
+    IsSourceGrouped = True,
+    Source = readonlyContacts,
+};
 
-LeftList.ItemsSource = oc;
-RightList.ItemsSource = acv;
\ No newline at end of file
+// Bind the CollectionViewSource to anything that supports grouped collections.
+ContactsList.ItemsSource = cvs.View;
\ No newline at end of file
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
index 5b5228183cf..811c5fa5d6c 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
@@ -9,7 +9,7 @@
 
     <Page.Resources>
         <Style TargetType="Button">
-            <Setter Property="Margin" Value="8,0" />
+            <Setter Property="Margin" Value="8,0,0,0" />
         </Style>
 
         <DataTemplate x:Key="PersonDataTemplate">
@@ -37,6 +37,7 @@
                     HorizontalAlignment="Center"
                     Orientation="Horizontal">
             <TextBox x:Name="NewContact"
+                     MinWidth="200"
                      PlaceholderText="New contact"
                      TextChanged="OnNewContactTextChanged" />
             <Button x:Name="AddContact"

From b8381542e12c3ec860e8fd3d4b0be3259c35e5f1 Mon Sep 17 00:00:00 2001
From: Ze Groumf <zeGroumf@hotmail.com>
Date: Thu, 26 Mar 2020 23:27:13 +0100
Subject: [PATCH 07/13] simplify base constructor call

---
 Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs b/Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs
index 79e7ef7c5d0..561190af0e7 100644
--- a/Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs
+++ b/Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs
@@ -27,7 +27,7 @@ public ObservableGroupedCollection()
         /// </summary>
         /// <param name="collection">The initial data to add in the grouped collection.</param>
         public ObservableGroupedCollection(IEnumerable<IGrouping<TKey, TValue>> collection)
-            : base(collection.Select(c => new ObservableGroup<TKey, TValue>(c.Key, c)))
+            : base(collection.Select(c => new ObservableGroup<TKey, TValue>(c)))
         {
         }
     }

From ec490106c8b391f82b71b30e3a65cb529078eef1 Mon Sep 17 00:00:00 2001
From: Ze Groumf <zeGroumf@hotmail.com>
Date: Mon, 30 Mar 2020 23:13:22 +0200
Subject: [PATCH 08/13] add IReadOnlyObservableGroup interface for x:Bind

---
 .../ObservableGroup/ObservableGroupPage.xaml  | 11 +++++----
 .../ObservableGroupPage.xaml.cs               |  2 +-
 Microsoft.Toolkit/Microsoft.Toolkit.csproj    |  4 ----
 .../Observables/IReadOnlyObservableGroup.cs   | 24 +++++++++++++++++++
 .../Observables/ObservableGroup.cs            |  6 ++++-
 .../Observables/ReadOnlyObservableGroup.cs    |  6 ++++-
 .../ReadOnlyObservableGroupedCollection.cs    |  2 +-
 UnitTests/Observables/ObservableGroupTests.cs | 14 +++++++++++
 .../ReadOnlyObservableGroupTests.cs           | 19 +++++++++++++--
 9 files changed, 74 insertions(+), 14 deletions(-)
 create mode 100644 Microsoft.Toolkit/Observables/IReadOnlyObservableGroup.cs

diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
index 811c5fa5d6c..2a6628b5181 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
@@ -3,6 +3,7 @@
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
       xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
       xmlns:local="using:Microsoft.Toolkit.Uwp.SampleApp.SamplePages"
+      xmlns:observables="using:Microsoft.Toolkit.Observables.Collections"
       xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
       Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
       mc:Ignorable="d">
@@ -12,13 +13,15 @@
             <Setter Property="Margin" Value="8,0,0,0" />
         </Style>
 
-        <DataTemplate x:Key="PersonDataTemplate">
-            <TextBlock Text="{Binding Name}" />
+        <DataTemplate x:Key="PersonDataTemplate"
+                      x:DataType="local:Person">
+            <TextBlock Text="{x:Bind Name}" />
         </DataTemplate>
 
-        <DataTemplate x:Key="GroupDataTemplate">
+        <DataTemplate x:Key="GroupDataTemplate"
+                      x:DataType="observables:IReadOnlyObservableGroup">
             <TextBlock Style="{StaticResource SubtitleTextBlockStyle}"
-                       Text="{Binding Key}" />
+                       Text="{x:Bind (x:String)Key}" />
         </DataTemplate>
 
         <CollectionViewSource x:Key="cvs"
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
index b43166cd929..ce39d378c12 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
@@ -2,8 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Toolkit.Observables.Collections;
 using System.Linq;
+using Microsoft.Toolkit.Observables.Collections;
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;
 
diff --git a/Microsoft.Toolkit/Microsoft.Toolkit.csproj b/Microsoft.Toolkit/Microsoft.Toolkit.csproj
index fe2846fe086..011f95377f7 100644
--- a/Microsoft.Toolkit/Microsoft.Toolkit.csproj
+++ b/Microsoft.Toolkit/Microsoft.Toolkit.csproj
@@ -67,8 +67,4 @@
     </Compile>
   </ItemGroup>
 
-  <ItemGroup>
-    <Folder Include="Observables\" />
-  </ItemGroup>
-
 </Project>
\ No newline at end of file
diff --git a/Microsoft.Toolkit/Observables/IReadOnlyObservableGroup.cs b/Microsoft.Toolkit/Observables/IReadOnlyObservableGroup.cs
new file mode 100644
index 00000000000..41e2a4618df
--- /dev/null
+++ b/Microsoft.Toolkit/Observables/IReadOnlyObservableGroup.cs
@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.Toolkit.Observables.Collections
+{
+    /// <summary>
+    /// An interface for a grouped collection of items.
+    /// It allows us to use x:Bind with <see cref="ObservableGroup{TKey, TValue}"/> and <see cref="ReadOnlyObservableGroup{TKey, TValue}"/> by providing
+    /// a non-generic type that we can declare using x:DataType.
+    /// </summary>
+    public interface IReadOnlyObservableGroup
+    {
+        /// <summary>
+        /// Gets the key for the current collection, as an <see cref="object"/>.
+        /// </summary>
+        object Key { get; }
+
+        /// <summary>
+        /// Gets the number of items currently in the grouped collection.
+        /// </summary>
+        int Count { get; }
+    }
+}
diff --git a/Microsoft.Toolkit/Observables/ObservableGroup.cs b/Microsoft.Toolkit/Observables/ObservableGroup.cs
index f7a965d4965..3303f9fbc00 100644
--- a/Microsoft.Toolkit/Observables/ObservableGroup.cs
+++ b/Microsoft.Toolkit/Observables/ObservableGroup.cs
@@ -14,7 +14,7 @@ namespace Microsoft.Toolkit.Observables.Collections
     /// </summary>
     /// <typeparam name="TKey">The type of the group key.</typeparam>
     /// <typeparam name="TValue">The type of the items in the collection.</typeparam>
-    public sealed class ObservableGroup<TKey, TValue> : ObservableCollection<TValue>, IGrouping<TKey, TValue>
+    public sealed class ObservableGroup<TKey, TValue> : ObservableCollection<TValue>, IGrouping<TKey, TValue>, IReadOnlyObservableGroup
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="ObservableGroup{TKey, TValue}"/> class.
@@ -50,5 +50,9 @@ public ObservableGroup(TKey key, IEnumerable<TValue> collection)
         /// Gets the key of the group.
         /// </summary>
         public TKey Key { get; }
+
+        object IReadOnlyObservableGroup.Key => Key;
+
+        int IReadOnlyObservableGroup.Count => Count;
     }
 }
diff --git a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs
index b0726e0b929..5ff22005435 100644
--- a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs
+++ b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs
@@ -12,7 +12,7 @@ namespace Microsoft.Toolkit.Observables.Collections
     /// </summary>
     /// <typeparam name="TKey">The type of the group key.</typeparam>
     /// <typeparam name="TValue">The type of the items in the collection.</typeparam>
-    public sealed class ReadOnlyObservableGroup<TKey, TValue> : ReadOnlyObservableCollection<TValue>, IGrouping<TKey, TValue>
+    public sealed class ReadOnlyObservableGroup<TKey, TValue> : ReadOnlyObservableCollection<TValue>, IGrouping<TKey, TValue>, IReadOnlyObservableGroup
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="ReadOnlyObservableGroup{TKey, TValue}"/> class.
@@ -37,5 +37,9 @@ public ReadOnlyObservableGroup(ObservableGroup<TKey, TValue> group)
 
         /// <inheritdoc/>
         public TKey Key { get; }
+
+        object IReadOnlyObservableGroup.Key => Key;
+
+        int IReadOnlyObservableGroup.Count => Count;
     }
 }
diff --git a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
index 09e391761f5..cee1bb1c654 100644
--- a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
+++ b/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
@@ -22,7 +22,7 @@ public sealed class ReadOnlyObservableGroupedCollection<TKey, TValue> :
         IReadOnlyList<ReadOnlyObservableGroup<TKey, TValue>>,
         INotifyPropertyChanged,
         INotifyCollectionChanged,
-        ICollection,    // Implementing IColletion and IList is needed to allow ListView to monitor the INotifyCollectionChanged events...
+        ICollection,    // Implementing ICollection and IList is needed to allow ListView to monitor the INotifyCollectionChanged events...
         IList
     {
         private readonly ObservableGroupedCollection<TKey, TValue> _collection;
diff --git a/UnitTests/Observables/ObservableGroupTests.cs b/UnitTests/Observables/ObservableGroupTests.cs
index 39e5cfd49a1..1ce7b31bdb9 100644
--- a/UnitTests/Observables/ObservableGroupTests.cs
+++ b/UnitTests/Observables/ObservableGroupTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Linq;
 using FluentAssertions;
 using Microsoft.Toolkit.Observables.Collections;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -107,5 +108,18 @@ public void Clear_ShouldRaiseEvent()
             group.Should().BeEmpty();
             collectionChangedEventRaised.Should().BeTrue();
         }
+
+        [TestCategory("Observables")]
+        [DataTestMethod]
+        [DataRow(0)]
+        [DataRow(3)]
+        public void IReadOnlyObservableGroup_ShouldReturnExpectedValues(int count)
+        {
+            var group = new ObservableGroup<string, int>("key", Enumerable.Range(0, count));
+            var iReadOnlyObservableGroup = (IReadOnlyObservableGroup)group;
+
+            iReadOnlyObservableGroup.Key.Should().Be("key");
+            iReadOnlyObservableGroup.Count.Should().Be(count);
+        }
     }
 }
diff --git a/UnitTests/Observables/ReadOnlyObservableGroupTests.cs b/UnitTests/Observables/ReadOnlyObservableGroupTests.cs
index 667a4a4db88..d011a3e5f8a 100644
--- a/UnitTests/Observables/ReadOnlyObservableGroupTests.cs
+++ b/UnitTests/Observables/ReadOnlyObservableGroupTests.cs
@@ -2,11 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Linq;
 using FluentAssertions;
 using Microsoft.Toolkit.Observables.Collections;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Collections.ObjectModel;
-using System.Collections.Specialized;
 
 namespace UnitTests.Observables
 {
@@ -103,5 +104,19 @@ public void Clear_ShouldRaiseEvent()
             group.Should().BeEmpty();
             collectionChangedEventRaised.Should().BeTrue();
         }
+
+        [TestCategory("Observables")]
+        [DataTestMethod]
+        [DataRow(0)]
+        [DataRow(3)]
+        public void IReadOnlyObservableGroup_ShouldReturnExpectedValues(int count)
+        {
+            var sourceGroup = new ObservableGroup<string, int>("key", Enumerable.Range(0, count));
+            var group = new ReadOnlyObservableGroup<string, int>(sourceGroup);
+            var iReadOnlyObservableGroup = (IReadOnlyObservableGroup)group;
+
+            iReadOnlyObservableGroup.Key.Should().Be("key");
+            iReadOnlyObservableGroup.Count.Should().Be(count);
+        }
     }
 }

From d39f3865454151845835ba2927792ce465675931 Mon Sep 17 00:00:00 2001
From: Vincent <zeGroumf@hotmail.com>
Date: Wed, 1 Apr 2020 22:53:33 +0200
Subject: [PATCH 09/13] address PR comments

---
 .../ObservableGroup/ObservableGroupPage.xaml     | 16 ++++++++++++----
 .../ObservableGroup/ObservableGroupPage.xaml.cs  |  2 +-
 .../IReadOnlyObservableGroup.cs                  |  7 +++++--
 .../ObservableGroup.cs                           |  5 ++---
 .../ObservableGroupedCollection.cs               |  2 +-
 .../ReadOnlyObservableGroup.cs                   |  5 ++---
 .../ReadOnlyObservableGroupedCollection.cs       |  2 +-
 7 files changed, 24 insertions(+), 15 deletions(-)
 rename Microsoft.Toolkit/{Observables => Collections}/IReadOnlyObservableGroup.cs (83%)
 rename Microsoft.Toolkit/{Observables => Collections}/ObservableGroup.cs (95%)
 rename Microsoft.Toolkit/{Observables => Collections}/ObservableGroupedCollection.cs (96%)
 rename Microsoft.Toolkit/{Observables => Collections}/ReadOnlyObservableGroup.cs (94%)
 rename Microsoft.Toolkit/{Observables => Collections}/ReadOnlyObservableGroupedCollection.cs (99%)

diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
index 2a6628b5181..30a0da9f00b 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
@@ -1,10 +1,11 @@
 <Page x:Class="Microsoft.Toolkit.Uwp.SampleApp.SamplePages.ObservableGroupPage"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+      xmlns:collections="using:Microsoft.Toolkit.Collections"
       xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
       xmlns:local="using:Microsoft.Toolkit.Uwp.SampleApp.SamplePages"
-      xmlns:observables="using:Microsoft.Toolkit.Observables.Collections"
       xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+      xmlns:system="using:System"
       Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
       mc:Ignorable="d">
 
@@ -19,9 +20,16 @@
         </DataTemplate>
 
         <DataTemplate x:Key="GroupDataTemplate"
-                      x:DataType="observables:IReadOnlyObservableGroup">
-            <TextBlock Style="{StaticResource SubtitleTextBlockStyle}"
-                       Text="{x:Bind (x:String)Key}" />
+                      x:DataType="collections:IReadOnlyObservableGroup">
+            <StackPanel Orientation="Horizontal">
+                <TextBlock Style="{StaticResource SubtitleTextBlockStyle}"
+                           Text="{x:Bind (x:String)Key}" />
+                <TextBlock Margin="8,0,0,0"
+                           VerticalAlignment="Bottom"
+                           Opacity="0.8"
+                           Style="{StaticResource CaptionTextBlockStyle}"
+                           Text="{x:Bind system:String.Format('{0} item(s)', Count), Mode=OneWay}" />
+            </StackPanel>
         </DataTemplate>
 
         <CollectionViewSource x:Key="cvs"
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
index ce39d378c12..0998f1427c7 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Linq;
-using Microsoft.Toolkit.Observables.Collections;
+using Microsoft.Toolkit.Collections;
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;
 
diff --git a/Microsoft.Toolkit/Observables/IReadOnlyObservableGroup.cs b/Microsoft.Toolkit/Collections/IReadOnlyObservableGroup.cs
similarity index 83%
rename from Microsoft.Toolkit/Observables/IReadOnlyObservableGroup.cs
rename to Microsoft.Toolkit/Collections/IReadOnlyObservableGroup.cs
index 41e2a4618df..89c302345de 100644
--- a/Microsoft.Toolkit/Observables/IReadOnlyObservableGroup.cs
+++ b/Microsoft.Toolkit/Collections/IReadOnlyObservableGroup.cs
@@ -2,17 +2,20 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace Microsoft.Toolkit.Observables.Collections
+using System.ComponentModel;
+
+namespace Microsoft.Toolkit.Collections
 {
     /// <summary>
     /// An interface for a grouped collection of items.
     /// It allows us to use x:Bind with <see cref="ObservableGroup{TKey, TValue}"/> and <see cref="ReadOnlyObservableGroup{TKey, TValue}"/> by providing
     /// a non-generic type that we can declare using x:DataType.
     /// </summary>
-    public interface IReadOnlyObservableGroup
+    public interface IReadOnlyObservableGroup : INotifyPropertyChanged
     {
         /// <summary>
         /// Gets the key for the current collection, as an <see cref="object"/>.
+        /// It is immutable.
         /// </summary>
         object Key { get; }
 
diff --git a/Microsoft.Toolkit/Observables/ObservableGroup.cs b/Microsoft.Toolkit/Collections/ObservableGroup.cs
similarity index 95%
rename from Microsoft.Toolkit/Observables/ObservableGroup.cs
rename to Microsoft.Toolkit/Collections/ObservableGroup.cs
index 3303f9fbc00..c81218a94e8 100644
--- a/Microsoft.Toolkit/Observables/ObservableGroup.cs
+++ b/Microsoft.Toolkit/Collections/ObservableGroup.cs
@@ -6,7 +6,7 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 
-namespace Microsoft.Toolkit.Observables.Collections
+namespace Microsoft.Toolkit.Collections
 {
     /// <summary>
     /// An observable group.
@@ -51,8 +51,7 @@ public ObservableGroup(TKey key, IEnumerable<TValue> collection)
         /// </summary>
         public TKey Key { get; }
 
+        /// <inheritdoc/>
         object IReadOnlyObservableGroup.Key => Key;
-
-        int IReadOnlyObservableGroup.Count => Count;
     }
 }
diff --git a/Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs b/Microsoft.Toolkit/Collections/ObservableGroupedCollection.cs
similarity index 96%
rename from Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs
rename to Microsoft.Toolkit/Collections/ObservableGroupedCollection.cs
index 561190af0e7..7c8be2f0c74 100644
--- a/Microsoft.Toolkit/Observables/ObservableGroupedCollection.cs
+++ b/Microsoft.Toolkit/Collections/ObservableGroupedCollection.cs
@@ -6,7 +6,7 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 
-namespace Microsoft.Toolkit.Observables.Collections
+namespace Microsoft.Toolkit.Collections
 {
     /// <summary>
     /// An observable list of observable groups.
diff --git a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs b/Microsoft.Toolkit/Collections/ReadOnlyObservableGroup.cs
similarity index 94%
rename from Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs
rename to Microsoft.Toolkit/Collections/ReadOnlyObservableGroup.cs
index 5ff22005435..fb4b8114215 100644
--- a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroup.cs
+++ b/Microsoft.Toolkit/Collections/ReadOnlyObservableGroup.cs
@@ -5,7 +5,7 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 
-namespace Microsoft.Toolkit.Observables.Collections
+namespace Microsoft.Toolkit.Collections
 {
     /// <summary>
     /// A read-only observable group. It associates a <see cref="Key"/> to a <see cref="ReadOnlyObservableCollection{T}"/>.
@@ -38,8 +38,7 @@ public ReadOnlyObservableGroup(ObservableGroup<TKey, TValue> group)
         /// <inheritdoc/>
         public TKey Key { get; }
 
+        /// <inheritdoc/>
         object IReadOnlyObservableGroup.Key => Key;
-
-        int IReadOnlyObservableGroup.Count => Count;
     }
 }
diff --git a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs b/Microsoft.Toolkit/Collections/ReadOnlyObservableGroupedCollection.cs
similarity index 99%
rename from Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
rename to Microsoft.Toolkit/Collections/ReadOnlyObservableGroupedCollection.cs
index cee1bb1c654..935969d1ae1 100644
--- a/Microsoft.Toolkit/Observables/ReadOnlyObservableGroupedCollection.cs
+++ b/Microsoft.Toolkit/Collections/ReadOnlyObservableGroupedCollection.cs
@@ -10,7 +10,7 @@
 using System.Diagnostics;
 using System.Linq;
 
-namespace Microsoft.Toolkit.Observables.Collections
+namespace Microsoft.Toolkit.Collections
 {
     /// <summary>
     /// A read-only list of groups.

From e96a3adb9b58a4e482c41c21607db121db49b25e Mon Sep 17 00:00:00 2001
From: Vincent <zeGroumf@hotmail.com>
Date: Wed, 1 Apr 2020 23:14:34 +0200
Subject: [PATCH 10/13] fixed unit tests

---
 UnitTests/{Observables => Collections}/IntGroup.cs     |  2 +-
 .../ObservableGroupTests.cs                            |  4 ++--
 .../ObservableGroupedCollectionTests.cs                |  4 ++--
 .../ReadOnlyObservableGroupTests.cs                    |  4 ++--
 .../ReadOnlyObservableGroupedCollectionTests.cs        |  4 ++--
 UnitTests/UnitTests.csproj                             | 10 +++++-----
 6 files changed, 14 insertions(+), 14 deletions(-)
 rename UnitTests/{Observables => Collections}/IntGroup.cs (94%)
 rename UnitTests/{Observables => Collections}/ObservableGroupTests.cs (98%)
 rename UnitTests/{Observables => Collections}/ObservableGroupedCollectionTests.cs (94%)
 rename UnitTests/{Observables => Collections}/ReadOnlyObservableGroupTests.cs (98%)
 rename UnitTests/{Observables => Collections}/ReadOnlyObservableGroupedCollectionTests.cs (99%)

diff --git a/UnitTests/Observables/IntGroup.cs b/UnitTests/Collections/IntGroup.cs
similarity index 94%
rename from UnitTests/Observables/IntGroup.cs
rename to UnitTests/Collections/IntGroup.cs
index d0a6734c160..2cdd9121b22 100644
--- a/UnitTests/Observables/IntGroup.cs
+++ b/UnitTests/Collections/IntGroup.cs
@@ -5,7 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace UnitTests.Observables
+namespace UnitTests.Collections
 {
     public class IntGroup : List<int>, IGrouping<string, int>
     {
diff --git a/UnitTests/Observables/ObservableGroupTests.cs b/UnitTests/Collections/ObservableGroupTests.cs
similarity index 98%
rename from UnitTests/Observables/ObservableGroupTests.cs
rename to UnitTests/Collections/ObservableGroupTests.cs
index 1ce7b31bdb9..d6e015dfd31 100644
--- a/UnitTests/Observables/ObservableGroupTests.cs
+++ b/UnitTests/Collections/ObservableGroupTests.cs
@@ -4,11 +4,11 @@
 
 using System.Linq;
 using FluentAssertions;
-using Microsoft.Toolkit.Observables.Collections;
+using Microsoft.Toolkit.Collections;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System.Collections.Specialized;
 
-namespace UnitTests.Observables
+namespace UnitTests.Collections
 {
     [TestClass]
     public class ObservableGroupTests
diff --git a/UnitTests/Observables/ObservableGroupedCollectionTests.cs b/UnitTests/Collections/ObservableGroupedCollectionTests.cs
similarity index 94%
rename from UnitTests/Observables/ObservableGroupedCollectionTests.cs
rename to UnitTests/Collections/ObservableGroupedCollectionTests.cs
index c43d14dc072..7b0c4629095 100644
--- a/UnitTests/Observables/ObservableGroupedCollectionTests.cs
+++ b/UnitTests/Collections/ObservableGroupedCollectionTests.cs
@@ -3,12 +3,12 @@
 // See the LICENSE file in the project root for more information.
 
 using FluentAssertions;
-using Microsoft.Toolkit.Observables.Collections;
+using Microsoft.Toolkit.Collections;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace UnitTests.Observables
+namespace UnitTests.Collections
 {
     [TestClass]
     public class ObservableGroupedCollectionTests
diff --git a/UnitTests/Observables/ReadOnlyObservableGroupTests.cs b/UnitTests/Collections/ReadOnlyObservableGroupTests.cs
similarity index 98%
rename from UnitTests/Observables/ReadOnlyObservableGroupTests.cs
rename to UnitTests/Collections/ReadOnlyObservableGroupTests.cs
index d011a3e5f8a..69bb996f638 100644
--- a/UnitTests/Observables/ReadOnlyObservableGroupTests.cs
+++ b/UnitTests/Collections/ReadOnlyObservableGroupTests.cs
@@ -6,10 +6,10 @@
 using System.Collections.Specialized;
 using System.Linq;
 using FluentAssertions;
-using Microsoft.Toolkit.Observables.Collections;
+using Microsoft.Toolkit.Collections;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
-namespace UnitTests.Observables
+namespace UnitTests.Collections
 {
     [TestClass]
     public class ReadOnlyObservableGroupTests
diff --git a/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs b/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs
similarity index 99%
rename from UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
rename to UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs
index 99f0598da46..8a2574b2e1b 100644
--- a/UnitTests/Observables/ReadOnlyObservableGroupedCollectionTests.cs
+++ b/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs
@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using FluentAssertions;
-using Microsoft.Toolkit.Observables.Collections;
+using Microsoft.Toolkit.Collections;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
 using System.Collections;
@@ -13,7 +13,7 @@
 using System.ComponentModel;
 using System.Linq;
 
-namespace UnitTests.Observables
+namespace UnitTests.Collections
 {
     [TestClass]
     public class ReadOnlyObservableGroupedCollectionTests
diff --git a/UnitTests/UnitTests.csproj b/UnitTests/UnitTests.csproj
index 3b2e79dbbc2..e5649870669 100644
--- a/UnitTests/UnitTests.csproj
+++ b/UnitTests/UnitTests.csproj
@@ -161,11 +161,11 @@
     <Compile Include="Markdown\Parse\SuperscriptTests.cs" />
     <Compile Include="Markdown\Parse\TableTests.cs" />
     <Compile Include="Markdown\TestBase.cs" />
-    <Compile Include="Observables\IntGroup.cs" />
-    <Compile Include="Observables\ObservableGroupedCollectionTests.cs" />
-    <Compile Include="Observables\ObservableGroupTests.cs" />
-    <Compile Include="Observables\ReadOnlyObservableGroupedCollectionTests.cs" />
-    <Compile Include="Observables\ReadOnlyObservableGroupTests.cs" />
+    <Compile Include="Collections\IntGroup.cs" />
+    <Compile Include="Collections\ObservableGroupedCollectionTests.cs" />
+    <Compile Include="Collections\ObservableGroupTests.cs" />
+    <Compile Include="Collections\ReadOnlyObservableGroupedCollectionTests.cs" />
+    <Compile Include="Collections\ReadOnlyObservableGroupTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Helpers\Test_WeakEventListener.cs" />
     <Compile Include="UI\Controls\Test_UniformGrid_AutoLayout.cs" />

From 6c68571ccbf6c003ac861e2f06177f3b0edb9f11 Mon Sep 17 00:00:00 2001
From: Vincent <zeGroumf@hotmail.com>
Date: Wed, 1 Apr 2020 23:15:31 +0200
Subject: [PATCH 11/13] changed test category

---
 UnitTests/Collections/ObservableGroupTests.cs | 16 +++++++-------
 .../ObservableGroupedCollectionTests.cs       |  4 ++--
 .../ReadOnlyObservableGroupTests.cs           | 14 ++++++------
 ...eadOnlyObservableGroupedCollectionTests.cs | 22 +++++++++----------
 4 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/UnitTests/Collections/ObservableGroupTests.cs b/UnitTests/Collections/ObservableGroupTests.cs
index d6e015dfd31..92a08f5a68b 100644
--- a/UnitTests/Collections/ObservableGroupTests.cs
+++ b/UnitTests/Collections/ObservableGroupTests.cs
@@ -13,7 +13,7 @@ namespace UnitTests.Collections
     [TestClass]
     public class ObservableGroupTests
     {
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Ctor_ShouldHaveExpectedState()
         {
@@ -23,7 +23,7 @@ public void Ctor_ShouldHaveExpectedState()
             group.Should().BeEmpty();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Ctor_WithGrouping_ShouldHaveExpectedState()
         {
@@ -34,7 +34,7 @@ public void Ctor_WithGrouping_ShouldHaveExpectedState()
             group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Ctor_WithCollection_ShouldHaveExpectedState()
         {
@@ -45,7 +45,7 @@ public void Ctor_WithCollection_ShouldHaveExpectedState()
             group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Add_ShouldRaiseEvent()
         {
@@ -61,7 +61,7 @@ public void Add_ShouldRaiseEvent()
             collectionChangedEventRaised.Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Update_ShouldRaiseEvent()
         {
@@ -77,7 +77,7 @@ public void Update_ShouldRaiseEvent()
             collectionChangedEventRaised.Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Remove_ShouldRaiseEvent()
         {
@@ -93,7 +93,7 @@ public void Remove_ShouldRaiseEvent()
             collectionChangedEventRaised.Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Clear_ShouldRaiseEvent()
         {
@@ -109,7 +109,7 @@ public void Clear_ShouldRaiseEvent()
             collectionChangedEventRaised.Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [DataTestMethod]
         [DataRow(0)]
         [DataRow(3)]
diff --git a/UnitTests/Collections/ObservableGroupedCollectionTests.cs b/UnitTests/Collections/ObservableGroupedCollectionTests.cs
index 7b0c4629095..49b0634e982 100644
--- a/UnitTests/Collections/ObservableGroupedCollectionTests.cs
+++ b/UnitTests/Collections/ObservableGroupedCollectionTests.cs
@@ -13,7 +13,7 @@ namespace UnitTests.Collections
     [TestClass]
     public class ObservableGroupedCollectionTests
     {
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Ctor_ShouldHaveExpectedValues()
         {
@@ -22,7 +22,7 @@ public void Ctor_ShouldHaveExpectedValues()
             groupCollection.Should().BeEmpty();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Ctor_WithGroups_ShouldHaveExpectedValues()
         {
diff --git a/UnitTests/Collections/ReadOnlyObservableGroupTests.cs b/UnitTests/Collections/ReadOnlyObservableGroupTests.cs
index 69bb996f638..6e35e51faa1 100644
--- a/UnitTests/Collections/ReadOnlyObservableGroupTests.cs
+++ b/UnitTests/Collections/ReadOnlyObservableGroupTests.cs
@@ -14,7 +14,7 @@ namespace UnitTests.Collections
     [TestClass]
     public class ReadOnlyObservableGroupTests
     {
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Ctor_WithKeyAndCollection_ShouldHaveExpectedInitialState()
         {
@@ -25,7 +25,7 @@ public void Ctor_WithKeyAndCollection_ShouldHaveExpectedInitialState()
             group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Ctor_ObservableGroup_ShouldHaveExpectedInitialState()
         {
@@ -37,7 +37,7 @@ public void Ctor_ObservableGroup_ShouldHaveExpectedInitialState()
             group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Add_ShouldRaiseEvent()
         {
@@ -54,7 +54,7 @@ public void Add_ShouldRaiseEvent()
             collectionChangedEventRaised.Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Update_ShouldRaiseEvent()
         {
@@ -71,7 +71,7 @@ public void Update_ShouldRaiseEvent()
             collectionChangedEventRaised.Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Remove_ShouldRaiseEvent()
         {
@@ -88,7 +88,7 @@ public void Remove_ShouldRaiseEvent()
             collectionChangedEventRaised.Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Clear_ShouldRaiseEvent()
         {
@@ -105,7 +105,7 @@ public void Clear_ShouldRaiseEvent()
             collectionChangedEventRaised.Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [DataTestMethod]
         [DataRow(0)]
         [DataRow(3)]
diff --git a/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs b/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs
index 8a2574b2e1b..0c41d29798d 100644
--- a/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs
+++ b/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs
@@ -18,7 +18,7 @@ namespace UnitTests.Collections
     [TestClass]
     public class ReadOnlyObservableGroupedCollectionTests
     {
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Ctor_WithEmptySource_ShoudInitializeObject()
         {
@@ -29,7 +29,7 @@ public void Ctor_WithEmptySource_ShoudInitializeObject()
             readOnlyGroup.Count.Should().Be(0);
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void Ctor_WithSource_ShoudInitializeObject()
         {
@@ -49,7 +49,7 @@ public void Ctor_WithSource_ShoudInitializeObject()
             readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithoutStrictOrdering());
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void IListImplementation_Properties_ShoudReturnExpectedValues()
         {
@@ -76,7 +76,7 @@ public void IListImplementation_Properties_ShoudReturnExpectedValues()
             list.IsSynchronized.Should().BeFalse();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void IListImplementation_MutableMethods_ShoudThrow()
         {
@@ -113,7 +113,7 @@ public void IListImplementation_MutableMethods_ShoudThrow()
             copyTo.Should().Throw<NotImplementedException>();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [DataTestMethod]
         [DataRow(-1)]
         [DataRow(0)]
@@ -138,7 +138,7 @@ public void IListImplementation_IndexOf_ShoudReturnExpectedValue(int groupIndex)
             index.Should().Be(groupIndex);
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [DataTestMethod]
         [DataRow(-1, false)]
         [DataRow(0, true)]
@@ -161,7 +161,7 @@ public void IListImplementation_Contains_ShoudReturnExpectedValue(int groupIndex
             result.Should().Be(expectedResult);
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void AddGroupInSource_ShouldAddGroup()
         {
@@ -185,7 +185,7 @@ public void AddGroupInSource_ShouldAddGroup()
             IsAddEventValid(collectionChangedEventArgs, itemsList).Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void RemoveGroupInSource_ShoudRemoveGroup()
         {
@@ -215,7 +215,7 @@ public void RemoveGroupInSource_ShoudRemoveGroup()
             IsRemoveEventValid(collectionChangedEventArgs, bItemsList, 1).Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void MoveGroupInSource_ShoudMoveGroup()
         {
@@ -247,7 +247,7 @@ public void MoveGroupInSource_ShoudMoveGroup()
             IsMoveEventValid(collectionChangedEventArgs, bItemsList, 1, 0).Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void ClearSource_ShoudClear()
         {
@@ -275,7 +275,7 @@ public void ClearSource_ShoudClear()
             IsResetEventValid(collectionChangedEventArgs).Should().BeTrue();
         }
 
-        [TestCategory("Observables")]
+        [TestCategory("Collections")]
         [TestMethod]
         public void ReplaceGroupInSource_ShoudReplaceGroup()
         {

From fbe35b895301eb46f376f6452c87d3b31802eb06 Mon Sep 17 00:00:00 2001
From: Vincent <zeGroumf@hotmail.com>
Date: Thu, 2 Apr 2020 22:54:56 +0200
Subject: [PATCH 12/13] simplify implementation of
 ReadOnlyObservableGroupedCollection

---
 .../Collections/ReadOnlyObservableGroup.cs    |  12 ++
 .../ReadOnlyObservableGroupedCollection.cs    | 141 ++++-----------
 .../ReadOnlyObservableGroupTests.cs           |  13 +-
 ...eadOnlyObservableGroupedCollectionTests.cs | 170 +++++++++++++++---
 4 files changed, 203 insertions(+), 133 deletions(-)

diff --git a/Microsoft.Toolkit/Collections/ReadOnlyObservableGroup.cs b/Microsoft.Toolkit/Collections/ReadOnlyObservableGroup.cs
index fb4b8114215..b060db390d0 100644
--- a/Microsoft.Toolkit/Collections/ReadOnlyObservableGroup.cs
+++ b/Microsoft.Toolkit/Collections/ReadOnlyObservableGroup.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 
@@ -35,6 +36,17 @@ public ReadOnlyObservableGroup(ObservableGroup<TKey, TValue> group)
             Key = group.Key;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReadOnlyObservableGroup{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="key">The key of the group.</param>
+        /// <param name="collection">The collection of items to add in the group.</param>
+        public ReadOnlyObservableGroup(TKey key, IEnumerable<TValue> collection)
+            : base(new ObservableCollection<TValue>(collection))
+        {
+            Key = key;
+        }
+
         /// <inheritdoc/>
         public TKey Key { get; }
 
diff --git a/Microsoft.Toolkit/Collections/ReadOnlyObservableGroupedCollection.cs b/Microsoft.Toolkit/Collections/ReadOnlyObservableGroupedCollection.cs
index 935969d1ae1..9ff14698586 100644
--- a/Microsoft.Toolkit/Collections/ReadOnlyObservableGroupedCollection.cs
+++ b/Microsoft.Toolkit/Collections/ReadOnlyObservableGroupedCollection.cs
@@ -3,10 +3,9 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Collections.Specialized;
-using System.ComponentModel;
 using System.Diagnostics;
 using System.Linq;
 
@@ -17,138 +16,70 @@ namespace Microsoft.Toolkit.Collections
     /// </summary>
     /// <typeparam name="TKey">The type of the group key.</typeparam>
     /// <typeparam name = "TValue" > The type of the items in the collection.</typeparam>
-    public sealed class ReadOnlyObservableGroupedCollection<TKey, TValue> :
-        IReadOnlyCollection<ReadOnlyObservableGroup<TKey, TValue>>,
-        IReadOnlyList<ReadOnlyObservableGroup<TKey, TValue>>,
-        INotifyPropertyChanged,
-        INotifyCollectionChanged,
-        ICollection,    // Implementing ICollection and IList is needed to allow ListView to monitor the INotifyCollectionChanged events...
-        IList
+    public sealed class ReadOnlyObservableGroupedCollection<TKey, TValue> : ReadOnlyObservableCollection<ReadOnlyObservableGroup<TKey, TValue>>
     {
-        private readonly ObservableGroupedCollection<TKey, TValue> _collection;
-        private readonly IDictionary<ObservableGroup<TKey, TValue>, ReadOnlyObservableGroup<TKey, TValue>> _mapping;
-
-        /// <inheritdoc/>
-        public event NotifyCollectionChangedEventHandler CollectionChanged;
-
-        /// <inheritdoc/>
-        public event PropertyChangedEventHandler PropertyChanged;
-
         /// <summary>
         /// Initializes a new instance of the <see cref="ReadOnlyObservableGroupedCollection{TKey, TValue}"/> class.
         /// </summary>
         /// <param name="collection">The source collection to wrap.</param>
         public ReadOnlyObservableGroupedCollection(ObservableGroupedCollection<TKey, TValue> collection)
+            : this(collection.Select(g => new ReadOnlyObservableGroup<TKey, TValue>(g)))
         {
-            _collection = collection;
-            _mapping = new Dictionary<ObservableGroup<TKey, TValue>, ReadOnlyObservableGroup<TKey, TValue>>(capacity: _collection.Count);
-
-            ((INotifyPropertyChanged)_collection).PropertyChanged += OnCollectionPropertyChanged;
-            ((INotifyCollectionChanged)_collection).CollectionChanged += OnCollectionChanged;
+            ((INotifyCollectionChanged)collection).CollectionChanged += this.OnSourceCollectionChanged;
         }
 
-        /// <inheritdoc/>
-        public ReadOnlyObservableGroup<TKey, TValue> this[int index] => GetGroupAt(index);
-
-        /// <inheritdoc/>
-        public int Count => _collection.Count;
-
-        /// <inheritdoc/>
-        public IEnumerator<ReadOnlyObservableGroup<TKey, TValue>> GetEnumerator() => _collection.Select(CreateOrGetReadOnlyObservableGroup).GetEnumerator();
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReadOnlyObservableGroupedCollection{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="collection">The initial data to add in the grouped collection.</param>
+        public ReadOnlyObservableGroupedCollection(IEnumerable<ReadOnlyObservableGroup<TKey, TValue>> collection)
+            : base(new ObservableCollection<ReadOnlyObservableGroup<TKey, TValue>>(collection))
+        {
+        }
 
-        /// <inheritdoc/>
-        IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)_collection.Select(CreateOrGetReadOnlyObservableGroup)).GetEnumerator();
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReadOnlyObservableGroupedCollection{TKey, TValue}"/> class.
+        /// </summary>
+        /// <param name="collection">The initial data to add in the grouped collection.</param>
+        public ReadOnlyObservableGroupedCollection(IEnumerable<IGrouping<TKey, TValue>> collection)
+            : this(collection.Select(g => new ReadOnlyObservableGroup<TKey, TValue>(g.Key, g)))
+        {
+        }
 
-        private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        private void OnSourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
-            // We force the evaluation to have all our instances ready before deleting the mapping.
-            var sourceOldItems = (e.OldItems?.Cast<ObservableGroup<TKey, TValue>>() ?? Enumerable.Empty<ObservableGroup<TKey, TValue>>()).ToList();
-            var oldItems = (IList)sourceOldItems.Select(CreateOrGetReadOnlyObservableGroup).ToList();
-            var newItems = (IList)(e.NewItems?.Cast<ObservableGroup<TKey, TValue>>().Select(CreateOrGetReadOnlyObservableGroup) ?? Enumerable.Empty<ReadOnlyObservableGroup<TKey, TValue>>()).ToList();
+            // Even if the NotifyCollectionChangedEventArgs allows multiple items, the actual implementation is only
+            // reporting the changes one by one. We consider only this case for now.
+            if (e.OldItems?.Count > 1 || e.NewItems?.Count > 1)
+            {
+                Debug.Fail("OldItems and NewItems should contain at most 1 item");
+                throw new NotSupportedException();
+            }
+
+            var newItem = e.NewItems?.Cast<ObservableGroup<TKey, TValue>>()?.FirstOrDefault();
 
             switch (e.Action)
             {
                 case NotifyCollectionChangedAction.Add:
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, newItems, e.NewStartingIndex));
+                    Items.Insert(e.NewStartingIndex, new ReadOnlyObservableGroup<TKey, TValue>(newItem));
                     break;
                 case NotifyCollectionChangedAction.Move:
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, newItems, e.NewStartingIndex, e.OldStartingIndex));
+                    // Our inner Items list is our own ObservableCollection<ReadOnlyObservableGroup<TKey, TValue>> so we can safely cast Items to its concrete type here.
+                    ((ObservableCollection<ReadOnlyObservableGroup<TKey, TValue>>)Items).Move(e.OldStartingIndex, e.NewStartingIndex);
                     break;
                 case NotifyCollectionChangedAction.Remove:
-                    // We unmap the removed or replaced items.
-                    foreach (var sourceOldItem in sourceOldItems)
-                    {
-                        _mapping.Remove(sourceOldItem);
-                    }
-
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, oldItems, e.OldStartingIndex));
+                    Items.RemoveAt(e.OldStartingIndex);
                     break;
                 case NotifyCollectionChangedAction.Replace:
-                    // We unmap the removed or replaced items.
-                    foreach (var sourceOldItem in sourceOldItems)
-                    {
-                        _mapping.Remove(sourceOldItem);
-                    }
-
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, newItems, oldItems));
+                    Items[e.OldStartingIndex] = new ReadOnlyObservableGroup<TKey, TValue>(newItem);
                     break;
                 case NotifyCollectionChangedAction.Reset:
-                    _mapping.Clear();
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+                    Items.Clear();
                     break;
                 default:
                     Debug.Fail("unsupported value");
                     break;
             }
         }
-
-        private void OnCollectionPropertyChanged(object sender, PropertyChangedEventArgs e) => PropertyChanged?.Invoke(this, e);
-
-        private ReadOnlyObservableGroup<TKey, TValue> CreateOrGetReadOnlyObservableGroup(ObservableGroup<TKey, TValue> observableGroup)
-        {
-            if (_mapping.TryGetValue(observableGroup, out var readOnlyGroup))
-            {
-                return readOnlyGroup;
-            }
-
-            readOnlyGroup = new ReadOnlyObservableGroup<TKey, TValue>(observableGroup);
-            _mapping.Add(observableGroup, readOnlyGroup);
-
-            return readOnlyGroup;
-        }
-
-        private ReadOnlyObservableGroup<TKey, TValue> GetGroupAt(int index) => CreateOrGetReadOnlyObservableGroup(_collection[index]);
-
-        int ICollection.Count => _collection.Count;
-
-        bool ICollection.IsSynchronized => false;
-
-        object ICollection.SyncRoot => this;
-
-        bool IList.IsFixedSize => ((IList)_collection).IsFixedSize;
-
-        bool IList.IsReadOnly => true;
-
-        object IList.this[int index]
-        {
-            get => GetGroupAt(index);
-            set => throw new NotImplementedException();
-        }
-
-        void ICollection.CopyTo(Array array, int index) => throw new NotImplementedException();
-
-        int IList.Add(object value) => throw new NotImplementedException();
-
-        void IList.Clear() => throw new NotImplementedException();
-
-        bool IList.Contains(object value) => this.Any(group => group == value);
-
-        int IList.IndexOf(object value) => this.Select((group, i) => (group == value) ? i : -1).Max();
-
-        void IList.Insert(int index, object value) => throw new NotImplementedException();
-
-        void IList.Remove(object value) => throw new NotImplementedException();
-
-        void IList.RemoveAt(int index) => throw new NotImplementedException();
     }
 }
diff --git a/UnitTests/Collections/ReadOnlyObservableGroupTests.cs b/UnitTests/Collections/ReadOnlyObservableGroupTests.cs
index 6e35e51faa1..35885107620 100644
--- a/UnitTests/Collections/ReadOnlyObservableGroupTests.cs
+++ b/UnitTests/Collections/ReadOnlyObservableGroupTests.cs
@@ -16,7 +16,7 @@ public class ReadOnlyObservableGroupTests
     {
         [TestCategory("Collections")]
         [TestMethod]
-        public void Ctor_WithKeyAndCollection_ShouldHaveExpectedInitialState()
+        public void Ctor_WithKeyAndOBservableCollection_ShouldHaveExpectedInitialState()
         {
             var source = new ObservableCollection<int>(new[] { 1, 2, 3 });
             var group = new ReadOnlyObservableGroup<string, int>("key", source);
@@ -37,6 +37,17 @@ public void Ctor_ObservableGroup_ShouldHaveExpectedInitialState()
             group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
         }
 
+        [TestCategory("Collections")]
+        [TestMethod]
+        public void Ctor_WithKeyAndCollection_ShouldHaveExpectedInitialState()
+        {
+            var source = new[] { 1, 2, 3 };
+            var group = new ReadOnlyObservableGroup<string, int>("key", source);
+
+            group.Key.Should().Be("key");
+            group.Should().BeEquivalentTo(new[] { 1, 2, 3 }, option => option.WithStrictOrdering());
+        }
+
         [TestCategory("Collections")]
         [TestMethod]
         public void Add_ShouldRaiseEvent()
diff --git a/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs b/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs
index 0c41d29798d..1e69d45246a 100644
--- a/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs
+++ b/UnitTests/Collections/ReadOnlyObservableGroupedCollectionTests.cs
@@ -31,7 +31,7 @@ public void Ctor_WithEmptySource_ShoudInitializeObject()
 
         [TestCategory("Collections")]
         [TestMethod]
-        public void Ctor_WithSource_ShoudInitializeObject()
+        public void Ctor_WithObservableGroupedCollection_ShoudInitializeObject()
         {
             var groups = new List<IGrouping<string, int>>
             {
@@ -49,6 +49,44 @@ public void Ctor_WithSource_ShoudInitializeObject()
             readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithoutStrictOrdering());
         }
 
+        [TestCategory("Collections")]
+        [TestMethod]
+        public void Ctor_WithListOfIGroupingSource_ShoudInitializeObject()
+        {
+            var source = new List<IGrouping<string, int>>
+            {
+                new IntGroup("A", new[] { 1, 3, 5 }),
+                new IntGroup("B", new[] { 2, 4, 6 }),
+            };
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+
+            readOnlyGroup.Should().HaveCount(2);
+            readOnlyGroup.Count.Should().Be(2);
+            readOnlyGroup.ElementAt(0).Key.Should().Be("A");
+            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(new[] { 1, 3, 5 }, o => o.WithoutStrictOrdering());
+            readOnlyGroup.ElementAt(1).Key.Should().Be("B");
+            readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithoutStrictOrdering());
+        }
+
+        [TestCategory("Collections")]
+        [TestMethod]
+        public void Ctor_WithListOfReadOnlyObservableGroupSource_ShoudInitializeObject()
+        {
+            var source = new List<ReadOnlyObservableGroup<string, int>>
+            {
+                new ReadOnlyObservableGroup<string, int>("A", new[] { 1, 3, 5 }),
+                new ReadOnlyObservableGroup<string, int>("B", new[] { 2, 4, 6 }),
+            };
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+
+            readOnlyGroup.Should().HaveCount(2);
+            readOnlyGroup.Count.Should().Be(2);
+            readOnlyGroup.ElementAt(0).Key.Should().Be("A");
+            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(new[] { 1, 3, 5 }, o => o.WithoutStrictOrdering());
+            readOnlyGroup.ElementAt(1).Key.Should().Be("B");
+            readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithoutStrictOrdering());
+        }
+
         [TestCategory("Collections")]
         [TestMethod]
         public void IListImplementation_Properties_ShoudReturnExpectedValues()
@@ -70,8 +108,8 @@ public void IListImplementation_Properties_ShoudReturnExpectedValues()
             group1.Key.Should().Be("B");
             group1.Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithoutStrictOrdering());
 
-            list.SyncRoot.Should().BeSameAs(readOnlyGroup);
-            list.IsFixedSize.Should().BeFalse();
+            list.SyncRoot.Should().NotBeNull();
+            list.IsFixedSize.Should().BeTrue();
             list.IsReadOnly.Should().BeTrue();
             list.IsSynchronized.Should().BeFalse();
         }
@@ -91,26 +129,26 @@ public void IListImplementation_MutableMethods_ShoudThrow()
 
             var testGroup = new ReadOnlyObservableGroup<string, int>("test", new ObservableCollection<int>());
             Action add = () => list.Add(testGroup);
-            add.Should().Throw<NotImplementedException>();
+            add.Should().Throw<NotSupportedException>();
 
             Action clear = () => list.Clear();
-            clear.Should().Throw<NotImplementedException>();
+            clear.Should().Throw<NotSupportedException>();
 
             Action insert = () => list.Insert(2, testGroup);
-            insert.Should().Throw<NotImplementedException>();
+            insert.Should().Throw<NotSupportedException>();
 
             Action remove = () => list.Remove(testGroup);
-            remove.Should().Throw<NotImplementedException>();
+            remove.Should().Throw<NotSupportedException>();
 
             Action removeAt = () => list.RemoveAt(2);
-            removeAt.Should().Throw<NotImplementedException>();
+            removeAt.Should().Throw<NotSupportedException>();
 
             Action set = () => list[2] = testGroup;
-            set.Should().Throw<NotImplementedException>();
+            set.Should().Throw<NotSupportedException>();
 
             var array = new object[5];
             Action copyTo = () => list.CopyTo(array, 0);
-            copyTo.Should().Throw<NotImplementedException>();
+            copyTo.Should().NotThrow();
         }
 
         [TestCategory("Collections")]
@@ -162,27 +200,78 @@ public void IListImplementation_Contains_ShoudReturnExpectedValue(int groupIndex
         }
 
         [TestCategory("Collections")]
-        [TestMethod]
-        public void AddGroupInSource_ShouldAddGroup()
+        [DataTestMethod]
+        [DataRow(0, 0)]
+        [DataRow(3, 3)]
+        public void AddGroupInSource_ShouldAddGroup(int sourceInitialItemsCount, int expectedInsertionIndex)
         {
             NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var collectionChangedEventsCount = 0;
             var isCountPropertyChangedEventRaised = false;
             var itemsList = new[] { 1, 2, 3 };
             var source = new ObservableGroupedCollection<string, int>();
+            for (var i = 0; i < sourceInitialItemsCount; i++)
+            {
+                source.Add(new ObservableGroup<string, int>($"group {i}", Enumerable.Empty<int>()));
+            }
+
             var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
-            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) =>
+            {
+                collectionChangedEventArgs = e;
+                collectionChangedEventsCount++;
+            };
             ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
 
             source.Add(new ObservableGroup<string, int>("Add", itemsList));
 
-            readOnlyGroup.Should().ContainSingle();
-            readOnlyGroup.Count.Should().Be(1);
-            readOnlyGroup.ElementAt(0).Key.Should().Be("Add");
-            readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(itemsList, o => o.WithoutStrictOrdering());
+            var expectedReadOnlyGroupCount = sourceInitialItemsCount + 1;
+            readOnlyGroup.Should().HaveCount(expectedReadOnlyGroupCount);
+            readOnlyGroup.Count.Should().Be(expectedReadOnlyGroupCount);
+            readOnlyGroup.Last().Key.Should().Be("Add");
+            readOnlyGroup.Last().Should().BeEquivalentTo(itemsList, o => o.WithoutStrictOrdering());
+
+            isCountPropertyChangedEventRaised.Should().BeTrue();
+            collectionChangedEventArgs.Should().NotBeNull();
+            collectionChangedEventsCount.Should().Be(1);
+            IsAddEventValid(collectionChangedEventArgs, itemsList, expectedInsertionIndex).Should().BeTrue();
+        }
+
+        [TestCategory("Collections")]
+        [DataTestMethod]
+        [DataRow(0)]
+        [DataRow(1)]
+        [DataRow(2)]
+        public void InsertGroupInSource_ShouldAddGroup(int insertionIndex)
+        {
+            NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var collectionChangedEventsCount = 0;
+            var isCountPropertyChangedEventRaised = false;
+            var itemsList = new[] { 1, 2, 3 };
+            var source = new ObservableGroupedCollection<string, int>
+            {
+                new ObservableGroup<string, int>("Group0", new[] { 10, 20, 30 }),
+                new ObservableGroup<string, int>("Group1", new[] { 40, 50, 60 })
+            };
+            var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) =>
+            {
+                collectionChangedEventArgs = e;
+                collectionChangedEventsCount++;
+            };
+            ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
+
+            source.Insert(insertionIndex, new ObservableGroup<string, int>("Add", itemsList));
+
+            readOnlyGroup.Should().HaveCount(3);
+            readOnlyGroup.Count.Should().Be(3);
+            readOnlyGroup.ElementAt(insertionIndex).Key.Should().Be("Add");
+            readOnlyGroup.ElementAt(insertionIndex).Should().BeEquivalentTo(itemsList, o => o.WithoutStrictOrdering());
 
             isCountPropertyChangedEventRaised.Should().BeTrue();
             collectionChangedEventArgs.Should().NotBeNull();
-            IsAddEventValid(collectionChangedEventArgs, itemsList).Should().BeTrue();
+            collectionChangedEventsCount.Should().Be(1);
+            IsAddEventValid(collectionChangedEventArgs, itemsList, addIndex: insertionIndex).Should().BeTrue();
         }
 
         [TestCategory("Collections")]
@@ -190,6 +279,7 @@ public void AddGroupInSource_ShouldAddGroup()
         public void RemoveGroupInSource_ShoudRemoveGroup()
         {
             NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var collectionChangedEventsCount = 0;
             var isCountPropertyChangedEventRaised = false;
             var aItemsList = new[] { 1, 2, 3 };
             var bItemsList = new[] { 2, 4, 6 };
@@ -200,7 +290,11 @@ public void RemoveGroupInSource_ShoudRemoveGroup()
             };
             var source = new ObservableGroupedCollection<string, int>(groups);
             var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
-            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) =>
+            {
+                collectionChangedEventArgs = e;
+                collectionChangedEventsCount++;
+            };
             ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
 
             source.RemoveAt(1);
@@ -212,14 +306,18 @@ public void RemoveGroupInSource_ShoudRemoveGroup()
 
             isCountPropertyChangedEventRaised.Should().BeTrue();
             collectionChangedEventArgs.Should().NotBeNull();
+            collectionChangedEventsCount.Should().Be(1);
             IsRemoveEventValid(collectionChangedEventArgs, bItemsList, 1).Should().BeTrue();
         }
 
         [TestCategory("Collections")]
-        [TestMethod]
-        public void MoveGroupInSource_ShoudMoveGroup()
+        [DataTestMethod]
+        [DataRow(1, 0)]
+        [DataRow(0, 1)]
+        public void MoveGroupInSource_ShoudMoveGroup(int oldIndex, int newIndex)
         {
             NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var collectionChangedEventsCount = 0;
             var isCountPropertyChangedEventRaised = false;
             var aItemsList = new[] { 1, 2, 3 };
             var bItemsList = new[] { 2, 4, 6 };
@@ -230,10 +328,14 @@ public void MoveGroupInSource_ShoudMoveGroup()
             };
             var source = new ObservableGroupedCollection<string, int>(groups);
             var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
-            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) =>
+            {
+                collectionChangedEventArgs = e;
+                collectionChangedEventsCount++;
+            };
             ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
 
-            source.Move(1, 0);
+            source.Move(oldIndex, newIndex);
 
             readOnlyGroup.Should().HaveCount(2);
             readOnlyGroup.Count.Should().Be(2);
@@ -244,7 +346,8 @@ public void MoveGroupInSource_ShoudMoveGroup()
 
             isCountPropertyChangedEventRaised.Should().BeFalse();
             collectionChangedEventArgs.Should().NotBeNull();
-            IsMoveEventValid(collectionChangedEventArgs, bItemsList, 1, 0).Should().BeTrue();
+            collectionChangedEventsCount.Should().Be(1);
+            IsMoveEventValid(collectionChangedEventArgs, groups[oldIndex], oldIndex, newIndex).Should().BeTrue();
         }
 
         [TestCategory("Collections")]
@@ -252,6 +355,7 @@ public void MoveGroupInSource_ShoudMoveGroup()
         public void ClearSource_ShoudClear()
         {
             NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var collectionChangedEventsCount = 0;
             var isCountPropertyChangedEventRaised = false;
             var aItemsList = new[] { 1, 2, 3 };
             var bItemsList = new[] { 2, 4, 6 };
@@ -262,7 +366,11 @@ public void ClearSource_ShoudClear()
             };
             var source = new ObservableGroupedCollection<string, int>(groups);
             var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
-            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) =>
+            {
+                collectionChangedEventArgs = e;
+                collectionChangedEventsCount++;
+            };
             ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
 
             source.Clear();
@@ -272,6 +380,7 @@ public void ClearSource_ShoudClear()
 
             isCountPropertyChangedEventRaised.Should().BeTrue();
             collectionChangedEventArgs.Should().NotBeNull();
+            collectionChangedEventsCount.Should().Be(1);
             IsResetEventValid(collectionChangedEventArgs).Should().BeTrue();
         }
 
@@ -280,6 +389,7 @@ public void ClearSource_ShoudClear()
         public void ReplaceGroupInSource_ShoudReplaceGroup()
         {
             NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
+            var collectionChangedEventsCount = 0;
             var isCountPropertyChangedEventRaised = false;
             var aItemsList = new[] { 1, 2, 3 };
             var bItemsList = new[] { 2, 4, 6 };
@@ -291,7 +401,11 @@ public void ReplaceGroupInSource_ShoudReplaceGroup()
             };
             var source = new ObservableGroupedCollection<string, int>(groups);
             var readOnlyGroup = new ReadOnlyObservableGroupedCollection<string, int>(source);
-            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) => collectionChangedEventArgs = e;
+            ((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) =>
+            {
+                collectionChangedEventArgs = e;
+                collectionChangedEventsCount++;
+            };
             ((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
 
             source[0] = new ObservableGroup<string, int>("C", cItemsList);
@@ -305,13 +419,15 @@ public void ReplaceGroupInSource_ShoudReplaceGroup()
 
             isCountPropertyChangedEventRaised.Should().BeFalse();
             collectionChangedEventArgs.Should().NotBeNull();
+            collectionChangedEventsCount.Should().Be(1);
             IsReplaceEventValid(collectionChangedEventArgs, aItemsList, cItemsList).Should().BeTrue();
         }
 
-        private static bool IsAddEventValid(NotifyCollectionChangedEventArgs args, IEnumerable<int> expectedGroupItems)
+        private static bool IsAddEventValid(NotifyCollectionChangedEventArgs args, IEnumerable<int> expectedGroupItems, int addIndex)
         {
             var newItems = args.NewItems?.Cast<IEnumerable<int>>();
             return args.Action == NotifyCollectionChangedAction.Add &&
+                    args.NewStartingIndex == addIndex &&
                     args.OldItems == null &&
                     newItems?.Count() == 1 &&
                     Enumerable.SequenceEqual(newItems.ElementAt(0), expectedGroupItems);

From 45f8df4d16c932756267aca8d76b29d1cc7a3e93 Mon Sep 17 00:00:00 2001
From: Vincent <zeGroumf@hotmail.com>
Date: Wed, 8 Apr 2020 22:06:46 +0200
Subject: [PATCH 13/13] Update sample code

---
 .../ObservableGroup/ObservableGroup.bind        |  1 +
 .../ObservableGroup/ObservableGroupPage.xaml    |  3 ++-
 .../ObservableGroup/ObservableGroupPage.xaml.cs | 17 +++++++++++++++--
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind
index 2e46d3f0e56..d4344fd4d6d 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroup.bind
@@ -26,6 +26,7 @@ var grouped = contacts.GroupBy(GetGroupName).OrderBy(g => g.Key);
 var contactsSource = new ObservableGroupedCollection<string, Person>(grouped);
 
 // Create a read-only observable grouped collection
+// Note: This step is optional. It is usually used in view models to expose the collection as read-only and prevent the view from altering it.
 var readonlyContacts = new ReadOnlyObservableGroupedCollection<string, Person>(contactsSource);
 
 // Set up the CollectionViewSource
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
index 30a0da9f00b..d57785e8ac1 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml
@@ -50,7 +50,8 @@
             <TextBox x:Name="NewContact"
                      MinWidth="200"
                      PlaceholderText="New contact"
-                     TextChanged="OnNewContactTextChanged" />
+                     TextChanged="OnNewContactTextChanged"
+                     KeyDown="OnNewContactKeyDown"/>
             <Button x:Name="AddContact"
                     Click="OnAddContactClick"
                     Content="Add"
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
index 0998f1427c7..ae9c7965119 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
+++ b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/ObservableGroup/ObservableGroupPage.xaml.cs
@@ -4,6 +4,7 @@
 
 using System.Linq;
 using Microsoft.Toolkit.Collections;
+using Windows.System;
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;
 
@@ -60,7 +61,9 @@ private void OnRemoveButtonClick(object sender, RoutedEventArgs e)
             }
         }
 
-        private void OnAddContactClick(object sender, RoutedEventArgs e)
+        private bool CanAddContact() => !string.IsNullOrEmpty(NewContact.Text.Trim());
+
+        private void AddNewContact()
         {
             var newContact = new Person
             {
@@ -81,6 +84,16 @@ private void OnAddContactClick(object sender, RoutedEventArgs e)
             NewContact.Text = string.Empty;
         }
 
-        private void OnNewContactTextChanged(object sender, TextChangedEventArgs e) => AddContact.IsEnabled = !string.IsNullOrEmpty(NewContact.Text.Trim());
+        private void OnAddContactClick(object sender, RoutedEventArgs e) => AddNewContact();
+
+        private void OnNewContactTextChanged(object sender, TextChangedEventArgs e) => AddContact.IsEnabled = CanAddContact();
+
+        private void OnNewContactKeyDown(object sender, Windows.UI.Xaml.Input.KeyRoutedEventArgs e)
+        {
+            if (e.Key == VirtualKey.Enter && CanAddContact())
+            {
+                AddNewContact();
+            }
+        }
     }
 }