From dce0bb618914376483391f252ca0486e3e9b9faa Mon Sep 17 00:00:00 2001
From: Yoshifumi Kawai <46207+neuecc@users.noreply.github.com>
Date: Wed, 4 Sep 2024 08:47:47 +0900
Subject: [PATCH 1/8] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8170ac4..761ccca 100644
--- a/README.md
+++ b/README.md
@@ -58,7 +58,7 @@ Observable<CollectionResetEvent<T>> IObservableCollection<T>.ObserveReset()
 Observable<CollectionResetEvent<T>> IObservableCollection<T>.ObserveReset()
 Observable<Unit> IObservableCollection<T>.ObserveClear<T>()
 Observable<(int Index, int Count)> IObservableCollection<T>.ObserveReverse<T>()
-Observable<(int Index, int Count, IComparer<T> Comparer)> IObservableCollection<T>.ObserveSort<T>()
+Observable<(int Index, int Count, IComparer<T>? Comparer)> IObservableCollection<T>.ObserveSort<T>()
 Observable<int> IObservableCollection<T>.ObserveCountChanged<T>()
 ```
 

From 7a573289ea1deb20f3350c851471dae0ed6f1d67 Mon Sep 17 00:00:00 2001
From: neuecc <ils@neue.cc>
Date: Wed, 4 Sep 2024 08:53:19 +0900
Subject: [PATCH 2/8] fix ObserveSort comparer nullable annotation

---
 .../ObservableCollectionR3Extensions.cs                | 10 +++++-----
 .../NotifyCollectionChangedEventArgs.cs                |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/ObservableCollections.R3/ObservableCollectionR3Extensions.cs b/src/ObservableCollections.R3/ObservableCollectionR3Extensions.cs
index 67d5da7..c62a02e 100644
--- a/src/ObservableCollections.R3/ObservableCollectionR3Extensions.cs
+++ b/src/ObservableCollections.R3/ObservableCollectionR3Extensions.cs
@@ -71,7 +71,7 @@ public static class ObservableCollectionR3Extensions
         return new ObservableCollectionReverse<T>(source, cancellationToken);
     }
 
-    public static Observable<(int Index, int Count, IComparer<T> Comparer)> ObserveSort<T>(this IObservableCollection<T> source, CancellationToken cancellationToken = default)
+    public static Observable<(int Index, int Count, IComparer<T>? Comparer)> ObserveSort<T>(this IObservableCollection<T> source, CancellationToken cancellationToken = default)
     {
         return new ObservableCollectionSort<T>(source, cancellationToken);
     }
@@ -290,18 +290,18 @@ sealed class ObservableCollectionReverse<T>(IObservableCollection<T> collection,
     }
 }
 
-sealed class ObservableCollectionSort<T>(IObservableCollection<T> collection, CancellationToken cancellationToken) : Observable<(int Index, int Count, IComparer<T> Comparer)>
+sealed class ObservableCollectionSort<T>(IObservableCollection<T> collection, CancellationToken cancellationToken) : Observable<(int Index, int Count, IComparer<T>? Comparer)>
 {
-    protected override IDisposable SubscribeCore(Observer<(int Index, int Count, IComparer<T> Comparer)> observer)
+    protected override IDisposable SubscribeCore(Observer<(int Index, int Count, IComparer<T>? Comparer)> observer)
     {
         return new _ObservableCollectionSort(collection, observer, cancellationToken);
     }
 
     sealed class _ObservableCollectionSort(
         IObservableCollection<T> collection,
-        Observer<(int Index, int Count, IComparer<T> Comparer)> observer,
+        Observer<(int Index, int Count, IComparer<T>? Comparer)> observer,
         CancellationToken cancellationToken)
-        : ObservableCollectionObserverBase<T, (int Index, int Count, IComparer<T> Comparer)>(collection, observer, cancellationToken)
+        : ObservableCollectionObserverBase<T, (int Index, int Count, IComparer<T>? Comparer)>(collection, observer, cancellationToken)
     {
         protected override void Handler(in NotifyCollectionChangedEventArgs<T> eventArgs)
         {
diff --git a/src/ObservableCollections/NotifyCollectionChangedEventArgs.cs b/src/ObservableCollections/NotifyCollectionChangedEventArgs.cs
index 790c606..22c149a 100644
--- a/src/ObservableCollections/NotifyCollectionChangedEventArgs.cs
+++ b/src/ObservableCollections/NotifyCollectionChangedEventArgs.cs
@@ -25,9 +25,9 @@ namespace ObservableCollections
             Comparer = comparer ?? NullComparerSentinel.Instance;
         }
 
-        public (int Index, int Count, IComparer<T> Comparer) AsTuple()
+        public (int Index, int Count, IComparer<T>? Comparer) AsTuple()
         {
-            return (Index, Count, Comparer!);
+            return (Index, Count, Comparer);
         }
 
         public static SortOperation<T> CreateReverse(int index, int count)

From 7ad977ffca03b5608d1c05beaff4453d6e485c96 Mon Sep 17 00:00:00 2001
From: neuecc <ils@neue.cc>
Date: Wed, 4 Sep 2024 10:40:04 +0900
Subject: [PATCH 3/8] support Range for ToNotifyCollectionChanged #67

---
 README.md                                     |  4 +
 sandbox/AvaloniaApp/MainWindow.axaml          | 11 ++-
 sandbox/AvaloniaApp/MainWindow.axaml.cs       | 58 ++++++++++--
 sandbox/WpfApp/MainWindow.xaml                |  2 +
 sandbox/WpfApp/MainWindow.xaml.cs             | 22 ++++-
 .../AlternateIndexList.cs                     |  4 +-
 .../ObservableList.OptimizeView.cs            | 10 ++-
 .../SynchronizedViewList.cs                   | 88 ++++++++++++++++---
 8 files changed, 168 insertions(+), 31 deletions(-)

diff --git a/README.md b/README.md
index 761ccca..21cf6b9 100644
--- a/README.md
+++ b/README.md
@@ -355,6 +355,10 @@ public class WpfDispatcherCollection(Dispatcher dispatcher) : ICollectionEventDi
 }
 ```
 
