Add ChangeKind.Clear but may needs more

sandbox/ConsoleApp/Program.cs

@@ -81,6 +81,9 @@ class HogeFilter : ISynchronizedViewFilter<int, ViewModel>
             case ChangedKind.Move:
                 view.Value += $" Move {eventArgs.OldStartingIndex} {eventArgs.NewStartingIndex}";
                 break;
+            case ChangedKind.Clear:
+                view.Value += $" Clear";
+                break;
             default:
                 throw new ArgumentOutOfRangeException(nameof(changedKind), changedKind, null);
         }

sandbox/WpfApp/MainWindow.xaml

@@ -6,15 +6,19 @@
         xmlns:local="clr-namespace:WpfApp"
         mc:Ignorable="d"
         Title="MainWindow" Height="450" Width="800">
-    <Grid>
+    <!--<Grid>
         <Grid.ColumnDefinitions>
             <ColumnDefinition />
             <ColumnDefinition />
         </Grid.ColumnDefinitions>
 
         <ListView ItemsSource="{Binding ItemsView}"></ListView>
-        
         <Button Grid.Column="1" Click="Button_Click">Insert</Button>
 
-    </Grid>
+    </Grid>-->
+
+    <StackPanel>
+        <ListBox ItemsSource="{Binding ItemsView}" />
+        <Button Content="Clear" Command="{Binding ClearCommand}" />
+    </StackPanel>
 </Window>

sandbox/WpfApp/MainWindow.xaml.cs

@@ -1,6 +1,8 @@
 using ObservableCollections;
+using R3;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading;
@@ -22,38 +24,72 @@ namespace WpfApp
     /// </summary>
     public partial class MainWindow : Window
     {
-        ObservableList<int> list;
+        //ObservableList<int> list;
-        public INotifyCollectionChangedSynchronizedView<int> ItemsView { get; set; }
+        //public INotifyCollectionChangedSynchronizedView<int> ItemsView { get; set; }
+
+
+
 
         public MainWindow()
         {
             InitializeComponent();
-            this.DataContext = this;
+
+
+            R3.WpfProviderInitializer.SetDefaultObservableSystem(x =>
+            {
+                Trace.WriteLine(x);
+            });
+
+            this.DataContext = new ViewModel();
 
 
 
 
-            list = new ObservableList<int>();
+            //list = new ObservableList<int>();
-            list.AddRange(new[] { 1, 10, 188 });
+            //list.AddRange(new[] { 1, 10, 188 });
-            ItemsView = list.CreateSortedView(x => x, x => x, comparer: Comparer<int>.Default).ToNotifyCollectionChanged();
+            //ItemsView = list.CreateSortedView(x => x, x => x, comparer: Comparer<int>.Default).ToNotifyCollectionChanged();
 
 
+            //BindingOperations.EnableCollectionSynchronization(ItemsView, new object());
+        }
+
+        //int adder = 99;
+
+        //private void Button_Click(object sender, RoutedEventArgs e)
+        //{
+        //    ThreadPool.QueueUserWorkItem(_ =>
+        //    {
+        //        list.Add(adder++);
+        //    });
+        //}
+
+        //protected override void OnClosed(EventArgs e)
+        //{
+        //    ItemsView.Dispose();
+        //}
+    }
+
+    public class ViewModel
+    {
+        private ObservableList<int> observableList { get; } = new ObservableList<int>();
+        public INotifyCollectionChangedSynchronizedView<int> ItemsView { get; }
+        public ReactiveCommand<Unit> ClearCommand { get; } = new ReactiveCommand<Unit>();
+
+        public ViewModel()
+        {
+            observableList.Add(1);
+            observableList.Add(2);
+
+            ItemsView = observableList.CreateView(x => x).ToNotifyCollectionChanged();
+
             BindingOperations.EnableCollectionSynchronization(ItemsView, new object());
-        }
 
-        int adder = 99;
+            // var iii = 10;
-
+            ClearCommand.Subscribe(_ =>
-        private void Button_Click(object sender, RoutedEventArgs e)
-        {
-            ThreadPool.QueueUserWorkItem(_ =>
             {
-                list.Add(adder++);
+                // observableList.Add(iii++);
+                observableList.Clear();
             });
         }
-
-        protected override void OnClosed(EventArgs e)
-        {
-            ItemsView.Dispose();
-        }
     }
 }

