Added ICollectionSynchronization

Toolkit.Foundation/ComponentBuilder.cs

@@ -45,6 +45,8 @@ public class ComponentBuilder :
 
                 services.AddHandler<NavigateHandler>();
                 services.AddHandler<NavigateBackHandler>();
+
+                services.AddTransient<ICollectionSynchronizer, CollectionSynchronizer>();
             });
     }
 

Toolkit.Foundation/DecoratorService.cs

@@ -1,7 +1,7 @@
 namespace Toolkit.Foundation;
 
-public class ValueStore<T> :
+public class DecoratorService<T> :
-    IValueStore<T>
+    IDecoratorService<T>
 {
     public T? Value { get; private set; }
 

Toolkit.Foundation/DefaultHostBuilder.cs

@@ -65,6 +65,8 @@ public class DefaultHostBuilder :
                 services.AddHandler<NavigateHandler>();
                 services.AddHandler<NavigateBackHandler>();
 
+                services.AddTransient<ICollectionSynchronizer, CollectionSynchronizer>();
+
                 services.AddInitializer<ComponentInitializer>();
                 services.AddHostedService<AppService>();
             });

Toolkit.Foundation/IDecoratorService.cs

@@ -1,6 +1,6 @@
 namespace Toolkit.Foundation;
 
-public interface IValueStore<T>
+public interface IDecoratorService<T>
 {
     T? Value { get; }
 

Toolkit.Foundation/IMediator.cs

@@ -11,12 +11,17 @@ public interface IMediator
         CancellationToken cancellationToken = default)
         where TMessage : notnull;
 