+`ToNotifyCollectionChanged()` can also be called without going through a View. In this case, it's guaranteed that no filters will be applied, making it faster. If you want to apply filters, please generate a View before calling it. Additionally, `ObservableList` has a variation called `ToNotifyCollectionChangedSlim()`. This option doesn't generate a list for the View and shares the actual data, making it the fastest and most memory-efficient option. However, range operations such as `AddRange`, `InsertRange` and `RemoveRange` are not supported by WPF (or Avalonia), so they will throw runtime exceptions.
+
+Views and ToNotifyCollectionChanged are internally connected by events, so they need to be `Dispose` to release those connections.
+
 Unity
 ---
 In Unity projects, you can installing `ObservableCollections` with [NugetForUnity](https://github.com/GlitchEnzo/NuGetForUnity). If R3 integration is required, similarly install `ObservableCollections.R3` via NuGetForUnity.
diff --git a/sandbox/AvaloniaApp/MainWindow.axaml b/sandbox/AvaloniaApp/MainWindow.axaml
index cfd3b92..9530d9b 100644
--- a/sandbox/AvaloniaApp/MainWindow.axaml
+++ b/sandbox/AvaloniaApp/MainWindow.axaml
@@ -7,7 +7,14 @@
         Title="AvaloniaApp">
 	<StackPanel>
 		<ListBox ItemsSource="{Binding ItemsView}" x:CompileBindings="False" />
-		<Button Content="Add" Command="{Binding AddCommand}" x:CompileBindings="False" />
-		<Button Content="Clear" Command="{Binding ClearCommand}"  x:CompileBindings="False" />
+		<Button Content="Add" Command="{Binding AddCommand}"  x:CompileBindings="False"/>
+		<Button Content="AddRange" Command="{Binding AddRangeCommand}"  x:CompileBindings="False"/>
+		<Button Content="Insert" Command="{Binding InsertAtRandomCommand}" x:CompileBindings="False" />
+		<Button Content="Remove" Command="{Binding RemoveAtRandomCommand}" x:CompileBindings="False" />
+		<Button Content="Clear" Command="{Binding ClearCommand}"  x:CompileBindings="False"/>
+		<Button Content="Reverse" Command="{Binding ReverseCommand}" x:CompileBindings="False" />
+		<Button Content="Sort" Command="{Binding SortCommand}"  x:CompileBindings="False"/>
+		<Button Content="AttachFilter" Command="{Binding AttachFilterCommand}" x:CompileBindings="False" />
+		<Button Content="ResetFilter" Command="{Binding ResetFilterCommand}" x:CompileBindings="False" />
 	</StackPanel>
 </Window>
diff --git a/sandbox/AvaloniaApp/MainWindow.axaml.cs b/sandbox/AvaloniaApp/MainWindow.axaml.cs
index b6c6dc6..92d9326 100644
--- a/sandbox/AvaloniaApp/MainWindow.axaml.cs
+++ b/sandbox/AvaloniaApp/MainWindow.axaml.cs
@@ -26,22 +26,27 @@ namespace AvaloniaApp
         private ObservableList<int> observableList { get; } = new ObservableList<int>();
         public INotifyCollectionChangedSynchronizedViewList<int> ItemsView { get; }
         public ReactiveCommand<Unit> AddCommand { get; } = new ReactiveCommand<Unit>();
+        public ReactiveCommand<Unit> AddRangeCommand { get; } = new ReactiveCommand<Unit>();
+        public ReactiveCommand<Unit> InsertAtRandomCommand { get; } = new ReactiveCommand<Unit>();
+        public ReactiveCommand<Unit> RemoveAtRandomCommand { get; } = new ReactiveCommand<Unit>();
         public ReactiveCommand<Unit> ClearCommand { get; } = new ReactiveCommand<Unit>();
+        public ReactiveCommand<Unit> ReverseCommand { get; } = new ReactiveCommand<Unit>();
+        public ReactiveCommand<Unit> SortCommand { get; } = new ReactiveCommand<Unit>();
+        public ReactiveCommand<Unit> AttachFilterCommand { get; } = new ReactiveCommand<Unit>();
+        public ReactiveCommand<Unit> ResetFilterCommand { get; } = new ReactiveCommand<Unit>();
 
         public ViewModel()
         {
             observableList.Add(1);
             observableList.Add(2);
 
-            //ItemsView = observableList.CreateView(x => x).ToNotifyCollectionChanged(SynchronizationContextCollectionEventDispatcher.Current);
+            var view = observableList.CreateView(x => x);
+            ItemsView = view.ToNotifyCollectionChanged(SynchronizationContextCollectionEventDispatcher.Current);
 
-            ItemsView = observableList.CreateView(x => x).ToNotifyCollectionChanged();
 
-            //var test = ItemsView.ToArray();
-            //INotifyCollectionChangedSynchronizedView<int>
-            // ItemsView = observableList.CreateView(x => x).ToNotifyCollectionChanged();
+            // check for optimize list
+            // ItemsView = observableList.ToNotifyCollectionChanged(SynchronizationContextCollectionEventDispatcher.Current);
 
-            // BindingOperations.EnableCollectionSynchronization(ItemsView, new object());
 
             AddCommand.Subscribe(_ =>
             {
@@ -51,12 +56,49 @@ namespace AvaloniaApp
                 });
             });
 
-            // var iii = 10;
+            AddRangeCommand.Subscribe(_ =>
+            {
+                var xs = Enumerable.Range(1, 5).Select(_ => Random.Shared.Next()).ToArray();
+                observableList.AddRange(xs);
+            });
+
+            InsertAtRandomCommand.Subscribe(_ =>
+            {
+                var from = Random.Shared.Next(0, view.Count);
+                observableList.Insert(from, Random.Shared.Next());
+            });
+
+            RemoveAtRandomCommand.Subscribe(_ =>
+            {
+                var from = Random.Shared.Next(0, view.Count);
+                observableList.RemoveAt(from);
+            });
+
             ClearCommand.Subscribe(_ =>
             {
-                // observableList.Add(iii++);
                 observableList.Clear();
             });
+
+
+            ReverseCommand.Subscribe(_ =>
+            {
+                observableList.Reverse();
+            });
+
+            SortCommand.Subscribe(_ =>
+            {
+                observableList.Sort();
+            });
+
+            AttachFilterCommand.Subscribe(_ =>
+            {
+                view.AttachFilter(x => x % 2 == 0);
+            });
+
+            ResetFilterCommand.Subscribe(_ =>
+            {
+                view.ResetFilter();
+            });
         }
     }
 }
\ No newline at end of file
diff --git a/sandbox/WpfApp/MainWindow.xaml b/sandbox/WpfApp/MainWindow.xaml
index e5b8ead..e9d7411 100644
--- a/sandbox/WpfApp/MainWindow.xaml
+++ b/sandbox/WpfApp/MainWindow.xaml
@@ -20,8 +20,10 @@
     <StackPanel>
         <ListBox ItemsSource="{Binding ItemsView}" />
         <Button Content="Add" Command="{Binding AddCommand}" />
