Bug Fix: Virtual sort on same page (#997)

* Performance improvement for sort and virtualize / sort and page
* Fix comparer not applying for virtual sort when the data set is smaller then the virtual  page

Author: RolandPheasant

src/DynamicData.Tests/Cache/SortAndVirtualizeFixture.cs

@@ -11,6 +11,9 @@
 namespace DynamicData.Tests.Cache;
 
 
+
+
+
 public sealed class SortAndVirtualizeWithComparerChangesFixture : SortAndVirtualizeFixtureBase
 {
     private BehaviorSubject<IComparer<Person>> _comparerSubject ;
@@ -44,6 +47,29 @@ public void ChangeComparer()
          actualResult = Aggregator.Data.Items.OrderBy(p => p, Comparer);
         actualResult.Should().BeEquivalentTo(expectedResult);
     }
+
+    [Fact]
+    public void ChangeComparerDataSetSmallerThanVirtualSize()
+    {
+        var people = Enumerable.Range(1, 10).Select(i => new Person($"P{i:00}", i)).OrderBy(p => Guid.NewGuid());
+        Source.AddOrUpdate(people);
+
+        // for first batch, it should use the results of the _virtualRequests subject (if a behaviour subject is used).
+        var expectedResult = people.OrderBy(p => p, Comparer).Take(10).ToList();
+        var actualResult = Aggregator.Data.Items.OrderBy(p => p, Comparer);
+        actualResult.Should().BeEquivalentTo(expectedResult);
+
+        Aggregator.Messages[0].All(c => c.Reason == ChangeReason.Add).Should().BeTrue();
+
+        // change the comparer 
+        _comparerSubject.OnNext(_descComparer);
+
+        expectedResult = people.OrderBy(p => p, _descComparer).Take(10).ToList();
+        actualResult = Aggregator.Data.Items.OrderBy(p => p, Comparer);
+        actualResult.Should().BeEquivalentTo(expectedResult);
+
+        Aggregator.Messages[1].All(c => c.Reason == ChangeReason.Refresh).Should().BeTrue();
+    }
 }
 
 public sealed class SortAndVirtualizeFixture : SortAndVirtualizeFixtureBase

src/DynamicData/Cache/Internal/KeyValueComparer.cs

@@ -33,6 +33,11 @@ public int Compare(KeyValuePair<TKey, TObject> x, KeyValuePair<TKey, TObject> y)
             return -1;
         }
 
+        if (x.Key is IComparable<TKey> xComp)
+        {
+            return xComp.CompareTo(y.Key);
+        }
+
         return x.Key.GetHashCode().CompareTo(y.Key.GetHashCode());
     }
 }

src/DynamicData/Cache/Internal/SortAndVirtualize.cs

@@ -151,19 +151,28 @@ private static ChangeSet<TObject, TKey, VirtualContext<TObject>> CalculateVirtua
         result.AddRange(removes);
         result.AddRange(adds);
 
-        if (changes is null) return result;
-
-        var keyInPreviousAndCurrent = new HashSet<TKey>(previousItems.Intersect(currentItems, _keyComparer).Select(x => x.Key));
-
-        foreach (var change in changes)
+        if (changes is null)
         {
-            // An update (or refresh) can only occur if it was in the previous or current result set.
-            // If it was in only one or the other, it would be an add or remove accordingly.
-            if (!keyInPreviousAndCurrent.Contains(change.Key)) continue;
+            // the comparer has changed, so we need to send a Refresh for item in the same page
+            foreach (var kvp in previousItems.Intersect(currentItems, _keyComparer))
+            {
+                result.Add(new Change<TObject, TKey>(ChangeReason.Refresh, kvp.Key, kvp.Value));
+            }
+        }
+        else
+        {
+            var keyInPreviousAndCurrent = new HashSet<TKey>(previousItems.Intersect(currentItems, _keyComparer).Select(x => x.Key));
 
-            if (change.Reason is ChangeReason.Update or ChangeReason.Refresh)
+            foreach (var change in changes)
             {
-                result.Add(change);
+                // An update (or refresh) can only occur if it was in the previous or current result set.
+                // If it was in only one or the other, it would be an add or remove accordingly.
+                if (!keyInPreviousAndCurrent.Contains(change.Key)) continue;
+
+                if (change.Reason is ChangeReason.Update or ChangeReason.Refresh)
+                {
+                    result.Add(change);
+                }
             }
         }
 

src/DynamicData/Cache/Internal/SortedKeyValueApplicator.cs

@@ -79,21 +79,10 @@ private void ApplyChanges(IChangeSet<TObject, TKey> changes)
                     {
                         var previous = new KeyValuePair<TKey, TObject>(change.Key, change.Previous.Value);
                         var currentIndex = GetCurrentPosition(previous);
-                        var updatedIndex = GetInsertPosition(item);
-
-                        // We need to recalibrate as GetCurrentPosition includes the current item
-                        updatedIndex = currentIndex < updatedIndex ? updatedIndex - 1 : updatedIndex;
+                        _target.RemoveAt(currentIndex);
 
-                        // Some control suites and platforms do not support replace, whiles others do, so we opt in.
-                        if (_options.UseReplaceForUpdates && currentIndex == updatedIndex)
-                        {
-                            _target[currentIndex] = item;
-                        }
-                        else
-                        {
-                            _target.RemoveAt(currentIndex);
-                            _target.Insert(updatedIndex, item);
-                        }
+                        var updatedIndex = GetInsertPosition(item);
+                        _target.Insert(updatedIndex, item);
                     }
                     break;
                 case ChangeReason.Remove: