diff --git a/sandbox/ConsoleApp/Program.cs b/sandbox/ConsoleApp/Program.cs
index acc7987..652caec 100644
--- a/sandbox/ConsoleApp/Program.cs
+++ b/sandbox/ConsoleApp/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Specialized;
 using R3;
 using System.Linq;
 using ObservableCollections;
@@ -65,24 +66,29 @@ class HogeFilter : ISynchronizedViewFilter<int, ViewModel>
     }
 
     public void OnCollectionChanged(
-        ChangedKind changedKind,
+        NotifyCollectionChangedAction changedAction,
         int value,
         ViewModel view,
         in NotifyCollectionChangedEventArgs<int> eventArgs)
     {
-        switch (changedKind)
+        switch (changedAction)
         {
-            case ChangedKind.Add:
+            case NotifyCollectionChangedAction.Add:
                 view.Value += " Add";
                 break;
-            case ChangedKind.Remove:
+            case NotifyCollectionChangedAction.Remove:
                 view.Value += " Remove";
                 break;
-            case ChangedKind.Move:
+            case NotifyCollectionChangedAction.Move:
                 view.Value += $" Move {eventArgs.OldStartingIndex} {eventArgs.NewStartingIndex}";
                 break;
+            case NotifyCollectionChangedAction.Replace:
+                view.Value += $" Replace {eventArgs.OldStartingIndex} {eventArgs.NewStartingIndex}";
+                break;
+            case NotifyCollectionChangedAction.Reset:
+                break;
             default:
-                throw new ArgumentOutOfRangeException(nameof(changedKind), changedKind, null);
+                throw new ArgumentOutOfRangeException(nameof(changedAction), changedAction, null);
         }
     }
 }
\ No newline at end of file
diff --git a/src/ObservableCollections/ISynchronizedViewFilter.cs b/src/ObservableCollections/ISynchronizedViewFilter.cs
index cd0fcfb..52c0290 100644
--- a/src/ObservableCollections/ISynchronizedViewFilter.cs
+++ b/src/ObservableCollections/ISynchronizedViewFilter.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Specialized;
 
 namespace ObservableCollections
 {
@@ -7,12 +8,7 @@ namespace ObservableCollections
         bool IsMatch(T value, TView view);
         void WhenTrue(T value, TView view);
         void WhenFalse(T value, TView view);
-        void OnCollectionChanged(ChangedKind changedKind, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs);
-    }
-
-    public enum ChangedKind
-    {
-        Add, Remove, Move
+        void OnCollectionChanged(NotifyCollectionChangedAction changedAction, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs);
     }
 
     public class SynchronizedViewFilter<T, TView> : ISynchronizedViewFilter<T, TView>
@@ -22,9 +18,9 @@ namespace ObservableCollections
         readonly Func<T, TView, bool> isMatch;
         readonly Action<T, TView>? whenTrue;
         readonly Action<T, TView>? whenFalse;
-        readonly Action<ChangedKind, T, TView>? onCollectionChanged;
+        readonly Action<NotifyCollectionChangedAction, T, TView>? onCollectionChanged;
 
-        public SynchronizedViewFilter(Func<T, TView, bool> isMatch, Action<T, TView>? whenTrue, Action<T, TView>? whenFalse, Action<ChangedKind, T, TView>? onCollectionChanged)
+        public SynchronizedViewFilter(Func<T, TView, bool> isMatch, Action<T, TView>? whenTrue, Action<T, TView>? whenFalse, Action<NotifyCollectionChangedAction, T, TView>? onCollectionChanged)
         {
             this.isMatch = isMatch;
             this.whenTrue = whenTrue;
@@ -35,14 +31,15 @@ namespace ObservableCollections
         public bool IsMatch(T value, TView view) => isMatch(value, view);
         public void WhenFalse(T value, TView view) => whenFalse?.Invoke(value, view);
         public void WhenTrue(T value, TView view) => whenTrue?.Invoke(value, view);
-        public void OnCollectionChanged(ChangedKind changedKind, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs) => onCollectionChanged?.Invoke(changedKind, value, view);
+        public void OnCollectionChanged(NotifyCollectionChangedAction changedAction, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs) => 
+            onCollectionChanged?.Invoke(changedAction, value, view);
 
         class NullViewFilter : ISynchronizedViewFilter<T, TView>
         {
             public bool IsMatch(T value, TView view) => true;
             public void WhenFalse(T value, TView view) { }
             public void WhenTrue(T value, TView view) { }
-            public void OnCollectionChanged(ChangedKind changedKind, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs) { }
+            public void OnCollectionChanged(NotifyCollectionChangedAction changedAction, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs) { }
         }
     }
 
@@ -58,7 +55,7 @@ namespace ObservableCollections
             source.AttachFilter(new SynchronizedViewFilter<T, TView>(isMatch, whenTrue, whenFalse, null));
         }
 
-        public static void AttachFilter<T, TView>(this ISynchronizedView<T, TView> source, Func<T, TView, bool> isMatch, Action<T, TView>? whenTrue, Action<T, TView>? whenFalse, Action<ChangedKind, T, TView>? onCollectionChanged)
+        public static void AttachFilter<T, TView>(this ISynchronizedView<T, TView> source, Func<T, TView, bool> isMatch, Action<T, TView>? whenTrue, Action<T, TView>? whenFalse, Action<NotifyCollectionChangedAction, T, TView>? onCollectionChanged)
         {
             source.AttachFilter(new SynchronizedViewFilter<T, TView>(isMatch, whenTrue, whenFalse, onCollectionChanged));
         }
@@ -83,7 +80,7 @@ namespace ObservableCollections
             {
                 filter.WhenFalse(value, view);
             }
-            filter.OnCollectionChanged(ChangedKind.Add, value, view, eventArgs);
+            filter.OnCollectionChanged(NotifyCollectionChangedAction.Add, value, view, eventArgs);
         }
 
         internal static void InvokeOnRemove<T, TView>(this ISynchronizedViewFilter<T, TView> filter, (T value, TView view) value, in NotifyCollectionChangedEventArgs<T> eventArgs)
@@ -93,7 +90,7 @@ namespace ObservableCollections
 
         internal static void InvokeOnRemove<T, TView>(this ISynchronizedViewFilter<T, TView> filter, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs)
         {
-            filter.OnCollectionChanged(ChangedKind.Remove, value, view, eventArgs);
+            filter.OnCollectionChanged(NotifyCollectionChangedAction.Remove, value, view, eventArgs);
         }
 
         internal static void InvokeOnMove<T, TView>(this ISynchronizedViewFilter<T, TView> filter, (T value, TView view) value, in NotifyCollectionChangedEventArgs<T> eventArgs)
@@ -103,7 +100,22 @@ namespace ObservableCollections
 
         internal static void InvokeOnMove<T, TView>(this ISynchronizedViewFilter<T, TView> filter, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs)
         {
-            filter.OnCollectionChanged(ChangedKind.Move, value, view, eventArgs);
+            filter.OnCollectionChanged(NotifyCollectionChangedAction.Move, value, view, eventArgs);
+        }
+        
+        internal static void InvokeOnReplace<T, TView>(this ISynchronizedViewFilter<T, TView> filter, (T value, TView view) value, in NotifyCollectionChangedEventArgs<T> eventArgs)
+        {
+            InvokeOnReplace(filter, value.value, value.view, eventArgs);
+        }
+
+        internal static void InvokeOnReplace<T, TView>(this ISynchronizedViewFilter<T, TView> filter, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs)
+        {
+            filter.OnCollectionChanged(NotifyCollectionChangedAction.Replace, value, view, eventArgs);
+        }
+
+        internal static void InvokeOnReset<T, TView>(this ISynchronizedViewFilter<T, TView> filter, in NotifyCollectionChangedEventArgs<T> eventArgs)
+        {
+            filter.OnCollectionChanged(NotifyCollectionChangedAction.Reset, default!, default!, eventArgs);
         }
 
         internal static void InvokeOnAttach<T, TView>(this ISynchronizedViewFilter<T, TView> filter, T value, TView view)
diff --git a/src/ObservableCollections/Internal/NotifyCollectionChangedSynchronizedView.cs b/src/ObservableCollections/Internal/NotifyCollectionChangedSynchronizedView.cs
index 522c62f..b44e257 100644
--- a/src/ObservableCollections/Internal/NotifyCollectionChangedSynchronizedView.cs
+++ b/src/ObservableCollections/Internal/NotifyCollectionChangedSynchronizedView.cs
@@ -58,25 +58,18 @@ namespace ObservableCollections.Internal
         public void WhenTrue(T value, TView view) => currentFilter.WhenTrue(value, view);
         public void WhenFalse(T value, TView view) => currentFilter.WhenFalse(value, view);
 
-        public void OnCollectionChanged(ChangedKind changedKind, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs)
+        public void OnCollectionChanged(NotifyCollectionChangedAction changedAction, T value, TView view, in NotifyCollectionChangedEventArgs<T> eventArgs)
         {
-            currentFilter.OnCollectionChanged(changedKind, value, view, in eventArgs);
+            currentFilter.OnCollectionChanged(changedAction, value, view, in eventArgs);
+            CollectionChanged?.Invoke(this, eventArgs.ToStandardEventArgs());
 
-            switch (changedKind)
+            switch (changedAction)
             {
-                case ChangedKind.Add:
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, view, eventArgs.NewStartingIndex));
-                    PropertyChanged?.Invoke(this, CountPropertyChangedEventArgs);
-                    return;
-                case ChangedKind.Remove:
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, view, eventArgs.OldStartingIndex));
+                case NotifyCollectionChangedAction.Add:
+                case NotifyCollectionChangedAction.Remove:
+                case NotifyCollectionChangedAction.Reset:
                     PropertyChanged?.Invoke(this, CountPropertyChangedEventArgs);
                     break;
-                case ChangedKind.Move:
-                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, view, eventArgs.NewStartingIndex, eventArgs.OldStartingIndex));
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(changedKind), changedKind, null);
             }
         }
     }
diff --git a/src/ObservableCollections/Internal/SortedView.cs b/src/ObservableCollections/Internal/SortedView.cs
index 747d822..d76bec8 100644
--- a/src/ObservableCollections/Internal/SortedView.cs
+++ b/src/ObservableCollections/Internal/SortedView.cs
@@ -185,11 +185,11 @@ namespace ObservableCollections.Internal
                     {
                         var oldValue = e.OldItem;
                         var oldKey = (oldValue, identitySelector(oldValue));
+                        var oldIndex = -1;
                         if (list.TryGetValue(oldKey, out var o))
                         {
-                            var oldIndex = list.IndexOfKey(oldKey);
+                            oldIndex = list.IndexOfKey(oldKey);
                             list.RemoveAt(oldIndex);
-                            filter.InvokeOnRemove(o, NotifyCollectionChangedEventArgs<T>.Remove(oldValue, oldIndex));
                         }
 
                         var value = e.NewItem;
@@ -198,7 +198,7 @@ namespace ObservableCollections.Internal
                         list.Add((value, id), (value, view));
                         var newIndex = list.IndexOfKey((value, id));
 
-                        filter.InvokeOnAdd(value, view, NotifyCollectionChangedEventArgs<T>.Add(value, newIndex));
+                        filter.InvokeOnReplace(value, view, NotifyCollectionChangedEventArgs<T>.Replace(e.NewItem, e.OldItem, newIndex, oldIndex));
                     }
                         break;
                     case NotifyCollectionChangedAction.Move:
@@ -212,14 +212,8 @@ namespace ObservableCollections.Internal
                     }
                         break;
                     case NotifyCollectionChangedAction.Reset:
-                        if (!filter.IsNullFilter())
-                        {
-                            foreach (var item in list)
-                            {
-                                filter.InvokeOnRemove(item.Value, e);
-                            }
-                        }
                         list.Clear();
+                        filter.InvokeOnReset(e);
                         break;
                     default:
                         break;
diff --git a/src/ObservableCollections/Internal/SortedViewViewComparer.cs b/src/ObservableCollections/Internal/SortedViewViewComparer.cs
index ab47dc9..eb465de 100644
--- a/src/ObservableCollections/Internal/SortedViewViewComparer.cs
+++ b/src/ObservableCollections/Internal/SortedViewViewComparer.cs
@@ -198,14 +198,14 @@ namespace ObservableCollections.Internal
                     {
                         var oldValue = e.OldItem;
                         var oldId = identitySelector(oldValue);
+                        var oldIndex = -1;
                         if (viewMap.Remove(oldId, out var oldView))
                         {
                             var oldKey = (oldView, oldId);
                             if (list.TryGetValue(oldKey, out var v))
                             {
-                                var oldIndex = list.IndexOfKey(oldKey);
+                                oldIndex = list.IndexOfKey(oldKey);
                                 list.RemoveAt(oldIndex);
-                                filter.InvokeOnRemove(oldValue, oldView, NotifyCollectionChangedEventArgs<T>.Remove(v.Value, oldIndex));
                             }
                         }
 
@@ -216,7 +216,7 @@ namespace ObservableCollections.Internal
                         viewMap.Add(id, view);
 
                         var index = list.IndexOfKey((view, id));
-                        filter.InvokeOnAdd(value, view, NotifyCollectionChangedEventArgs<T>.Add(value, index));
+                        filter.InvokeOnReplace(value, view, NotifyCollectionChangedEventArgs<T>.Replace(e.NewItem, e.OldItem, index, oldIndex));
                         break;
                     }
                     case NotifyCollectionChangedAction.Move:
@@ -231,15 +231,9 @@ namespace ObservableCollections.Internal
                         break;
                     }
                     case NotifyCollectionChangedAction.Reset:
-                        if (!filter.IsNullFilter())
-                        {
-                            foreach (var item in list)
-                            {
-                                filter.InvokeOnRemove(item.Value, e);
-                            }
-                        }
                         list.Clear();
                         viewMap.Clear();
+                        filter.InvokeOnReset(e);
                         break;
                     default:
                         break;
diff --git a/src/ObservableCollections/NotifyCollectionChangedEventArgs.cs b/src/ObservableCollections/NotifyCollectionChangedEventArgs.cs
index 9be0f6d..3622540 100644
--- a/src/ObservableCollections/NotifyCollectionChangedEventArgs.cs
+++ b/src/ObservableCollections/NotifyCollectionChangedEventArgs.cs
@@ -104,14 +104,14 @@ namespace ObservableCollections
             return new NotifyCollectionChangedEventArgs<T>(NotifyCollectionChangedAction.Remove, false, oldItems: oldItems, oldStartingIndex: oldStartingIndex);
         }
 
-        public static NotifyCollectionChangedEventArgs<T> Replace(T newItem, T oldItem, int startingIndex)
+        public static NotifyCollectionChangedEventArgs<T> Replace(T newItem, T oldItem, int newStartingIndex, int oldStartingIndex)
         {
-            return new NotifyCollectionChangedEventArgs<T>(NotifyCollectionChangedAction.Replace, true, newItem: newItem, oldItem: oldItem, newStartingIndex: startingIndex, oldStartingIndex: startingIndex);
+            return new NotifyCollectionChangedEventArgs<T>(NotifyCollectionChangedAction.Replace, true, newItem: newItem, oldItem: oldItem, newStartingIndex: newStartingIndex, oldStartingIndex: oldStartingIndex);
         }
 
-        public static NotifyCollectionChangedEventArgs<T> Replace(ReadOnlySpan<T> newItems, ReadOnlySpan<T> oldItems, int startingIndex)
+        public static NotifyCollectionChangedEventArgs<T> Replace(ReadOnlySpan<T> newItems, ReadOnlySpan<T> oldItems, int newStartingIndex, int oldStartingIndex)
         {
-            return new NotifyCollectionChangedEventArgs<T>(NotifyCollectionChangedAction.Replace, false, newItems: newItems, oldItems: oldItems, newStartingIndex: startingIndex, oldStartingIndex: startingIndex);
+            return new NotifyCollectionChangedEventArgs<T>(NotifyCollectionChangedAction.Replace, false, newItems: newItems, oldItems: oldItems, newStartingIndex: newStartingIndex, oldStartingIndex: oldStartingIndex);
         }
 
         public static NotifyCollectionChangedEventArgs<T> Move(T changedItem, int newStartingIndex, int oldStartingIndex)
diff --git a/src/ObservableCollections/ObservableDictionary.Views.cs b/src/ObservableCollections/ObservableDictionary.Views.cs
index ed250e1..0e87078 100644
--- a/src/ObservableCollections/ObservableDictionary.Views.cs
+++ b/src/ObservableCollections/ObservableDictionary.Views.cs
@@ -148,27 +148,17 @@ namespace ObservableCollections
                             break;
                         case NotifyCollectionChangedAction.Replace:
                         {
-                            if (dict.Remove(e.OldItem.Key, out var oldView))
-                            {
-                                filter.InvokeOnRemove((new KeyValuePair<TKey, TValue>(e.OldItem.Key, oldView.Item1), oldView.Item2), e);
-                            }
-
                             var v = selector(e.NewItem);
+                            dict.Remove(e.OldItem.Key);
                             dict[e.NewItem.Key] = (e.NewItem.Value, v);
-                            filter.InvokeOnAdd(new KeyValuePair<TKey, TValue>(e.NewItem.Key, e.NewItem.Value), v, e);
+                            
+                            filter.InvokeOnReplace(new KeyValuePair<TKey, TValue>(e.NewItem.Key, e.NewItem.Value), v, e);
                         }
                             break;
                         case NotifyCollectionChangedAction.Reset:
                         {
-                            if (!filter.IsNullFilter())
-                            {
-                                foreach (var item in dict)
-                                {
-                                    filter.InvokeOnRemove((new KeyValuePair<TKey, TValue>(item.Key, item.Value.Item1), item.Value.Item2), e);
-                                }
-                            }
-
                             dict.Clear();
+                            filter.InvokeOnReset(e);
                         }
                             break;
                         case NotifyCollectionChangedAction.Move: // ObservableDictionary have no Move operation.
diff --git a/src/ObservableCollections/ObservableDictionary.cs b/src/ObservableCollections/ObservableDictionary.cs
index 4f213b2..b052988 100644
--- a/src/ObservableCollections/ObservableDictionary.cs
+++ b/src/ObservableCollections/ObservableDictionary.cs
@@ -51,8 +51,8 @@ namespace ObservableCollections
                         dictionary[key] = value;
                         CollectionChanged?.Invoke(NotifyCollectionChangedEventArgs<KeyValuePair<TKey, TValue>>.Replace(
                             new KeyValuePair<TKey, TValue>(key, value),
-                            new KeyValuePair<TKey, TValue>(key, oldValue),
-                            -1));
+                            new KeyValuePair<TKey, TValue>(key, oldValue!),
+                            -1, -1));
                     }
                     else
                     {
diff --git a/src/ObservableCollections/ObservableFixedSizeRingBuffer.cs b/src/ObservableCollections/ObservableFixedSizeRingBuffer.cs
index c1c3be6..358397d 100644
--- a/src/ObservableCollections/ObservableFixedSizeRingBuffer.cs
+++ b/src/ObservableCollections/ObservableFixedSizeRingBuffer.cs
@@ -51,7 +51,7 @@ namespace ObservableCollections
                 {
                     var oldValue = buffer[index];
                     buffer[index] = value;
-                    CollectionChanged?.Invoke(NotifyCollectionChangedEventArgs<T>.Replace(value, oldValue, index));
+                    CollectionChanged?.Invoke(NotifyCollectionChangedEventArgs<T>.Replace(value, oldValue, index, index));
                 }
             }
         }