+        <Button Content="AddRange" Command="{Binding AddRangeCommand}" />
         <Button Content="Insert" Command="{Binding InsertAtRandomCommand}" />
         <Button Content="Remove" Command="{Binding RemoveAtRandomCommand}" />
+        <Button Content="RemoveRange" Command="{Binding RemoveRangeCommand}" />
         <Button Content="Clear" Command="{Binding ClearCommand}" />
         <Button Content="Reverse" Command="{Binding ReverseCommand}" />
         <Button Content="Sort" Command="{Binding SortCommand}" />
diff --git a/sandbox/WpfApp/MainWindow.xaml.cs b/sandbox/WpfApp/MainWindow.xaml.cs
index 148e950..8c476e2 100644
--- a/sandbox/WpfApp/MainWindow.xaml.cs
+++ b/sandbox/WpfApp/MainWindow.xaml.cs
@@ -2,6 +2,7 @@
 using R3;
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Linq;
@@ -76,8 +77,10 @@ namespace WpfApp
         private ObservableList<int> observableList { get; } = new ObservableList<int>();
         public INotifyCollectionChangedSynchronizedViewList<int> ItemsView { get; }
         public ReactiveCommand<Unit> AddCommand { get; } = new ReactiveCommand<Unit>();
+        public ReactiveCommand<Unit> AddRangeCommand { get; } = new ReactiveCommand<Unit>();
         public ReactiveCommand<Unit> InsertAtRandomCommand { get; } = new ReactiveCommand<Unit>();
         public ReactiveCommand<Unit> RemoveAtRandomCommand { get; } = new ReactiveCommand<Unit>();
+        public ReactiveCommand<Unit> RemoveRangeCommand { get; } = new ReactiveCommand<Unit>();
         public ReactiveCommand<Unit> ClearCommand { get; } = new ReactiveCommand<Unit>();
         public ReactiveCommand<Unit> ReverseCommand { get; } = new ReactiveCommand<Unit>();
         public ReactiveCommand<Unit> SortCommand { get; } = new ReactiveCommand<Unit>();
@@ -90,8 +93,8 @@ namespace WpfApp
             observableList.Add(2);
 
             var view = observableList.CreateView(x => x);
-            ItemsView = view.ToNotifyCollectionChanged(SynchronizationContextCollectionEventDispatcher.Current);
-
+            //ItemsView = view.ToNotifyCollectionChanged();
+            ItemsView = observableList.ToNotifyCollectionChanged();
 
             // check for optimize list
             // ItemsView = observableList.ToNotifyCollectionChanged(SynchronizationContextCollectionEventDispatcher.Current);
@@ -99,10 +102,16 @@ namespace WpfApp
 
             AddCommand.Subscribe(_ =>
             {
-                ThreadPool.QueueUserWorkItem(_ =>
+                // ThreadPool.QueueUserWorkItem(_ =>
                 {
                     observableList.Add(Random.Shared.Next());
-                });
+                }
+            });
+
+            AddRangeCommand.Subscribe(_ =>
+            {
+                var xs = Enumerable.Range(1, 5).Select(_ => Random.Shared.Next()).ToArray();
+                observableList.AddRange(xs);
             });
 
             InsertAtRandomCommand.Subscribe(_ =>
@@ -117,6 +126,11 @@ namespace WpfApp
                 observableList.RemoveAt(from);
             });
 
