Add R3 ObserveChanged

Cysharp · Oct 16, 2024 · 8913192 · 8913192
1 parent 8b75c41
commit 8913192
Show file tree

Hide file tree

Showing 5 changed files with 140 additions and 122 deletions.
diff --git a/README.md b/README.md
@@ -50,6 +50,7 @@ ObservableCollections has not just a simple list, there are many more data struc
 If you want to handle each change event with Rx, you can monitor it with the following method by combining it with [R3](https://github.com/Cysharp/R3):
 
 ```csharp
+Observable<CollectionChangedEvent<T>> IObservableCollection<T>.ObserveChanged()
 Observable<CollectionAddEvent<T>> IObservableCollection<T>.ObserveAdd()
 Observable<CollectionRemoveEvent<T>> IObservableCollection<T>.ObserveRemove()
 Observable<CollectionReplaceEvent<T>> IObservableCollection<T>.ObserveReplace() 
@@ -237,7 +238,7 @@ class DescendantComaprer : IComparer<int>
 
 Reactive Extensions with R3
 ---
-Once the R3 extension package is installed, you can subscribe to `ObserveAdd`, `ObserveRemove`, `ObserveReplace`, `ObserveMove`, `ObserveReset`, `ObserveClear`, `ObserveReverse`, `ObserveSort` events as Rx, allowing you to compose events individually.
+Once the R3 extension package is installed, you can subscribe to `ObserveChanged`, `ObserveAdd`, `ObserveRemove`, `ObserveReplace`, `ObserveMove`, `ObserveReset`, `ObserveClear`, `ObserveReverse`, `ObserveSort` events as Rx, allowing you to compose events individually.
 
 > dotnet add package [ObservableCollections.R3](https://www.nuget.org/packages/ObservableCollections.R3)
 
@@ -317,7 +318,7 @@ Because of data binding in WPF, it is important that the collection is Observabl
 // WPF simple sample.
 
 ObservableList<int> list;
-public INotifyCollectionChangedSynchronizedViewList<int> ItemsView { get; set; }
+public NotifyCollectionChangedSynchronizedViewList<int> ItemsView { get; set; }
 
 public MainWindow()
 {
@@ -366,8 +367,8 @@ public delegate T WritableViewChangedEventHandler<T, TView>(TView newView, T ori
 
 public interface IWritableSynchronizedView<T, TView> : ISynchronizedView<T, TView>
 {
-    INotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged(WritableViewChangedEventHandler<T, TView> converter);
-    INotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged(WritableViewChangedEventHandler<T, TView> converter, ICollectionEventDispatcher? collectionEventDispatcher);
+    NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged(WritableViewChangedEventHandler<T, TView> converter);
+    NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged(WritableViewChangedEventHandler<T, TView> converter, ICollectionEventDispatcher? collectionEventDispatcher);
 }
 ```
 
@@ -564,8 +565,8 @@ public interface ISynchronizedView<T, TView> : IReadOnlyCollection<TView>, IDisp
     void AttachFilter(ISynchronizedViewFilter<T> filter);
     void ResetFilter();
     ISynchronizedViewList<TView> ToViewList();
-    INotifyCollectionChangedSynchronizedViewList<TView> ToNotifyCollectionChanged();
-    INotifyCollectionChangedSynchronizedViewList<TView> ToNotifyCollectionChanged(ICollectionEventDispatcher? collectionEventDispatcher);
+    NotifyCollectionChangedSynchronizedViewList<TView> ToNotifyCollectionChanged();
+    NotifyCollectionChangedSynchronizedViewList<TView> ToNotifyCollectionChanged(ICollectionEventDispatcher? collectionEventDispatcher);
 }
 ```
 
@@ -630,10 +631,10 @@ public sealed partial class ObservableList<T>
 {
     public IWritableSynchronizedView<T, TView> CreateWritableView<TView>(Func<T, TView> transform);
 
-    public INotifyCollectionChangedSynchronizedViewList<T> ToWritableNotifyCollectionChanged();
-    public INotifyCollectionChangedSynchronizedViewList<T> ToWritableNotifyCollectionChanged(ICollectionEventDispatcher? collectionEventDispatcher);
-    public INotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged<TView>(Func<T, TView> transform, WritableViewChangedEventHandler<T, TView>? converter);
-    public INotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged<TView>(Func<T, TView> transform, ICollectionEventDispatcher? collectionEventDispatcher, WritableViewChangedEventHandler<T, TView>? converter);
+    public NotifyCollectionChangedSynchronizedViewList<T> ToWritableNotifyCollectionChanged();
+    public NotifyCollectionChangedSynchronizedViewList<T> ToWritableNotifyCollectionChanged(ICollectionEventDispatcher? collectionEventDispatcher);
+    public NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged<TView>(Func<T, TView> transform, WritableViewChangedEventHandler<T, TView>? converter);
+    public NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged<TView>(Func<T, TView> transform, ICollectionEventDispatcher? collectionEventDispatcher, WritableViewChangedEventHandler<T, TView>? converter);
 }
 
 public delegate T WritableViewChangedEventHandler<T, TView>(TView newView, T originalValue, ref bool setValue);
@@ -671,9 +672,18 @@ public interface ISynchronizedViewList<out TView> : IReadOnlyList<TView>, IDispo
 {
 }
 
+// Obsolete for public use
 public interface INotifyCollectionChangedSynchronizedViewList<out TView> : ISynchronizedViewList<TView>, INotifyCollectionChanged, INotifyPropertyChanged
 {
 }
+
+public abstract class NotifyCollectionChangedSynchronizedViewList<TView> :
+    INotifyCollectionChangedSynchronizedViewList<TView>,
+    IWritableSynchronizedViewList<TView>,
+    IList<TView>,
+    IList
+    {
+    }
 ```
 
 License