diff --git a/src/ObservableCollections/ObservableHashSet.Views.cs b/src/ObservableCollections/ObservableHashSet.Views.cs
index 3039bef..febd4aa 100644
--- a/src/ObservableCollections/ObservableHashSet.Views.cs
+++ b/src/ObservableCollections/ObservableHashSet.Views.cs
@@ -162,14 +162,8 @@ namespace ObservableCollections
                             }
                             break;
                         case NotifyCollectionChangedAction.Reset:
-                            if (!filter.IsNullFilter())
-                            {
-                                foreach (var item in dict)
-                                {
-                                    filter.InvokeOnRemove(item.Value, e);
-                                }
-                            }
                             dict.Clear();
+                            filter.InvokeOnReset(e);
                             break;
                         case NotifyCollectionChangedAction.Replace:
                         case NotifyCollectionChangedAction.Move:
diff --git a/src/ObservableCollections/ObservableList.Views.cs b/src/ObservableCollections/ObservableList.Views.cs
index b699171..7e188f5 100644
--- a/src/ObservableCollections/ObservableList.Views.cs
+++ b/src/ObservableCollections/ObservableList.Views.cs
@@ -212,12 +212,8 @@ namespace ObservableCollections
                             // ObservableList does not support replace range
                         {
                             var v = (e.NewItem, selector(e.NewItem));
-
-                            var oldItem = list[e.NewStartingIndex];
                             list[e.NewStartingIndex] = v;
-
-                            filter.InvokeOnRemove(oldItem, e);
-                            filter.InvokeOnAdd(v, e);
+                            filter.InvokeOnReplace(v, e);
                             break;
                         }
                         case NotifyCollectionChangedAction.Move:
@@ -230,14 +226,8 @@ namespace ObservableCollections
                         }
                             break;
                         case NotifyCollectionChangedAction.Reset:
-                            if (!filter.IsNullFilter())
-                            {
-                                foreach (var item in list)
-                                {
-                                    filter.InvokeOnRemove(item, e);
-                                }
-                            }
                             list.Clear();
+                            filter.InvokeOnReset(e);
                             break;
                         default:
                             break;
diff --git a/src/ObservableCollections/ObservableList.cs b/src/ObservableCollections/ObservableList.cs
index dc33723..663356f 100644
--- a/src/ObservableCollections/ObservableList.cs
+++ b/src/ObservableCollections/ObservableList.cs
@@ -10,7 +10,7 @@ namespace ObservableCollections
     public sealed partial class ObservableList<T> : IList<T>, IReadOnlyList<T>, IObservableCollection<T>
     {
         readonly List<T> list;
-        public object SyncRoot { get; } = new object();
+        public object SyncRoot { get; } = new();
 
         public ObservableList()
         {
@@ -42,7 +42,7 @@ namespace ObservableCollections
                 {
                     var oldValue = list[index];
                     list[index] = value;
-                    CollectionChanged?.Invoke(NotifyCollectionChangedEventArgs<T>.Replace(value, oldValue, index));
+                    CollectionChanged?.Invoke(NotifyCollectionChangedEventArgs<T>.Replace(value, oldValue, index, index));
                 }
             }
         }
@@ -271,4 +271,4 @@ namespace ObservableCollections
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/ObservableCollections/ObservableQueue.Views.cs b/src/ObservableCollections/ObservableQueue.Views.cs
index bcb9e93..db48cc0 100644
--- a/src/ObservableCollections/ObservableQueue.Views.cs
+++ b/src/ObservableCollections/ObservableQueue.Views.cs
@@ -178,14 +178,8 @@ namespace ObservableCollections
                             }
                             break;
                         case NotifyCollectionChangedAction.Reset:
-                            if (!filter.IsNullFilter())
-                            {
-                                foreach (var item in queue)
-                                {
-                                    filter.InvokeOnRemove(item, e);
-                                }
-                            }
                             queue.Clear();
+                            filter.InvokeOnReset(e);
                             break;
                         case NotifyCollectionChangedAction.Replace:
                         case NotifyCollectionChangedAction.Move:
diff --git a/src/ObservableCollections/ObservableRingBuffer.Views.cs b/src/ObservableCollections/ObservableRingBuffer.Views.cs
index a0866b4..33fac6a 100644
--- a/src/ObservableCollections/ObservableRingBuffer.Views.cs
+++ b/src/ObservableCollections/ObservableRingBuffer.Views.cs
@@ -224,25 +224,15 @@ namespace ObservableCollections
                             }
                             break;
                         case NotifyCollectionChangedAction.Reset:
-                            if (!filter.IsNullFilter())
-                            {
-                                foreach (var item in ringBuffer)
-                                {
-                                    filter.InvokeOnRemove(item, e);
-                                }
-                            }
                             ringBuffer.Clear();
+                            filter.InvokeOnReset(e);
                             break;
                         case NotifyCollectionChangedAction.Replace:
                             // range is not supported
                             {
                                 var v = (e.NewItem, selector(e.NewItem));
-
-                                var oldItem = ringBuffer[e.NewStartingIndex];
                                 ringBuffer[e.NewStartingIndex] = v;
-
-                                filter.InvokeOnRemove(oldItem, e);
-                                filter.InvokeOnAdd(v, e);
+                                filter.InvokeOnReplace(v, e);
                                 break;
                             }
                         case NotifyCollectionChangedAction.Move:
diff --git a/src/ObservableCollections/ObservableRingBuffer.cs b/src/ObservableCollections/ObservableRingBuffer.cs
index 3a92de2..26976b9 100644
--- a/src/ObservableCollections/ObservableRingBuffer.cs
+++ b/src/ObservableCollections/ObservableRingBuffer.cs
@@ -41,7 +41,7 @@ namespace ObservableCollections
                 {
                     var oldValue = buffer[index];
                     buffer[index] = value;
-                    CollectionChanged?.Invoke(NotifyCollectionChangedEventArgs<T>.Replace(value, oldValue, index));
+                    CollectionChanged?.Invoke(NotifyCollectionChangedEventArgs<T>.Replace(value, oldValue, index, index));
                 }
             }
         }
diff --git a/src/ObservableCollections/ObservableStack.Views.cs b/src/ObservableCollections/ObservableStack.Views.cs
index a21c1e0..e610fb4 100644
--- a/src/ObservableCollections/ObservableStack.Views.cs
+++ b/src/ObservableCollections/ObservableStack.Views.cs
@@ -178,14 +178,8 @@ namespace ObservableCollections
                             }
                             break;
                         case NotifyCollectionChangedAction.Reset:
-                            if (!filter.IsNullFilter())
-                            {
-                                foreach (var item in stack)
-                                {
-                                    filter.InvokeOnRemove(item, e);
-                                }
-                            }
                             stack.Clear();
+                            filter.InvokeOnReset(e);
                             break;
                         case NotifyCollectionChangedAction.Replace:
                         case NotifyCollectionChangedAction.Move:
diff --git a/tests/ObservableCollections.Tests/ObservableDictionaryTest.cs b/tests/ObservableCollections.Tests/ObservableDictionaryTest.cs
index 9eb733c..9f6d23f 100644
--- a/tests/ObservableCollections.Tests/ObservableDictionaryTest.cs
+++ b/tests/ObservableCollections.Tests/ObservableDictionaryTest.cs
@@ -1,6 +1,7 @@
 using FluentAssertions;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.Linq;
 using Xunit;
 
@@ -126,33 +127,30 @@ namespace ObservableCollections.Tests
             filter3.CalledWhenTrue.Select(x => x.Item1.Value).Should().Equal(-40, -34, -12);
 
             dict.Add(99, -100);
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value)).Should().Equal((ChangedKind.Add, -100));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value)).Should().Equal((ChangedKind.Add, -100));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value)).Should().Equal((ChangedKind.Add, -100));
+            filter1.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value.Value)).Should().Equal((NotifyCollectionChangedAction.Add, -100));
+            filter2.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value.Value)).Should().Equal((NotifyCollectionChangedAction.Add, -100));
+            filter3.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value.Value)).Should().Equal((NotifyCollectionChangedAction.Add, -100));
             foreach (var item in new[] { filter1, filter2, filter3 }) item.CalledOnCollectionChanged.Clear();
 
             dict[10] = -1090;
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value)).Should().Equal((ChangedKind.Remove, -12), (ChangedKind.Add, -1090));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value)).Should().Equal((ChangedKind.Remove, -12), (ChangedKind.Add, -1090));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value)).Should().Equal((ChangedKind.Remove, -12), (ChangedKind.Add, -1090));
+            filter1.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value.Value)).Should().Equal((NotifyCollectionChangedAction.Replace, -1090));
+            filter2.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value.Value)).Should().Equal((NotifyCollectionChangedAction.Replace, -1090));
+            filter3.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value.Value)).Should().Equal((NotifyCollectionChangedAction.Replace, -1090));
             foreach (var item in new[] { filter1, filter2, filter3 }) item.CalledOnCollectionChanged.Clear();
 
             dict.Remove(20);
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value)).Should().Equal((ChangedKind.Remove, -25));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value)).Should().Equal((ChangedKind.Remove, -25));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value)).Should().Equal((ChangedKind.Remove, -25));
+            filter1.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value.Value)).Should().Equal((NotifyCollectionChangedAction.Remove, -25));
+            filter2.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value.Value)).Should().Equal((NotifyCollectionChangedAction.Remove, -25));
+            filter3.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value.Value)).Should().Equal((NotifyCollectionChangedAction.Remove, -25));
             foreach (var item in new[] { filter1, filter2, filter3 }) item.CalledOnCollectionChanged.Clear();
 
             dict.Clear();
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value))
-                .OrderBy(x => x.Value)
-                .Should().Equal((ChangedKind.Remove, -1090), (ChangedKind.Remove, -100), (ChangedKind.Remove, -53), (ChangedKind.Remove, -40), (ChangedKind.Remove, -34));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value))
-                .OrderBy(x => x.Value)
-                .Should().Equal((ChangedKind.Remove, -1090), (ChangedKind.Remove, -100), (ChangedKind.Remove, -53), (ChangedKind.Remove, -40), (ChangedKind.Remove, -34));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value.Value))
-                .OrderBy(x => x.Value)
-                .Should().Equal((ChangedKind.Remove, -1090), (ChangedKind.Remove, -100), (ChangedKind.Remove, -53), (ChangedKind.Remove, -40), (ChangedKind.Remove, -34));
+            filter1.CalledOnCollectionChanged.Select(x => x.changedAction)
+                .Should().Equal(NotifyCollectionChangedAction.Reset);
+            filter2.CalledOnCollectionChanged.Select(x => x.changedAction)
+                .Should().Equal(NotifyCollectionChangedAction.Reset);
+            filter3.CalledOnCollectionChanged.Select(x => x.changedAction)
+                .Should().Equal(NotifyCollectionChangedAction.Reset);
         }
         
         [Fact]
@@ -171,15 +169,15 @@ namespace ObservableCollections.Tests
             view1.AttachFilter(filter1, true);
 
             filter1.CalledOnCollectionChanged.Count.Should().Be(5);
-            filter1.CalledOnCollectionChanged[0].changedKind.Should().Be(ChangedKind.Add);
+            filter1.CalledOnCollectionChanged[0].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter1.CalledOnCollectionChanged[0].value.Key.Should().Be(10);
-            filter1.CalledOnCollectionChanged[1].changedKind.Should().Be(ChangedKind.Add);
+            filter1.CalledOnCollectionChanged[1].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter1.CalledOnCollectionChanged[1].value.Key.Should().Be(50);
-            filter1.CalledOnCollectionChanged[2].changedKind.Should().Be(ChangedKind.Add);
+            filter1.CalledOnCollectionChanged[2].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter1.CalledOnCollectionChanged[2].value.Key.Should().Be(30);
-            filter1.CalledOnCollectionChanged[3].changedKind.Should().Be(ChangedKind.Add);
+            filter1.CalledOnCollectionChanged[3].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter1.CalledOnCollectionChanged[3].value.Key.Should().Be(20);
-            filter1.CalledOnCollectionChanged[4].changedKind.Should().Be(ChangedKind.Add);
+            filter1.CalledOnCollectionChanged[4].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter1.CalledOnCollectionChanged[4].value.Key.Should().Be(40);
 
             filter1.CalledWhenTrue.Count.Should().Be(3);
diff --git a/tests/ObservableCollections.Tests/ObservableHashSetTest.cs b/tests/ObservableCollections.Tests/ObservableHashSetTest.cs
index fcddbb8..66606b2 100644
--- a/tests/ObservableCollections.Tests/ObservableHashSetTest.cs
+++ b/tests/ObservableCollections.Tests/ObservableHashSetTest.cs
@@ -1,6 +1,7 @@
 using FluentAssertions;
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -69,12 +70,12 @@ namespace ObservableCollections.Tests
             set.Add(33);
             set.AddRange(new[] { 98 });
 