+            RemoveRangeCommand.Subscribe(_ =>
+            {
+                observableList.RemoveRange(2, 5);
+            });
+
             ClearCommand.Subscribe(_ =>
             {
                 observableList.Clear();
diff --git a/src/ObservableCollections/AlternateIndexList.cs b/src/ObservableCollections/AlternateIndexList.cs
index 19d3110..23c2e28 100644
--- a/src/ObservableCollections/AlternateIndexList.cs
+++ b/src/ObservableCollections/AlternateIndexList.cs
@@ -178,7 +178,7 @@ public class AlternateIndexList<T> : IEnumerable<T>
 
         object IEnumerator.Current => Current;
 
-        public void Dispose() => iter.Reset();
+        public void Dispose() => iter.Dispose();
 
         public bool MoveNext()
         {
@@ -191,7 +191,7 @@ public class AlternateIndexList<T> : IEnumerable<T>
             return false;
         }
 
-        public void Reset() => iter.Reset();
+        public void Reset() { }
 
         public IEnumerator<IndexedValue> GetEnumerator() => this;
 
diff --git a/src/ObservableCollections/ObservableList.OptimizeView.cs b/src/ObservableCollections/ObservableList.OptimizeView.cs
index 15c5ce0..c5052da 100644
--- a/src/ObservableCollections/ObservableList.OptimizeView.cs
+++ b/src/ObservableCollections/ObservableList.OptimizeView.cs
@@ -21,12 +21,18 @@ public sealed partial class ObservableList<T> : IList<T>, IReadOnlyObservableLis
     //    return new NonFilteredSynchronizedViewList<T, TView>(collection.CreateView(transform));
     //}
 
-    public INotifyCollectionChangedSynchronizedViewList<T> ToNotifyCollectionChanged()
+    /// <summary>
+    /// Create faster, compact INotifyCollectionChanged view, however it does not support ***Range.
+    /// </summary>
+    public INotifyCollectionChangedSynchronizedViewList<T> ToNotifyCollectionChangedSlim()
     {
         return new ObservableListSynchronizedViewList<T>(this, null);
     }
 
-    public INotifyCollectionChangedSynchronizedViewList<T> ToNotifyCollectionChanged(ICollectionEventDispatcher? collectionEventDispatcher)
+    /// <summary>
+    /// Create faster, compact INotifyCollectionChanged view, however it does not support ***Range.
+    /// </summary>
+    public INotifyCollectionChangedSynchronizedViewList<T> ToNotifyCollectionChangedSlim(ICollectionEventDispatcher? collectionEventDispatcher)
     {
         return new ObservableListSynchronizedViewList<T>(this, collectionEventDispatcher);
     }
diff --git a/src/ObservableCollections/SynchronizedViewList.cs b/src/ObservableCollections/SynchronizedViewList.cs
index eb16d64..fedec6c 100644
--- a/src/ObservableCollections/SynchronizedViewList.cs
+++ b/src/ObservableCollections/SynchronizedViewList.cs
@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -16,6 +17,8 @@ internal class FiltableSynchronizedViewList<T, TView> : ISynchronizedViewList<TV
     protected readonly AlternateIndexList<TView> listView;
     protected readonly object gate = new object();
 
+    protected virtual bool IsSupportRangeFeature => true;
+
     public FiltableSynchronizedViewList(ISynchronizedView<T, TView> parent)
     {
         this.parent = parent;
@@ -67,9 +70,22 @@ internal class FiltableSynchronizedViewList<T, TView> : ISynchronizedViewList<TV
                     }
                     else
                     {
-                        using var array = new CloneCollection<TView>(e.NewViews);
-                        var index = listView.InsertRange(e.NewStartingIndex, array.AsEnumerable());
-                        OnCollectionChanged(e.WithNewStartingIndex(index));
+                        if (IsSupportRangeFeature)
+                        {
+                            using var array = new CloneCollection<TView>(e.NewViews);
+                            var index = listView.InsertRange(e.NewStartingIndex, array.AsEnumerable());
+                            OnCollectionChanged(e.WithNewStartingIndex(index));
+                        }
+                        else
+                        {
+                            var span = e.NewViews;
+                            for (int i = 0; i < span.Length; i++)
+                            {
+                                var index = listView.Insert(e.NewStartingIndex + i, span[i]);
+                                var ev = new SynchronizedViewChangedEventArgs<T, TView>(e.Action, true, newItem: (e.NewValues[i], span[i]), newStartingIndex: index);
+                                OnCollectionChanged(ev);
+                            }
+                        }
                         return;
                     }
                 case NotifyCollectionChangedAction.Remove: // Remove
@@ -99,7 +115,21 @@ internal class FiltableSynchronizedViewList<T, TView> : ISynchronizedViewList<TV
                             }
                             else
                             {
-                                index = listView.RemoveRange(e.OldStartingIndex, e.OldViews.Length);
+                                if (IsSupportRangeFeature)
+                                {
+                                    index = listView.RemoveRange(e.OldStartingIndex, e.OldViews.Length);
+                                }
+                                else
+                                {
+                                    var span = e.OldViews;
+                                    for (int i = 0; i < span.Length; i++)
+                                    {
+                                        index = listView.RemoveAt(e.OldStartingIndex); // when removed, next remove index is same.
+                                        var ev = new SynchronizedViewChangedEventArgs<T, TView>(e.Action, true, oldItem: (e.OldValues[i], span[i]), oldStartingIndex: index);
+                                        OnCollectionChanged(ev);
+                                    }
+                                    return;
+                                }
                             }
                         }
                         OnCollectionChanged(e.WithOldStartingIndex(index));