diff --git a/sandbox/ConsoleApp/Program.cs b/sandbox/ConsoleApp/Program.cs
@@ -39,6 +39,11 @@
     }
 });
 
+
+list.Clear();
+
+list.Add(new() { Age = 99, Name = "tako" });
+
 // bindable[0] = "takoyaki";
 
 foreach (var item in view)

diff --git a/src/ObservableCollections.R3/ObservableCollectionR3Extensions.cs b/src/ObservableCollections.R3/ObservableCollectionR3Extensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
+using System.Runtime.InteropServices;
 using System.Threading;
 using R3;
 
@@ -27,15 +28,40 @@ public CollectionResetEvent(SortOperation<T> sortOperation)
     }
 }
 
+[StructLayout(LayoutKind.Auto)]
+public readonly record struct CollectionChangedEvent<T>
+{
+    public readonly NotifyCollectionChangedAction Action;
+    public readonly T NewItem;
+    public readonly T OldItem;
+    public readonly int NewStartingIndex;
+    public readonly int OldStartingIndex;
+    public readonly SortOperation<T> SortOperation;
+
+    public CollectionChangedEvent(NotifyCollectionChangedAction action, T newItem, T oldItem, int newStartingIndex, int oldStartingIndex, SortOperation<T> sortOperation)
+    {
+        Action = action;
+        NewItem = newItem;
+        OldItem = oldItem;
+        NewStartingIndex = newStartingIndex;
+        OldStartingIndex = oldStartingIndex;
+        SortOperation = sortOperation;
+    }
+}
+
 public readonly record struct DictionaryAddEvent<TKey, TValue>(TKey Key, TValue Value);
 
 public readonly record struct DictionaryRemoveEvent<TKey, TValue>(TKey Key, TValue Value);
 
 public readonly record struct DictionaryReplaceEvent<TKey, TValue>(TKey Key, TValue OldValue, TValue NewValue);
 
-
 public static class ObservableCollectionR3Extensions
 {
+    public static Observable<CollectionChangedEvent<T>> ObserveChanged<T>(this IObservableCollection<T> source, CancellationToken cancellationToken = default)
+    {
+        return new ObservableCollectionChanged<T>(source, cancellationToken);
+    }
+
     public static Observable<CollectionAddEvent<T>> ObserveAdd<T>(this IObservableCollection<T> source, CancellationToken cancellationToken = default)
     {
         return new ObservableCollectionAdd<T>(source, cancellationToken);
@@ -102,6 +128,72 @@ public static Observable<DictionaryReplaceEvent<TKey, TValue>> ObserveDictionary
     }
 }
 
+sealed class ObservableCollectionChanged<T>(IObservableCollection<T> collection, CancellationToken cancellationToken)
+    : Observable<CollectionChangedEvent<T>>
+{
+    protected override IDisposable SubscribeCore(Observer<CollectionChangedEvent<T>> observer)
+    {
+        return new _ObservableCollectionAdd(collection, observer, cancellationToken);
+    }
+
+    sealed class _ObservableCollectionAdd(
+        IObservableCollection<T> collection,
+        Observer<CollectionChangedEvent<T>> observer,
+        CancellationToken cancellationToken)
+        : ObservableCollectionObserverBase<T, CollectionChangedEvent<T>>(collection, observer, cancellationToken)
+    {
+        protected override void Handler(in NotifyCollectionChangedEventArgs<T> eventArgs)
+        {
+            if (eventArgs.IsSingleItem)
+            {
+                var newArgs = new CollectionChangedEvent<T>(
+                    eventArgs.Action,
+                    eventArgs.NewItem,
+                    eventArgs.OldItem,
+                    eventArgs.NewStartingIndex,
+                    eventArgs.OldStartingIndex,
+                    eventArgs.SortOperation);
+
+                observer.OnNext(newArgs);
+            }
+            else
+            {
+                if (eventArgs.Action == NotifyCollectionChangedAction.Add)
+                {
+                    var i = eventArgs.NewStartingIndex;
+                    foreach (var item in eventArgs.NewItems)
+                    {
+                        var newArgs = new CollectionChangedEvent<T>(
+                            eventArgs.Action,
+                            eventArgs.NewItem,
+                            eventArgs.OldItem,
+                            i++,
+                            eventArgs.OldStartingIndex,
+                            eventArgs.SortOperation);
+
+                        observer.OnNext(newArgs);
+                    }
+                }
+                else if (eventArgs.Action == NotifyCollectionChangedAction.Remove)
+                {
+                    foreach (var item in eventArgs.OldItems)
+                    {
+                        var newArgs = new CollectionChangedEvent<T>(
+                            eventArgs.Action,
+                            eventArgs.NewItem,
+                            eventArgs.OldItem,
+                            eventArgs.NewStartingIndex,
+                            eventArgs.OldStartingIndex, // removed, uses same index
+                            eventArgs.SortOperation);
+
+                        observer.OnNext(newArgs);
+                    }
+                }
+            }
+        }
+    }
+}
+
 sealed class ObservableCollectionAdd<T>(IObservableCollection<T> collection, CancellationToken cancellationToken)
     : Observable<CollectionAddEvent<T>>
 {
@@ -161,10 +253,9 @@ protected override void Handler(in NotifyCollectionChangedEventArgs<T> eventArgs
                 }
                 else
                 {
-                    var i = eventArgs.OldStartingIndex;
                     foreach (var item in eventArgs.OldItems)
                     {
-                        observer.OnNext(new CollectionRemoveEvent<T>(i++, item));
+                        observer.OnNext(new CollectionRemoveEvent<T>(eventArgs.OldStartingIndex, item)); // remove uses same index
                     }
                 }
             }