-            filter.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Add, 33), (ChangedKind.Add, 98));
+            filter.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Add, 33), (NotifyCollectionChangedAction.Add, 98));
             filter.Clear();
 
             set.Remove(10);
             set.RemoveRange(new[] { 50, 30 });
-            filter.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 10), (ChangedKind.Remove, 50), (ChangedKind.Remove, 30));
+            filter.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Remove, 10), (NotifyCollectionChangedAction.Remove, 50), (NotifyCollectionChangedAction.Remove, 30));
         }
         
         [Fact]
@@ -92,15 +93,15 @@ namespace ObservableCollections.Tests
 
             view.AttachFilter(filter, true);
             filter.CalledOnCollectionChanged.Count.Should().Be(5);
-            filter.CalledOnCollectionChanged[0].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[0].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[0].value.Should().Be(10);
-            filter.CalledOnCollectionChanged[1].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[1].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[1].value.Should().Be(50);
-            filter.CalledOnCollectionChanged[2].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[2].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[2].value.Should().Be(30);
-            filter.CalledOnCollectionChanged[3].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[3].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[3].value.Should().Be(20);
-            filter.CalledOnCollectionChanged[4].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[4].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[4].value.Should().Be(40);
 
             filter.CalledWhenTrue.Count.Should().Be(1);
diff --git a/tests/ObservableCollections.Tests/ObservableListTest.cs b/tests/ObservableCollections.Tests/ObservableListTest.cs
index edf28b9..fe76f73 100644
--- a/tests/ObservableCollections.Tests/ObservableListTest.cs
+++ b/tests/ObservableCollections.Tests/ObservableListTest.cs
@@ -1,6 +1,7 @@
 using FluentAssertions;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.Linq;
 using Xunit;
 
@@ -178,45 +179,45 @@ namespace ObservableCollections.Tests
             filter2.CalledWhenFalse.Select(x => x.Item1).Should().Equal(101);
             filter3.CalledWhenFalse.Select(x => x.Item1).Should().Equal(101);
 
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Add, 100), (ChangedKind.Add, 101));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Add, 100), (ChangedKind.Add, 101));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Add, 100), (ChangedKind.Add, 101));
+            filter1.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Add, 100), (NotifyCollectionChangedAction.Add, 101));
+            filter2.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Add, 100), (NotifyCollectionChangedAction.Add, 101));
+            filter3.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Add, 100), (NotifyCollectionChangedAction.Add, 101));
 
             foreach (var item in new[] { filter1, filter2, filter3 }) item.CalledOnCollectionChanged.Clear();
 
             list.Insert(0, 1000);
             list.InsertRange(0, new[] { 999 });
 
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Add, 1000), (ChangedKind.Add, 999));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Add, 1000), (ChangedKind.Add, 999));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Add, 1000), (ChangedKind.Add, 999));
+            filter1.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Add, 1000), (NotifyCollectionChangedAction.Add, 999));
+            filter2.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Add, 1000), (NotifyCollectionChangedAction.Add, 999));
+            filter3.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Add, 1000), (NotifyCollectionChangedAction.Add, 999));
             foreach (var item in new[] { filter1, filter2, filter3 }) item.CalledOnCollectionChanged.Clear();
 
             list.RemoveAt(0);
             list.RemoveRange(0, 1);
 
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 999), (ChangedKind.Remove, 1000));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 999), (ChangedKind.Remove, 1000));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 999), (ChangedKind.Remove, 1000));
+            filter1.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Remove, 999), (NotifyCollectionChangedAction.Remove, 1000));
+            filter2.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Remove, 999), (NotifyCollectionChangedAction.Remove, 1000));
+            filter3.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Remove, 999), (NotifyCollectionChangedAction.Remove, 1000));
             foreach (var item in new[] { filter1, filter2, filter3 }) item.CalledOnCollectionChanged.Clear();
 
             list[0] = 9999;
 
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 10), (ChangedKind.Add, 9999));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 10), (ChangedKind.Add, 9999));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 10), (ChangedKind.Add, 9999));
+            filter1.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Replace, 9999));
+            filter2.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Replace, 9999));
+            filter3.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Replace, 9999));
             foreach (var item in new[] { filter1, filter2, filter3 }) item.CalledOnCollectionChanged.Clear();
 
             list.Move(3, 0);
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Move, 44));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Move, 44));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Move, 44));
+            filter1.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Move, 44));
+            filter2.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Move, 44));
+            filter3.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Move, 44));
             foreach (var item in new[] { filter1, filter2, filter3 }) item.CalledOnCollectionChanged.Clear();
 
             list.Clear();
-            filter1.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 44), (ChangedKind.Remove, 9999), (ChangedKind.Remove, 21), (ChangedKind.Remove, 30), (ChangedKind.Remove, 45), (ChangedKind.Remove, 66), (ChangedKind.Remove, 90), (ChangedKind.Remove, 100), (ChangedKind.Remove, 101));
-            filter2.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 21), (ChangedKind.Remove, 30), (ChangedKind.Remove, 44), (ChangedKind.Remove, 45), (ChangedKind.Remove, 66), (ChangedKind.Remove, 90), (ChangedKind.Remove, 100), (ChangedKind.Remove, 101), (ChangedKind.Remove, 9999));
-            filter3.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 21), (ChangedKind.Remove, 30), (ChangedKind.Remove, 44), (ChangedKind.Remove, 45), (ChangedKind.Remove, 66), (ChangedKind.Remove, 90), (ChangedKind.Remove, 100), (ChangedKind.Remove, 101), (ChangedKind.Remove, 9999));
+            filter1.CalledOnCollectionChanged.Select(x => x.changedAction).Should().Equal(NotifyCollectionChangedAction.Reset);
+            filter2.CalledOnCollectionChanged.Select(x => x.changedAction).Should().Equal(NotifyCollectionChangedAction.Reset);
+            filter3.CalledOnCollectionChanged.Select(x => x.changedAction).Should().Equal(NotifyCollectionChangedAction.Reset);
         }
 
         [Fact]
@@ -229,13 +230,13 @@ namespace ObservableCollections.Tests
             var filter1 = new TestFilter<int>((x, v) => x % 2 == 0);
             view1.AttachFilter(filter1, true);
             