@@ -192,7 +222,7 @@ internal class FiltableSynchronizedViewList<T, TView> : ISynchronizedViewList<TV
 
     IEnumerator IEnumerable.GetEnumerator()
     {
-        return listView.GetEnumerator();
+        return GetEnumerator();
     }
 
     public void Dispose()
@@ -206,6 +236,8 @@ internal class NonFilteredSynchronizedViewList<T, TView> : ISynchronizedViewList
     readonly ISynchronizedView<T, TView> parent;
     protected readonly List<TView> listView; // no filter can be faster
     protected readonly object gate = new object();
+    
+    protected virtual bool IsSupportRangeFeature => true;
 
     public NonFilteredSynchronizedViewList(ISynchronizedView<T, TView> parent)
     {
@@ -231,12 +263,27 @@ internal class NonFilteredSynchronizedViewList<T, TView> : ISynchronizedViewList
                     }
                     else
                     {
+                        if (IsSupportRangeFeature)
+                        {
 #if NET8_0_OR_GREATER
-                        listView.InsertRange(e.NewStartingIndex, e.NewViews);
+                            listView.InsertRange(e.NewStartingIndex, e.NewViews);
 #else
-                        using var array = new CloneCollection<TView>(e.NewViews);
-                        listView.InsertRange(e.NewStartingIndex, array.AsEnumerable());
+                            using var array = new CloneCollection<TView>(e.NewViews);
+                            listView.InsertRange(e.NewStartingIndex, array.AsEnumerable());
 #endif
+                        }
+                        else
+                        {
+                            var span = e.NewViews;
+                            for (int i = 0; i < span.Length; i++)
+                            {
+                                var index = e.NewStartingIndex + i;
+                                listView.Insert(index, span[i]);
+                                var ev = new SynchronizedViewChangedEventArgs<T, TView>(e.Action, true, newItem: (e.NewValues[i], span[i]), newStartingIndex: index);
+                                OnCollectionChanged(ev);
+                            }
+                            return;
+                        }
                     }
                     break;
                 case NotifyCollectionChangedAction.Remove: // Remove
@@ -269,7 +316,21 @@ internal class NonFilteredSynchronizedViewList<T, TView> : ISynchronizedViewList
                             }
                             else
                             {
-                                listView.RemoveRange(e.OldStartingIndex, e.OldViews.Length);
+                                if (IsSupportRangeFeature)
+                                {
+                                    listView.RemoveRange(e.OldStartingIndex, e.OldViews.Length);
+                                }
+                                else
+                                {
+                                    var span = e.OldViews;
+                                    for (int i = 0; i < span.Length; i++)
+                                    {
+                                        listView.RemoveAt(e.OldStartingIndex); // when removed, next remove index is same.
+                                        var ev = new SynchronizedViewChangedEventArgs<T, TView>(e.Action, true, oldItem: (e.OldValues[i], span[i]), oldStartingIndex: e.OldStartingIndex);
+                                        OnCollectionChanged(ev);
+                                    }
+                                    return;
+                                }
                             }
                         }
                         break;
