Refactor to match API of other CQRS extension packages

Author: joel-jeremy

Src/CqrsBuilder.cs

@@ -7,7 +7,7 @@ internal class CommandHandlerDelegateResolver : IMessageHandlerResolver
     {
         private readonly IMessageHandlerResolver _messageHandlerResolver;
 
-        public CommandHandlerDelegateResolver(IMessageHandlerResolver messageHandlerResolver)
+        internal CommandHandlerDelegateResolver(IMessageHandlerResolver messageHandlerResolver)
         {
             _messageHandlerResolver = messageHandlerResolver;
         }

Src/ICqrsBuilder.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Microsoft.Extensions.DependencyInjection;
+using Xer.Cqrs.CommandStack;
+using Xer.Cqrs.CommandStack.Attributes;
+using Xer.Cqrs.CommandStack.Resolvers;
+using Xer.Cqrs.EventStack;
+using Xer.Cqrs.EventStack.Attributes;
+using Xer.Cqrs.EventStack.Resolvers;
+using Xer.Delegator.Registrations;
+using Xer.Delegator.Resolvers;
+
+namespace Xer.Cqrs.Extensions.Microsoft.DependencyInjection
+{
+    internal class CqrsBuilder : ICqrsBuilder
+    {
+        private readonly IServiceCollection _serviceCollection;
+        private readonly CqrsCommandHandlerSelector _commandHandlerSelector;
+        private readonly CqrsEventHandlerSelector _eventHandlerSelector;
+
+        internal CqrsBuilder(IServiceCollection serviceCollection)
+        {
+            _serviceCollection = serviceCollection;
+            _commandHandlerSelector = new CqrsCommandHandlerSelector(serviceCollection);
+            _eventHandlerSelector = new CqrsEventHandlerSelector(serviceCollection);
+        }
+
+        public ICqrsBuilder AddCommandHandlers(Action<ICqrsCommandHandlerSelector> selector)
+        {
+            if (selector == null)
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
+            selector(_commandHandlerSelector);
+
+            _serviceCollection.AddSingleton<CommandDelegator>(serviceProvider => 
+            {
+                CommandHandlerDelegateResolver[] messageHandlerResolvers = serviceProvider.GetServices<CommandHandlerDelegateResolver>().ToArray();
+                
+                if (messageHandlerResolvers.Length == 1)
+                {
+                    return new CommandDelegator(messageHandlerResolvers[0]);
+                }
+                else if (messageHandlerResolvers.Length > 1)
+                {
+                    return new CommandDelegator(CompositeMessageHandlerResolver.Compose(messageHandlerResolvers));
+                }
+                
+                // Empty delegator.
+                return new CommandDelegator(new SingleMessageHandlerRegistration().BuildMessageHandlerResolver());
+            });
+
+            return this;
+        }
+
+        public ICqrsBuilder AddEventHandlers(Action<ICqrsEventHandlerSelector> selector)
+        {
+            if (selector == null)
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
+            selector(_eventHandlerSelector);
+
+            _serviceCollection.AddSingleton<EventDelegator>(serviceProvider => 
+            {
+                EventHandlerDelegateResolver[] messageHandlerResolvers = serviceProvider.GetServices<EventHandlerDelegateResolver>().ToArray();
+                
+                if (messageHandlerResolvers.Length == 1)
+                {
+                    return new EventDelegator(messageHandlerResolvers[0]);
+                }
+                else if (messageHandlerResolvers.Length > 1)
+                {
+                    return new EventDelegator(CompositeMessageHandlerResolver.Compose(messageHandlerResolvers));
+                }
+
+                // Empty delegator.
+                return new EventDelegator(new MultiMessageHandlerRegistration().BuildMessageHandlerResolver());
+            });
+
+            return this;
+        }
+    }
+}

Src/AssemblyInfo.cs renamed to Src/Xer.Cqrs.Extensions.Microsoft.DependencyInjection/AssemblyInfo.cs

@@ -0,0 +1,100 @@
+using System.Collections.Generic;
+using System.Reflection;
+using Microsoft.Extensions.DependencyInjection;
+using Xer.Cqrs.CommandStack;
+using Xer.Cqrs.CommandStack.Resolvers;
+using Xer.Delegator.Registrations;
+using Xer.Delegator.Resolvers;
+
+namespace Xer.Cqrs.Extensions.Microsoft.DependencyInjection
+{
+    internal class CqrsCommandHandlerSelector : ICqrsCommandHandlerSelector
+    {
+        private readonly IServiceCollection _serviceCollection;
+
+        internal CqrsCommandHandlerSelector(IServiceCollection serviceCollection)
+        {
+            _serviceCollection = serviceCollection;
+        }
+
+        public ICqrsCommandHandlerSelector ByInterface(Assembly assembly)
+        {
+            return ByInterface(assembly, ServiceLifetime.Transient);
+        }
+
+        public ICqrsCommandHandlerSelector ByInterface(Assembly assembly, ServiceLifetime lifetime)
+        {
+            return ByInterface(new[] { assembly }, lifetime);
+        }
+
+        public ICqrsCommandHandlerSelector ByInterface(IEnumerable<Assembly> assemblies)
+        {
+            return ByInterface(assemblies, ServiceLifetime.Transient);
+        }
+
+        public ICqrsCommandHandlerSelector ByInterface(IEnumerable<Assembly> assemblies, ServiceLifetime lifetime)
+        {
+            if (assemblies == null)
+            {
+                throw new System.ArgumentNullException(nameof(assemblies));
+            }
+
+            _serviceCollection.Scan(scan => scan
+                .FromAssemblies(assemblies)
+                // Register async and sync command handlers
+                .AddClasses(classes => classes.AssignableToAny(typeof(ICommandAsyncHandler<>), typeof(ICommandHandler<>)))
+                .AsImplementedInterfaces()
+                .WithLifetime(lifetime));
+
+            _serviceCollection.AddSingleton<CommandHandlerDelegateResolver>(serviceProvider =>
+            {
+                return new CommandHandlerDelegateResolver(
+                    CompositeMessageHandlerResolver.Compose(
+                        new ContainerCommandAsyncHandlerResolver(new ServiceProviderAdapter(serviceProvider)),
+                        new ContainerCommandHandlerResolver(new ServiceProviderAdapter(serviceProvider))));
+            });
+
+            return this;
+        }
+
+        public ICqrsCommandHandlerSelector ByAttribute(Assembly assembly)
+        {
+            return ByAttribute(assembly, ServiceLifetime.Transient);
+        }
+
+        public ICqrsCommandHandlerSelector ByAttribute(Assembly assembly, ServiceLifetime lifetime)
+        {
+            return ByAttribute(new[] { assembly }, lifetime);
+        }
+
+        public ICqrsCommandHandlerSelector ByAttribute(IEnumerable<Assembly> assemblies)
+        {
+            return ByAttribute(assemblies, ServiceLifetime.Transient);
+        }
+
+        public ICqrsCommandHandlerSelector ByAttribute(IEnumerable<Assembly> assemblies, ServiceLifetime lifetime)
+        {
+            if (assemblies == null)
+            {
+                throw new System.ArgumentNullException(nameof(assemblies));
+            }
+
+            _serviceCollection.Scan(scan => scan
+                .FromAssemblies(assemblies)
+                // Register classes that has a method marked with [CommandHandler]
+                .AddClasses(classes => classes.Where(type => CommandHandlerAttributeMethod.IsFoundInType(type)))
+                .AsSelf()
+                .WithLifetime(lifetime));
+            
+            _serviceCollection.AddSingleton<CommandHandlerDelegateResolver>(serviceProvider => 
+            {
+                var singleMessageHandlerRegistration = new SingleMessageHandlerRegistration();
+                singleMessageHandlerRegistration.RegisterCommandHandlerAttributes(assemblies, serviceProvider.GetRequiredService);
+
+                return new CommandHandlerDelegateResolver(singleMessageHandlerRegistration.BuildMessageHandlerResolver());
+            });
+
+            return this;
+        }
+    }
+}