-            filter1.CalledOnCollectionChanged[0].changedKind.Should().Be(ChangedKind.Add);
+            filter1.CalledOnCollectionChanged[0].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter1.CalledOnCollectionChanged[0].value.Should().Be(10);
-            filter1.CalledOnCollectionChanged[1].changedKind.Should().Be(ChangedKind.Add);
+            filter1.CalledOnCollectionChanged[1].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter1.CalledOnCollectionChanged[1].value.Should().Be(21);
-            filter1.CalledOnCollectionChanged[2].changedKind.Should().Be(ChangedKind.Add);
+            filter1.CalledOnCollectionChanged[2].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter1.CalledOnCollectionChanged[2].value.Should().Be(30);
-            filter1.CalledOnCollectionChanged[3].changedKind.Should().Be(ChangedKind.Add);
+            filter1.CalledOnCollectionChanged[3].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter1.CalledOnCollectionChanged[3].value.Should().Be(44);
 
             filter1.CalledWhenTrue.Count.Should().Be(3);
diff --git a/tests/ObservableCollections.Tests/ObservableQueueTest.cs b/tests/ObservableCollections.Tests/ObservableQueueTest.cs
index bfdb08f..36e199b 100644
--- a/tests/ObservableCollections.Tests/ObservableQueueTest.cs
+++ b/tests/ObservableCollections.Tests/ObservableQueueTest.cs
@@ -1,6 +1,7 @@
 using FluentAssertions;
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -73,12 +74,12 @@ namespace ObservableCollections.Tests
             queue.Enqueue(33);
             queue.EnqueueRange(new[] { 98 });
 
-            filter.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Add, 33), (ChangedKind.Add, 98));
+            filter.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Add, 33), (NotifyCollectionChangedAction.Add, 98));
             filter.Clear();
 
             queue.Dequeue();
             queue.DequeueRange(2);
-            filter.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 10), (ChangedKind.Remove, 50), (ChangedKind.Remove, 30));
+            filter.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Remove, 10), (NotifyCollectionChangedAction.Remove, 50), (NotifyCollectionChangedAction.Remove, 30));
         }
         
         [Fact]
@@ -97,15 +98,15 @@ namespace ObservableCollections.Tests
             view.AttachFilter(filter, true);
             
             filter.CalledOnCollectionChanged.Count.Should().Be(5);
-            filter.CalledOnCollectionChanged[0].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[0].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[0].value.Should().Be(10);
-            filter.CalledOnCollectionChanged[1].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[1].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[1].value.Should().Be(50);
-            filter.CalledOnCollectionChanged[2].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[2].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[2].value.Should().Be(30);
-            filter.CalledOnCollectionChanged[3].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[3].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[3].value.Should().Be(20);
-            filter.CalledOnCollectionChanged[4].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[4].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[4].value.Should().Be(40);
 
             filter.CalledWhenTrue.Count.Should().Be(1);
diff --git a/tests/ObservableCollections.Tests/ObservableStackTest.cs b/tests/ObservableCollections.Tests/ObservableStackTest.cs
index 02a2b9c..1b90f57 100644
--- a/tests/ObservableCollections.Tests/ObservableStackTest.cs
+++ b/tests/ObservableCollections.Tests/ObservableStackTest.cs
@@ -1,6 +1,7 @@
 using FluentAssertions;
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -73,12 +74,12 @@ namespace ObservableCollections.Tests
             stack.Push(33);
             stack.PushRange(new[] { 98 });
 
-            filter.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Add, 33), (ChangedKind.Add, 98));
+            filter.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Add, 33), (NotifyCollectionChangedAction.Add, 98));
             filter.Clear();
 
             stack.Pop();
             stack.PopRange(2);
-            filter.CalledOnCollectionChanged.Select(x => (x.changedKind, x.value)).Should().Equal((ChangedKind.Remove, 98), (ChangedKind.Remove, 33), (ChangedKind.Remove, 40));
+            filter.CalledOnCollectionChanged.Select(x => (x.changedAction, x.value)).Should().Equal((NotifyCollectionChangedAction.Remove, 98), (NotifyCollectionChangedAction.Remove, 33), (NotifyCollectionChangedAction.Remove, 40));
         }
         
         [Fact]
@@ -96,15 +97,15 @@ namespace ObservableCollections.Tests
 
             view.AttachFilter(filter, true);
             filter.CalledOnCollectionChanged.Count.Should().Be(5);
-            filter.CalledOnCollectionChanged[4].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[4].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[4].value.Should().Be(10);
-            filter.CalledOnCollectionChanged[3].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[3].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[3].value.Should().Be(50);
-            filter.CalledOnCollectionChanged[2].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[2].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[2].value.Should().Be(30);
-            filter.CalledOnCollectionChanged[1].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[1].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[1].value.Should().Be(20);
-            filter.CalledOnCollectionChanged[0].changedKind.Should().Be(ChangedKind.Add);
+            filter.CalledOnCollectionChanged[0].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
             filter.CalledOnCollectionChanged[0].value.Should().Be(40);
 
             filter.CalledWhenTrue.Count.Should().Be(1);
diff --git a/tests/ObservableCollections.Tests/SortedViewTest.cs b/tests/ObservableCollections.Tests/SortedViewTest.cs
index 4b22bec..0a7bd12 100644
--- a/tests/ObservableCollections.Tests/SortedViewTest.cs
+++ b/tests/ObservableCollections.Tests/SortedViewTest.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Collections.Specialized;
 
 namespace ObservableCollections.Tests;
 
@@ -49,21 +50,19 @@ public class SortedViewTest
         sortedView.AttachFilter(filter);
         
         list.Add(20);
-        filter.CalledOnCollectionChanged[0].changedKind.Should().Be(ChangedKind.Add);
+        filter.CalledOnCollectionChanged[0].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
         filter.CalledOnCollectionChanged[0].value.Should().Be(20);
         filter.CalledOnCollectionChanged[0].index.Should().Be(1);
 
         list.Remove(20);
-        filter.CalledOnCollectionChanged[1].changedKind.Should().Be(ChangedKind.Remove);
+        filter.CalledOnCollectionChanged[1].changedAction.Should().Be(NotifyCollectionChangedAction.Remove);
         filter.CalledOnCollectionChanged[1].value.Should().Be(20);
         filter.CalledOnCollectionChanged[1].oldIndex.Should().Be(1);
 
         list[1] = 999; // from 10(at 0 in original) to 999
-        filter.CalledOnCollectionChanged[2].changedKind.Should().Be(ChangedKind.Remove);
-        filter.CalledOnCollectionChanged[2].value.Should().Be(10);
+        filter.CalledOnCollectionChanged[2].changedAction.Should().Be(NotifyCollectionChangedAction.Replace);
+        filter.CalledOnCollectionChanged[2].value.Should().Be(999);
+        filter.CalledOnCollectionChanged[2].index.Should().Be(1);
         filter.CalledOnCollectionChanged[2].oldIndex.Should().Be(0);