@@ -320,9 +381,6 @@ internal class NonFilteredSynchronizedViewList<T, TView> : ISynchronizedViewList
                     }
                     else
                     {
-
-
-
 #if NET6_0_OR_GREATER
 #pragma warning disable CS0436
                         if (parent is ObservableList<T>.View<TView> observableListView && typeof(T) == typeof(TView))
@@ -408,7 +466,7 @@ internal class NonFilteredSynchronizedViewList<T, TView> : ISynchronizedViewList
 
     IEnumerator IEnumerable.GetEnumerator()
     {
-        return listView.GetEnumerator();
+        return GetEnumerator();
     }
 
     public void Dispose()
@@ -428,6 +486,8 @@ internal class NotifyCollectionChangedSynchronizedViewList<T, TView> :
 
     readonly ICollectionEventDispatcher eventDispatcher;
 
+    protected override bool IsSupportRangeFeature => false; // WPF, Avalonia etc does not support range notification
+
     public event NotifyCollectionChangedEventHandler? CollectionChanged;
     public event PropertyChangedEventHandler? PropertyChanged;
 
@@ -676,6 +736,8 @@ internal class NonFilteredNotifyCollectionChangedSynchronizedViewList<T, TView>
     public event NotifyCollectionChangedEventHandler? CollectionChanged;
     public event PropertyChangedEventHandler? PropertyChanged;
 
+    protected override bool IsSupportRangeFeature => false; // WPF, Avalonia etc does not support range notification
+
     public NonFilteredNotifyCollectionChangedSynchronizedViewList(ISynchronizedView<T, TView> parent, ICollectionEventDispatcher? eventDispatcher)
         : base(parent)
     {

From efec73f052f5e71226adbcbf603d0dec6d39fdfd Mon Sep 17 00:00:00 2001
From: Yoshifumi Kawai <46207+neuecc@users.noreply.github.com>
Date: Fri, 6 Sep 2024 09:37:35 +0900
Subject: [PATCH 4/8] Update README.md

---
 README.md | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 21cf6b9..5c46667 100644
--- a/README.md
+++ b/README.md
@@ -380,21 +380,25 @@ public class SampleScript : MonoBehaviour
         {
             var item = GameObject.Instantiate(prefab);
             item.GetComponentInChildren<Text>().text = x.ToString();
+
+            // add to root
+            item.transform.SetParent(root.transform);
+
             return item.gameObject;
         });
         view.ViewChanged += View_ViewChanged;
     }
 
     void View_ViewChanged(in SynchronizedViewChangedEventArgs<int, string> eventArgs)
