Add validation

Toolkit.Foundation/IServiceCollectionExtensions.cs

@@ -41,43 +41,43 @@ public static class IServiceCollectionExtensions
         string? key = null)
         where THandler : IHandler
     {
-        if (typeof(THandler).GetInterfaces() is Type[] contracts)
+        if (typeof(THandler).GetInterfaces() is Type[] handlerTypes)
         {
-            foreach (Type contract in contracts)
+            foreach (Type handlerType in handlerTypes)
             {
-                if (contract.Name == typeof(INotificationHandler<>).Name &&
+                if (handlerType.Name == typeof(INotificationHandler<>).Name &&
-                    contract.GetGenericArguments() is { Length: 1 } notificationHandlerArguments)
+                    handlerType.GetGenericArguments() is { Length: 1 } notificationHandlerArguments)
                 {
                     Type notificationType = notificationHandlerArguments[0];
                     Type wrapperType = typeof(NotificationHandlerWrapper<>).MakeGenericType(notificationType);
 
-                    string actualKey = $"{(key is not null ? $"{key}:" : "")}{notificationType}";
+                    string preferredKey = $"{(key is not null ? $"{key}:" : "")}{notificationType}";
 
                     services.Add(new ServiceDescriptor(typeof(INotificationHandler<>)
-                        .MakeGenericType(notificationType), actualKey, typeof(THandler), lifetime));
+                        .MakeGenericType(notificationType), preferredKey, typeof(THandler), lifetime));
 
-                    services.Add(new ServiceDescriptor(wrapperType, actualKey, (provider, registeredKey) =>
+                    services.Add(new ServiceDescriptor(wrapperType, preferredKey, (provider, registeredKey) =>
                             provider.GetService<IServiceFactory>()?.Create(wrapperType,
                                 provider.GetRequiredKeyedService(typeof(INotificationHandler<>).MakeGenericType(notificationType), registeredKey),
                                 provider.GetServices(typeof(IPipelineBehaviour<>)
                                     .MakeGenericType(notificationType)))!, lifetime));
                 }
 
-                if (contract.Name == typeof(IHandler<,>).Name &&
+                if (handlerType.Name == typeof(IHandler<,>).Name &&
-                    contract.GetGenericArguments() is { Length: 2 } handlerArguments)
+                    handlerType.GetGenericArguments() is { Length: 2 } handlerArguments)
                 {
                     Type requestType = handlerArguments[0];
                     Type responseType = handlerArguments[1];
 
                     Type wrapperType = typeof(HandlerWrapper<,>).MakeGenericType(requestType, responseType);
-                    string actualKey = $"{(key is not null ? $"{key}:" : "")}{wrapperType}";
+                    string preferredKey = $"{(key is not null ? $"{key}:" : "")}{wrapperType}";
 
-                    services.Add(new ServiceDescriptor(typeof(THandler), actualKey,
+                    services.Add(new ServiceDescriptor(typeof(THandler), preferredKey,
                         typeof(THandler), lifetime));
 
-                    services.Add(new ServiceDescriptor(wrapperType, actualKey, (provider, actualKey) =>
+                    services.Add(new ServiceDescriptor(wrapperType, preferredKey, (provider, actualKey) =>
                         provider.GetService<IServiceFactory>()?.Create(wrapperType,
-                                provider.GetRequiredKeyedService<THandler>(actualKey),
+                                provider.GetRequiredKeyedService<THandler>(preferredKey),
                                 provider.GetServices(typeof(IPipelineBehaviour<,>)
                                     .MakeGenericType(requestType, responseType)))!, lifetime));
                 }

Toolkit.Foundation/Subscriber.cs

@@ -8,106 +8,88 @@ public class Subscriber(SubscriptionCollection subscriptions,
 {
     public void Subscribe(object subscriber)
     {
-        Type handlerType = subscriber.GetType();
-
         IDictionary<Type, List<object>> subscribers = GetSubscriptionKeys(subscriber);
-        foreach (Type interfaceType in GetHandlerInterfaces(handlerType))
-        {
-            if (interfaceType.GetGenericArguments().FirstOrDefault() is Type argumentType)
-            {
-                subscribers.TryGetValue(argumentType, out List<object>? keys);
-                if (keys is not null)
-                {
-                    foreach (object key in keys)
-                    {
-                        string subscriptionKey = $"{(key is not null ? $"{key}:" : "")}{argumentType}";
-                        subscriptions.AddOrUpdate(subscriptionKey, _ => new List<WeakReference> { new(subscriber) }, (_, collection) =>
-                        {
-                            collection.Add(new WeakReference(subscriber));
-                            return collection;
-                        });
 
-                        disposer.Add(subscriber, Disposable.Create(() => RemoveSubscriber(subscriber, subscriptionKey)));
+        foreach (Type handlerType in GetHandlerInterfaces(subscriber.GetType()))
-                    }
-                }
-                else
         {
-                    string subscriptionKey = $"{argumentType}";
+            if (handlerType.Name == typeof(INotificationHandler<>).Name &&
-                    subscriptions.AddOrUpdate(subscriptionKey, _ => new List<WeakReference> { new(subscriber) }, (_, collection) =>
+                handlerType.GetGenericArguments() is { Length: 1 } notificationHandlerArguments)
             {
-                        collection.Add(new WeakReference(subscriber));
+                Type notificationType = notificationHandlerArguments[0];
-                        return collection;
+                AddSubscriptions(subscriber, subscribers, notificationType);
-                    });
+            }
 
-                    disposer.Add(subscriber, Disposable.Create(() => RemoveSubscriber(subscriber, subscriptionKey)));
+            if (handlerType.Name == typeof(IHandler<,>).Name &&
-                }
+                handlerType.GetGenericArguments() is { Length: 2 } handlerArguments)
+            {
+                Type requestType = handlerArguments[0];
+                Type responseType = handlerArguments[1];
+                Type wrapperType = typeof(HandlerWrapper<,>).MakeGenericType(requestType, responseType);
+                AddSubscriptions(subscriber, subscribers, wrapperType);
             }
         }
     }
 
     public void Unsubscribe(object subscriber)
     {
-        Type handlerType = subscriber.GetType();
         IDictionary<Type, List<object>> subscribers = GetSubscriptionKeys(subscriber);
-        foreach (Type interfaceType in GetHandlerInterfaces(handlerType))
+
+        foreach (Type handlerType in GetHandlerInterfaces(subscriber.GetType()))
         {
-            if (interfaceType.GetGenericArguments().FirstOrDefault() is Type argumentType)
+            if (handlerType.Name == typeof(INotificationHandler<>).Name &&
+                handlerType.GetGenericArguments() is { Length: 1 } notificationHandlerArguments)
             {
-                subscribers.TryGetValue(argumentType, out List<object>? keys);
+                Type notificationType = notificationHandlerArguments[0];
-                if (keys is not null)
+                RemoveSubscriptions(subscriber, subscribers, notificationType);
+            }
+
+            if (handlerType.Name == typeof(IHandler<,>).Name &&
+                handlerType.GetGenericArguments() is { Length: 2 } handlerArguments)
+            {
+                Type requestType = handlerArguments[0];
+                Type responseType = handlerArguments[1];
+                Type wrapperType = typeof(HandlerWrapper<,>).MakeGenericType(requestType, responseType);
+                RemoveSubscriptions(subscriber, subscribers, wrapperType);
+            }
+        }
+    }
+
+    private void AddOrUpdateSubscription(object subscriber, string preferredKey)
+    {
+        subscriptions.AddOrUpdate(preferredKey, _ => new List<WeakReference> { new(subscriber) }, (_, collection) =>
+        {
+            collection.Add(new WeakReference(subscriber));
+            return collection;
+        });
+
+        disposer.Add(subscriber, Disposable.Create(() => RemoveSubscription(subscriber, preferredKey)));
+    }
+
+    private void AddSubscriptions(object subscriber, IDictionary<Type, List<object>> subscribers, Type handlerType)
+    {
+        if (subscribers.TryGetValue(handlerType, out List<object>? keys))
         {
             foreach (object key in keys)
             {
-                        string subscriptionKey = $"{(key is not null ? $"{key}:" : "")}{argumentType}";
+                string preferredKey = $"{(key is not null ? $"{key}:" : "")}{handlerType}";
-                        if (subscriptions.TryGetValue(subscriptionKey, out List<WeakReference>? existing))
+                AddOrUpdateSubscription(subscriber, preferredKey);
-                        {
-                            for (int i = existing.Count - 1; i >= 0; i--)
-                            {
-                                if (!existing[i].IsAlive || existing[i].Target == subscriber)
-                                {
-                                    existing.RemoveAt(i);
-                                }
-                            }
-                        }
             }
         }
         else
         {
-                    string subscriptionKey = $"{argumentType}";
+            string preferredKey = $"{handlerType}";
-                    if (subscriptions.TryGetValue(subscriptionKey, out List<WeakReference>? existing))
+            AddOrUpdateSubscription(subscriber, preferredKey);
-                    {
-                        for (int i = existing.Count - 1; i >= 0; i--)
-                        {
-                            if (!existing[i].IsAlive || existing[i].Target == subscriber)
-                            {
-                                existing.RemoveAt(i);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    private void RemoveSubscriber(object subscriber,
-        string key)
-    {
-        if (subscriptions.TryGetValue(key, out List<WeakReference>? subscribers))
-        {
-            for (int i = subscribers.Count - 1; i >= 0; i--)
-            {
-                if (subscribers[i].Target == subscriber)
-                {
-                    subscribers.RemoveAt(i);
         }
     }
 
-            if (subscribers.Count == 0)
+    private IEnumerable<Type> GetHandlerInterfaces(Type handlerType) =>
+        handlerType.GetInterfaces().Where(interfaceType =>
         {
-                subscriptions.TryRemove(key, out _);
+            Type? definition = interfaceType.IsGenericType ? interfaceType.GetGenericTypeDefinition() : null;
-            }
+            return definition == typeof(INotificationHandler<>) ||
-        }
+                   definition == typeof(IHandler<>) ||
-    }
+                   definition == typeof(IHandler<,>);
+        });
 
     private IDictionary<Type, List<object>> GetSubscriptionKeys(object subscriber)
     {
@@ -133,12 +115,40 @@ public class Subscriber(SubscriptionCollection subscriptions,
         return keys;
     }
 
-    private IEnumerable<Type> GetHandlerInterfaces(Type handlerType) =>
+    private void RemoveSubscription(object subscriber,
-        handlerType.GetInterfaces().Where(interfaceType =>
+        string key)
     {
-            Type? definition = interfaceType.IsGenericType ? interfaceType.GetGenericTypeDefinition() : null;
+        if (subscriptions.TryGetValue(key, out List<WeakReference>? subscribers))
-            return definition == typeof(INotificationHandler<>) ||
+        {
-                   definition == typeof(IHandler<>) ||
+            for (int i = subscribers.Count - 1; i >= 0; i--)
-                   definition == typeof(IHandler<,>);
+            {
-        });
+                if (subscribers[i].Target == subscriber)
+                {
+                    subscribers.RemoveAt(i);
+                }
+            }
+
+            if (subscribers.Count == 0)
+            {
+                subscriptions.TryRemove(key, out _);
+            }
+        }
+    }
+
+    private void RemoveSubscriptions(object subscriber, IDictionary<Type, List<object>> subscribers, Type handlerType)
+    {
+        if (subscribers.TryGetValue(handlerType, out List<object>? keys))
+        {
+            foreach (object key in keys)
+            {
+                string subscriptionKey = $"{(key is not null ? $"{key}:" : "")}{handlerType}";
+                RemoveSubscription(subscriber, subscriptionKey);
+            }
+        }
+        else
+        {
+            string subscriptionKey = $"{handlerType}";
+            RemoveSubscription(subscriber, subscriptionKey);
+        }
+    }
 }