-        filter.CalledOnCollectionChanged[3].changedKind.Should().Be(ChangedKind.Add);
-        filter.CalledOnCollectionChanged[3].value.Should().Be(999);
-        filter.CalledOnCollectionChanged[3].index.Should().Be(1);
     }
 }
\ No newline at end of file
diff --git a/tests/ObservableCollections.Tests/SortedViewViewComparerTest.cs b/tests/ObservableCollections.Tests/SortedViewViewComparerTest.cs
index ee6dcf3..095bfd6 100644
--- a/tests/ObservableCollections.Tests/SortedViewViewComparerTest.cs
+++ b/tests/ObservableCollections.Tests/SortedViewViewComparerTest.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Collections.Specialized;
 
 namespace ObservableCollections.Tests;
 
@@ -49,21 +50,19 @@ public class SortedViewViewComparerTest
         sortedView.AttachFilter(filter);
         
         list.Add(20);
-        filter.CalledOnCollectionChanged[0].changedKind.Should().Be(ChangedKind.Add);
+        filter.CalledOnCollectionChanged[0].changedAction.Should().Be(NotifyCollectionChangedAction.Add);
         filter.CalledOnCollectionChanged[0].value.Should().Be(20);
         filter.CalledOnCollectionChanged[0].index.Should().Be(1);
 
         list.Remove(20);
-        filter.CalledOnCollectionChanged[1].changedKind.Should().Be(ChangedKind.Remove);
+        filter.CalledOnCollectionChanged[1].changedAction.Should().Be(NotifyCollectionChangedAction.Remove);
         filter.CalledOnCollectionChanged[1].value.Should().Be(20);
         filter.CalledOnCollectionChanged[1].oldIndex.Should().Be(1);
 
         list[1] = 999; // from 10(at 0 in original) to 999
-        filter.CalledOnCollectionChanged[2].changedKind.Should().Be(ChangedKind.Remove);
-        filter.CalledOnCollectionChanged[2].value.Should().Be(10);
+        filter.CalledOnCollectionChanged[2].changedAction.Should().Be(NotifyCollectionChangedAction.Replace);
+        filter.CalledOnCollectionChanged[2].value.Should().Be(999);
+        filter.CalledOnCollectionChanged[2].index.Should().Be(1);
         filter.CalledOnCollectionChanged[2].oldIndex.Should().Be(0);
-        filter.CalledOnCollectionChanged[3].changedKind.Should().Be(ChangedKind.Add);
-        filter.CalledOnCollectionChanged[3].value.Should().Be(999);
-        filter.CalledOnCollectionChanged[3].index.Should().Be(1);
     }
 }
\ No newline at end of file
diff --git a/tests/ObservableCollections.Tests/ViewContainer.cs b/tests/ObservableCollections.Tests/ViewContainer.cs
index 256941b..c874320 100644
--- a/tests/ObservableCollections.Tests/ViewContainer.cs
+++ b/tests/ObservableCollections.Tests/ViewContainer.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 
 namespace ObservableCollections.Tests
 {
@@ -12,7 +13,7 @@ namespace ObservableCollections.Tests
 
         public T Value { get; }
 
-        public static implicit operator ViewContainer<T>(T value) => new ViewContainer<T>(value);
+        public static implicit operator ViewContainer<T>(T value) => new(value);
 
         public override int GetHashCode()
         {
@@ -35,7 +36,7 @@ namespace ObservableCollections.Tests
         readonly Func<T, ViewContainer<T>, bool> filter;
         public List<(T, ViewContainer<T>)> CalledWhenTrue = new();
         public List<(T, ViewContainer<T>)> CalledWhenFalse = new();
-        public List<(ChangedKind changedKind, T value, ViewContainer<T> view, int index, int oldIndex)> CalledOnCollectionChanged = new();
+        public List<(NotifyCollectionChangedAction changedAction, T value, ViewContainer<T> view, int index, int oldIndex)> CalledOnCollectionChanged = new();
 
         public TestFilter(Func<T, ViewContainer<T>, bool> filter)
         {
@@ -54,9 +55,9 @@ namespace ObservableCollections.Tests
             return this.filter.Invoke(value, view);
         }
 
-        public void OnCollectionChanged(ChangedKind changedKind, T value, ViewContainer<T> view, in NotifyCollectionChangedEventArgs<T> eventArgs)
+        public void OnCollectionChanged(NotifyCollectionChangedAction changedAction, T value, ViewContainer<T> view, in NotifyCollectionChangedEventArgs<T> eventArgs)
         {
-            CalledOnCollectionChanged.Add((changedKind, value, view, eventArgs.NewStartingIndex, eventArgs.OldStartingIndex));
+            CalledOnCollectionChanged.Add((changedAction, value, view, eventArgs.NewStartingIndex, eventArgs.OldStartingIndex));
         }
 
         public void WhenTrue(T value, ViewContainer<T> view)
@@ -75,7 +76,7 @@ namespace ObservableCollections.Tests
         readonly Func<KeyValuePair<T, T>, ViewContainer<T>, bool> filter;
         public List<(KeyValuePair<T, T>, ViewContainer<T>)> CalledWhenTrue = new();
         public List<(KeyValuePair<T, T>, ViewContainer<T>)> CalledWhenFalse = new();
-        public List<(ChangedKind changedKind, KeyValuePair<T, T> value, ViewContainer<T> view)> CalledOnCollectionChanged = new();
+        public List<(NotifyCollectionChangedAction changedAction, KeyValuePair<T, T> value, ViewContainer<T> view)> CalledOnCollectionChanged = new();
 
         public TestFilter2(Func<KeyValuePair<T, T>, ViewContainer<T>, bool> filter)
         {
@@ -94,9 +95,9 @@ namespace ObservableCollections.Tests
             return this.filter.Invoke(value, view);
         }
 
-        public void OnCollectionChanged(ChangedKind changedKind, KeyValuePair<T, T> value, ViewContainer<T> view, in NotifyCollectionChangedEventArgs<KeyValuePair<T, T>> eventArgs)
+        public void OnCollectionChanged(NotifyCollectionChangedAction changedAction, KeyValuePair<T, T> value, ViewContainer<T> view, in NotifyCollectionChangedEventArgs<KeyValuePair<T, T>> eventArgs)
         {
-            CalledOnCollectionChanged.Add((changedKind, value, view));
+            CalledOnCollectionChanged.Add((changedAction, value, view));
         }
 
         public void WhenTrue(KeyValuePair<T, T> value, ViewContainer<T> view)