-    { 
-        if (eventArgs.Action == NotifyCollectionChangedAction.Add)
-        {
-            eventArgs.NewItem.View.transform.SetParent(root.transform);
-        }
-        else if (NotifyCollectionChangedAction.Remove)
+    {
+        // hook remove event
+        if (NotifyCollectionChangedAction.Remove)
         {
             GameObject.Destroy(eventArgs.OldItem.View);
         }
+
+        // hook for Filter attached, clear, etc...
+        // if (NotifyCollectionChangedAction.Reset) { }
     }
 
     void OnDestroy()

From b0bc7c21515e000154bd64da3494d0c0bd04544e Mon Sep 17 00:00:00 2001
From: neuecc <ils@neue.cc>
Date: Tue, 10 Sep 2024 01:07:15 +0900
Subject: [PATCH 5/8] fix ArgumentOutOfRangeException when using
 ToNotifyCollectionChanged with ObservableDictionary #70

---
 src/ObservableCollections/SynchronizedViewList.cs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/ObservableCollections/SynchronizedViewList.cs b/src/ObservableCollections/SynchronizedViewList.cs
index fedec6c..f1dc3a5 100644
--- a/src/ObservableCollections/SynchronizedViewList.cs
+++ b/src/ObservableCollections/SynchronizedViewList.cs
@@ -259,7 +259,14 @@ internal class NonFilteredSynchronizedViewList<T, TView> : ISynchronizedViewList
                 case NotifyCollectionChangedAction.Add: // Add or Insert
                     if (e.IsSingleItem)
                     {
-                        listView.Insert(e.NewStartingIndex, e.NewItem.View);
+                        if (e.NewStartingIndex == -1)
+                        {
+                            listView.Add(e.NewItem.View);
+                        }
+                        else
+                        {
+                            listView.Insert(e.NewStartingIndex, e.NewItem.View);
+                        }
                     }
                     else
                     {

From 9c4f7b2d9edc06cb52da8573b91248644fe6966b Mon Sep 17 00:00:00 2001
From: neuecc <ils@neue.cc>
Date: Tue, 10 Sep 2024 01:22:38 +0900
Subject: [PATCH 6/8] Dictionary FilteredView add operation adds last

---
 sandbox/ConsoleApp/Program.cs                 | 33 ++++---------------
 .../SynchronizedViewList.cs                   | 17 ++++++++--
 2 files changed, 21 insertions(+), 29 deletions(-)

diff --git a/sandbox/ConsoleApp/Program.cs b/sandbox/ConsoleApp/Program.cs
index f547f51..b293fdf 100644
--- a/sandbox/ConsoleApp/Program.cs
+++ b/sandbox/ConsoleApp/Program.cs
@@ -7,36 +7,17 @@ using System.Collections;
 using System.Collections.Generic;
 
 
+var dict = new ObservableDictionary<int, string>();
+var view = dict.CreateView(x => x).ToNotifyCollectionChanged();
+dict.Add(key: 1, value: "foo");
+dict.Add(key: 2, value: "bar");
 
-
-// Queue <-> List Synchronization
-var queue = new ObservableQueue<int>();
-
-queue.Enqueue(1);
-queue.Enqueue(10);
-queue.Enqueue(100);
-queue.Enqueue(1000);
-queue.Enqueue(10000);
-
-using var view = queue.CreateView(x => x.ToString() + "$");
-
-using var viewList = view.ToViewList();
-
-Console.WriteLine(viewList[2]); // 100$
-
-
-view.ViewChanged += View_ViewChanged;
-
-void View_ViewChanged(in SynchronizedViewChangedEventArgs<int, string> eventArgs)
+foreach (var item in view)
 {
-    if (eventArgs.Action == NotifyCollectionChangedAction.Add)
-    {
-     // eventArgs.OldItem.View.   
-    }
-
-    throw new NotImplementedException();
+    Console.WriteLine(item);
 }
 
+
 class ViewModel
 {
     public int Id { get; set; }
diff --git a/src/ObservableCollections/SynchronizedViewList.cs b/src/ObservableCollections/SynchronizedViewList.cs
index f1dc3a5..418768f 100644
--- a/src/ObservableCollections/SynchronizedViewList.cs
+++ b/src/ObservableCollections/SynchronizedViewList.cs
@@ -64,9 +64,20 @@ internal class FiltableSynchronizedViewList<T, TView> : ISynchronizedViewList<TV
                 case NotifyCollectionChangedAction.Add: // Add or Insert
                     if (e.IsSingleItem)
                     {
-                        var index = listView.Insert(e.NewStartingIndex, e.NewItem.View);
-                        OnCollectionChanged(e.WithNewStartingIndex(index));
-                        return;
+                        if (e.OldStartingIndex == -1)
+                        {
+                            // add operation
+                            var index = listView.Count;
+                            listView.Insert(index, e.NewItem.View);
+                            OnCollectionChanged(e.WithNewStartingIndex(index));
+                            return;
+                        }
+                        else
+                        {
+                            var index = listView.Insert(e.NewStartingIndex, e.NewItem.View);
+                            OnCollectionChanged(e.WithNewStartingIndex(index));
+                            return;
+                        }
                     }
                     else
                     {

From 9fe7a38b96c3632cd7e82ec38f6d6cb693a07390 Mon Sep 17 00:00:00 2001
From: neuecc <ils@neue.cc>
Date: Tue, 10 Sep 2024 01:27:40 +0900
Subject: [PATCH 7/8] new2

---
 src/ObservableCollections/SynchronizedViewList.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ObservableCollections/SynchronizedViewList.cs b/src/ObservableCollections/SynchronizedViewList.cs
index 418768f..7fe5634 100644
--- a/src/ObservableCollections/SynchronizedViewList.cs
+++ b/src/ObservableCollections/SynchronizedViewList.cs
@@ -64,7 +64,7 @@ internal class FiltableSynchronizedViewList<T, TView> : ISynchronizedViewList<TV
                 case NotifyCollectionChangedAction.Add: // Add or Insert
                     if (e.IsSingleItem)
                     {
-                        if (e.OldStartingIndex == -1)
+                        if (e.NewStartingIndex == -1)
                         {
                             // add operation
                             var index = listView.Count;

From 3d26e1d9de65b6807884e9300f02e0ce9a9f7d2c Mon Sep 17 00:00:00 2001
From: neuecc <ils@neue.cc>
Date: Fri, 13 Sep 2024 00:36:57 +0900
Subject: [PATCH 8/8] Fix ObservableDictionary.ToNotifyCollectionChanged #71

---
 src/ObservableCollections/SynchronizedViewList.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/ObservableCollections/SynchronizedViewList.cs b/src/ObservableCollections/SynchronizedViewList.cs
index 7fe5634..d0222d3 100644
--- a/src/ObservableCollections/SynchronizedViewList.cs
+++ b/src/ObservableCollections/SynchronizedViewList.cs
@@ -1,4 +1,4 @@
-using ObservableCollections.Internal;
+using ObservableCollections.Internal;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -272,7 +272,10 @@ internal class NonFilteredSynchronizedViewList<T, TView> : ISynchronizedViewList
                     {
                         if (e.NewStartingIndex == -1)
                         {
+                            var index = listView.Count;
                             listView.Add(e.NewItem.View);
+                            OnCollectionChanged(e.WithNewStartingIndex(index));
+                            return;
                         }
                         else
                         {