-    IAsyncEnumerable<object?> HandleMany(object message,
+    IAsyncEnumerable<object?> HandleManyAsync(object message,
         object? key = null,
         CancellationToken cancellationToken = default);
 
-    IAsyncEnumerable<TResponse?> HandleMany<TMessage, TResponse>(TMessage message,
+    IAsyncEnumerable<TResponse?> HandleManyAsync<TMessage, TResponse>(TMessage message,
         object? key = null,
         CancellationToken cancellationToken = default)
         where TMessage : notnull;
+
+    Task<IList<TResponse?>> HandleMany<TMessage, TResponse>(TMessage message,
+            object? key = null,
+            CancellationToken cancellationToken = default)
+            where TMessage : notnull;
 }

Toolkit.Foundation/IProvider.cs

@@ -8,9 +8,4 @@ public interface IProvider<TParameter, TService>
 public interface IProvider<TService>
 {
     TService? Get();
-}
-
-public interface ISelectable
-{
-    bool Selected { get; set; }
 }

Toolkit.Foundation/ISelectable.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface ISelectable
+{
+    bool Selected { get; set; }
+}

Toolkit.Foundation/Mediator.cs

@@ -53,8 +53,34 @@ public class Mediator(IHandlerProvider handlerProvider,
         return default;
     }
 
-    public async IAsyncEnumerable<object?> HandleMany(object message,
+    public async Task<List<object?>> HandleMany(object message,
         object? key = null,
+        CancellationToken cancellationToken = default)
+    {
+        List<object?> responses = [];
+        await foreach (object? response in HandleManyAsync(message, key, cancellationToken))
+        {
+            responses.Add(response);
+        }
+        return responses;
+    }
+
+    public async Task<IList<TResponse?>> HandleMany<TMessage, TResponse>(TMessage message,
+        object? key = null,
+        CancellationToken cancellationToken = default)
+        where TMessage : notnull
+    {
+        List<TResponse?> responses = [];
+        await foreach (TResponse? response in HandleManyAsync<TMessage, TResponse>(message, key, cancellationToken))
+        {
+            responses.Add(response);
+        }
+
+        return responses;
+    }
+
+    public async IAsyncEnumerable<object?> HandleManyAsync(object message,
+                object? key = null,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
         Type messageType = message.GetType();
@@ -76,14 +102,12 @@ public class Mediator(IHandlerProvider handlerProvider,
             }
         }
     }
-
+    public async IAsyncEnumerable<TResponse?> HandleManyAsync<TMessage, TResponse>(TMessage message,
-    public async IAsyncEnumerable<TResponse?> HandleMany<TMessage, TResponse>(TMessage message,
         object? key = null,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
         where TMessage : notnull
     {
         List<object?> handlers = GetHandlers<TMessage, TResponse>(message, key);
-
         foreach (object? handler in handlers)
         {
             MethodInfo? handleMethod = handler?.GetType().GetMethod("Handle", [message.GetType(), typeof(CancellationToken)]);
@@ -93,6 +117,7 @@ public class Mediator(IHandlerProvider handlerProvider,
             }
         }
     }
+
     private List<object?> GetHandlers<TMessage, TResponse>(TMessage message, object? key)
         where TMessage : notnull
     {

Toolkit.Foundation/MediatorExtensions.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public static class MediatorExtensions
+{
+
+}

Toolkit.Foundation/NotificationAttribute.cs

@@ -2,7 +2,8 @@
 
 
 [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
-public class NotificationAttribute(Type type, object key) : Attribute
+public class NotificationAttribute(Type type,
+    object key) : Attribute
 {
     public Type Type => type;
 

Toolkit.Foundation/ObservableCollection.cs

@@ -6,6 +6,40 @@ using System.Reactive.Disposables;
 
 namespace Toolkit.Foundation;
 
+public interface IIndexable
+{
+    int Index { get; }
+}
+
+public interface ICollectionSynchronization<TItem> 
+    where TItem : notnull
+{
+    int IndexOf(TItem item);
+}
+
+public interface ICollectionSynchronizer 
+{
+    void Set<TItem>(ICollectionSynchronization<TItem> collection)
+        where TItem : notnull;
+}
+
+public class CollectionSynchronizer(IServiceProvider serviceProvider) : 
+    ICollectionSynchronizer
+{
+    private readonly IServiceProvider serviceProvider = serviceProvider;
+
+    public void Set<TItem>(ICollectionSynchronization<TItem> collection) 
+        where TItem : notnull
+    {
+        if (serviceProvider.GetService<IDecoratorService<ICollectionSynchronization<TItem>>>() 
+            is IDecoratorService<ICollectionSynchronization<TItem>> decoratorService)
+        {
+            decoratorService.Set(collection);
+        }
+    }
+}
+
+
 public partial class ObservableCollection<TItem> :
     ObservableObject,
     IObservableCollectionViewModel<TItem>,
@@ -18,6 +52,7 @@ public partial class ObservableCollection<TItem> :
     IList,
     IReadOnlyList<TItem>,
     INotifyCollectionChanged,
+    ICollectionSynchronization<TItem>,
     IServiceProviderRequired,
     IServiceFactoryRequired,
     IMediatorRequired,
@@ -31,7 +66,7 @@ public partial class ObservableCollection<TItem> :
     INotificationHandler<MoveToEventArgs<TItem>>,
     INotificationHandler<ReplaceEventArgs<TItem>>,
     INotificationHandler<SelectionEventArgs<TItem>>
-    where TItem :
+    where TItem : notnull, 
     IDisposable
 {
     private readonly System.Collections.ObjectModel.ObservableCollection<TItem> collection = [];
@@ -54,13 +89,16 @@ public partial class ObservableCollection<TItem> :
     [ObservableProperty]
     private TItem? selectedItem;
 
-    public ObservableCollection(IServiceProvider provider,
+    public ObservableCollection(ICollectionSynchronizer synchronizer,
+        IServiceProvider provider,
         IServiceFactory factory,
         IMediator mediator,
         IPublisher publisher,
         ISubscription subscriber,
         IDisposer disposer)
     {
+        synchronizer.Set(this);
+
         Provider = provider;
         Factory = factory;
         Mediator = mediator;
@@ -73,7 +111,8 @@ public partial class ObservableCollection<TItem> :
         collection.CollectionChanged += OnCollectionChanged;
     }
 
-    public ObservableCollection(IServiceProvider provider,
+    public ObservableCollection(ICollectionSynchronizer synchronizer, 
+        IServiceProvider provider,
         IServiceFactory factory,
         IMediator mediator,
         IPublisher publisher,
@@ -81,6 +120,8 @@ public partial class ObservableCollection<TItem> :
         IDisposer disposer,
         IEnumerable<TItem> items)
     {
+        synchronizer.Set(this);
+
         Provider = provider;
         Factory = factory;
         Mediator = mediator;
@@ -623,21 +664,24 @@ public partial class ObservableCollection<TItem> :
     }
 }
 
-public partial class ObservableCollection<TValue, TViewModel>(IServiceProvider provider,
+public partial class ObservableCollection<TValue, TViewModel>(ICollectionSynchronizer synchronizer, 
+    IServiceProvider provider,
     IServiceFactory factory,
     IMediator mediator,
     IPublisher publisher,
-    ISubscription subscriber, IDisposer disposer) : ObservableCollection<TViewModel>(provider, factory, mediator, publisher, subscriber, disposer)
+    ISubscription subscriber, IDisposer disposer) : ObservableCollection<TViewModel>(synchronizer, provider, factory, mediator, publisher, subscriber, disposer)
-    where TViewModel : IDisposable
+    where TViewModel : notnull,
+    IDisposable
 {
     [ObservableProperty]
     private TValue? value;
 }
 
-public class ObservableCollection(IServiceProvider provider,
+public class ObservableCollection(ICollectionSynchronizer synchronizer,
+    IServiceProvider provider,
     IServiceFactory factory,
     IMediator mediator,
     IPublisher publisher,
     ISubscription subscriber,
     IDisposer disposer) :
-    ObservableCollection<IDisposable>(provider, factory, mediator, publisher, subscriber, disposer);
+    ObservableCollection<IDisposable>(synchronizer, provider, factory, mediator, publisher, subscriber, disposer);