Add drag/drop handling

TheXamlGuy.TaskbarGroup.Core/IAsyncMessageHandler.cs

@@ -1,11 +1,16 @@
 namespace TheXamlGuy.TaskbarGroup.Core
 {
-    public interface IAsyncMessageHandler<TMessage>
+    public interface IAsyncMessageHandler
+    {
+
+    }
+
+    public interface IAsyncMessageHandler<TMessage> : IAsyncMessageHandler
     {
         Task Handle(TMessage message, CancellationToken canellationToken = default);
     }
 
-    public interface IAsyncMessageHandler<TReturn, TMessage>
+    public interface IAsyncMessageHandler<TReturn, TMessage> : IAsyncMessageHandler
     {
         Task<TReturn> Handle(TMessage message, CancellationToken cancellationToken = default);
     }

TheXamlGuy.TaskbarGroup.Core/IMessageHandler.cs

@@ -1,11 +1,15 @@
 namespace TheXamlGuy.TaskbarGroup.Core
 {
-    public interface IMessageHandler<TMessage>
+    public interface IMessageHandler
+    {
+
+    }
+    public interface IMessageHandler<TMessage> : IMessageHandler
     {
         void Handle(TMessage message);
     }
 
-    public interface IMessageHandler<TReturn, TMessage>
+    public interface IMessageHandler<TReturn, TMessage> : IMessageHandler
     {
         TReturn Handle(TMessage message);
     }

TheXamlGuy.TaskbarGroup.Core/IMessageInvoker.cs

@@ -2,7 +2,7 @@
 
 namespace TheXamlGuy.TaskbarGroup.Core
 {
-    public interface IEventAggregatorInvoker
+    public interface IMessageInvoker
     {
         void Invoke<TMessage>(object target, TMessage message, MethodInfo methodInfo);
     }

TheXamlGuy.TaskbarGroup.Core/IObservableExtensions.cs

@@ -6,7 +6,7 @@ namespace TheXamlGuy.TaskbarGroup.Core
 
     public static class IObservableExtensions
     {
-        public static IDisposable WeakSubscribe<TMessage>(this IObservable<TMessage> observable, IEventAggregatorInvoker invoker, Action<TMessage> actionDelegate)
+        public static IDisposable WeakSubscribe<TMessage>(this IObservable<TMessage> observable, IMessageInvoker invoker, Action<TMessage> actionDelegate)
         {
             var methodInfo = actionDelegate.Method;
             var weakReference = new WeakReference(actionDelegate.Target);

TheXamlGuy.TaskbarGroup.Core/IServiceCollectionExtensions.cs

@@ -4,12 +4,55 @@ namespace TheXamlGuy.TaskbarGroup.Core
 {
     public static class IServiceCollectionExtensions
     {
+        public static IServiceCollection AddAsyncHandler<TAsyncMessageHandle>(this IServiceCollection serviceCollection)
+            where TAsyncMessageHandle : IAsyncMessageHandler
+        {
+            if (typeof(TAsyncMessageHandle).GetInterfaces().FirstOrDefault(x =>
+                x.GetGenericTypeDefinition() == typeof(IAsyncMessageHandler<>)
+                || x.GetGenericTypeDefinition() == typeof(IAsyncMessageHandler<>)) is { } messageHandler)
+            {
+                var messageArguments = messageHandler.GetGenericArguments();
+                if (messageArguments is { Length: 1 })
+                {
+                    serviceCollection.AddTransient(typeof(IAsyncMessageHandler<>).MakeGenericType(messageArguments[0]), typeof(TAsyncMessageHandle));
+                }
+                else
+                {
+                    serviceCollection.AddTransient(typeof(IAsyncMessageHandler<,>).MakeGenericType(messageArguments[0], messageArguments[1]), typeof(TAsyncMessageHandle));
+                }
+            }
+
+            return serviceCollection;
+        }
+
+        public static IServiceCollection AddHandler<TMessageHandle>(this IServiceCollection serviceCollection)
+            where TMessageHandle : IMessageHandler
+        {
+            if (typeof(TMessageHandle).GetInterfaces().FirstOrDefault(x =>
+                x.GetGenericTypeDefinition() == typeof(IMessageHandler<>)
+                || x.GetGenericTypeDefinition() == typeof(IMessageHandler<,>)) is { } messageHandler)
+            {
+                var messageArguments = messageHandler.GetGenericArguments();
+
+                if (messageArguments is { Length: 1 })
+                {
+                    serviceCollection.AddTransient(typeof(IMessageHandler<>).MakeGenericType(messageArguments[0]), typeof(TMessageHandle));
+                }
+                else
+                {
+                    serviceCollection.AddTransient(typeof(IMessageHandler<,>).MakeGenericType(messageArguments[0], messageArguments[1]), typeof(TMessageHandle));
+                }
+            }
+
+            return serviceCollection;
+        }
+
         public static IServiceCollection AddRequiredCore(this IServiceCollection serviceCollection)
         {
             return serviceCollection
                 .AddSingleton<IDisposer, Disposer>()
                 .AddSingleton<IServiceFactory>(provider => new ServiceFactory(provider.GetService, (type, parameter) => ActivatorUtilities.CreateInstance(provider, type, parameter)))
-                .AddSingleton<IEventAggregatorInvoker, EventAggregatorInvoker>()
+                .AddSingleton<IMessageInvoker, MessageInvoker>()
                 .AddSingleton<IMessenger, Messenger>()
                 .AddSingleton<IMediator, Mediator>()
                 .AddSingleton<IInitializable, WndProcMonitor>()

TheXamlGuy.TaskbarGroup.Core/Mediator.cs

@@ -40,6 +40,7 @@
         {
             return HandleAsync<TResponse>(new TRequest(), parameters);
         }
+
         public Task HandleAsync(object request, CancellationToken cancellationToken, params object[] parameters)
         {
             return GetHandler(typeof(IAsyncMessageHandler<>).MakeGenericType(request.GetType()), parameters)

TheXamlGuy.TaskbarGroup.Core/MessageInvoker.cs

@@ -2,7 +2,7 @@
 
 namespace TheXamlGuy.TaskbarGroup.Core
 {
-    public class EventAggregatorInvoker : IEventAggregatorInvoker
+    public class MessageInvoker : IMessageInvoker
     {
         public void Invoke<TMessage>(object target, TMessage message, MethodInfo methodInfo)
         {

TheXamlGuy.TaskbarGroup.Core/Messenger.cs

@@ -7,12 +7,12 @@ namespace TheXamlGuy.TaskbarGroup.Core
 {
     public class Messenger : IMessenger
     {
-        public IEventAggregatorInvoker invoker;
+        public IMessageInvoker invoker;
         private readonly ConcurrentDictionary<Type, object> subjects = new();
 
         private IScheduler dispatcher;
 
-        public Messenger(IEventAggregatorInvoker invoker)
+        public Messenger(IMessageInvoker invoker)
         {
             var synchronizationContext = SynchronizationContext.Current;
             if (synchronizationContext is null) throw new NullReferenceException(nameof(synchronizationContext));