sandbox/WpfApp/WpfApp.csproj

@@ -10,6 +10,12 @@
 	</PropertyGroup>
 
 	<ItemGroup>
+	  <PackageReference Include="R3" Version="1.0.4" />
+	  <PackageReference Include="R3Extensions.WPF" Version="1.0.4" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\src\ObservableCollections.R3\ObservableCollections.R3.csproj" />
 		<ProjectReference Include="..\..\src\ObservableCollections\ObservableCollections.csproj" />
 	</ItemGroup>
 

src/ObservableCollections/ISynchronizedViewFilter.cs

@@ -12,7 +12,7 @@ namespace ObservableCollections
 
     public enum ChangedKind
     {
-        Add, Remove, Move
+        Add, Remove, Move, Clear
     }
 
     public class SynchronizedViewFilter<T, TView> : ISynchronizedViewFilter<T, TView>
@@ -106,6 +106,11 @@ namespace ObservableCollections
             filter.OnCollectionChanged(ChangedKind.Move, value, view, eventArgs);
         }
 
+        internal static void InvokeOnClear<T, TView>(this ISynchronizedViewFilter<T, TView> filter, in NotifyCollectionChangedEventArgs<T> eventArgs)
+        {
+            filter.OnCollectionChanged(ChangedKind.Clear, default!, default!, eventArgs);
+        }
+
         internal static void InvokeOnAttach<T, TView>(this ISynchronizedViewFilter<T, TView> filter, T value, TView view)
         {
             if (filter.IsMatch(value, view))

src/ObservableCollections/Internal/NotifyCollectionChangedSynchronizedView.cs

@@ -75,6 +75,10 @@ namespace ObservableCollections.Internal
                 case ChangedKind.Move:
                     CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, view, eventArgs.NewStartingIndex, eventArgs.OldStartingIndex));
                     break;
+                case ChangedKind.Clear:
+                    PropertyChanged?.Invoke(this, CountPropertyChangedEventArgs);
+                    CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+                    break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(changedKind), changedKind, null);
             }

src/ObservableCollections/ObservableList.Views.cs

@@ -210,34 +210,28 @@ namespace ObservableCollections
                             break;
                         case NotifyCollectionChangedAction.Replace:
                             // ObservableList does not support replace range
-                        {
+                            {
-                            var v = (e.NewItem, selector(e.NewItem));
+                                var v = (e.NewItem, selector(e.NewItem));
 
-                            var oldItem = list[e.NewStartingIndex];
+                                var oldItem = list[e.NewStartingIndex];
-                            list[e.NewStartingIndex] = v;
+                                list[e.NewStartingIndex] = v;
 
-                            filter.InvokeOnRemove(oldItem, e);
+                                filter.InvokeOnRemove(oldItem, e);
-                            filter.InvokeOnAdd(v, e);
+                                filter.InvokeOnAdd(v, e);
-                            break;
+                                break;
-                        }
+                            }
                         case NotifyCollectionChangedAction.Move:
-                        {
+                            {
-                            var removeItem = list[e.OldStartingIndex];
+                                var removeItem = list[e.OldStartingIndex];
-                            list.RemoveAt(e.OldStartingIndex);
+                                list.RemoveAt(e.OldStartingIndex);
-                            list.Insert(e.NewStartingIndex, removeItem);
+                                list.Insert(e.NewStartingIndex, removeItem);
 
-                            filter.InvokeOnMove(removeItem, e);
+                                filter.InvokeOnMove(removeItem, e);
-                        }
+                            }
                             break;
                         case NotifyCollectionChangedAction.Reset:
-                            if (!filter.IsNullFilter())
-                            {
-                                foreach (var item in list)
-                                {
-                                    filter.InvokeOnRemove(item, e);
-                                }
-                            }
                             list.Clear();
+                            filter.InvokeOnClear(e);
                             break;
                         default:
                             break;