/// <summary> /// Registers the commanding system in an ioc container. /// If the container is not able to resolve unregistered types (for example the NetStandard Microsoft container) then /// the commandHandlerContainerRegistration should be used to perform the type registration for the handler /// </summary> /// <param name="dependencyResolver">The dependency resolver to register inside</param> /// <param name="options">Configuration options for the commanding system</param> /// <returns>The dependency resolver</returns> public ICommandRegistry AddCommanding(ICommandingDependencyResolverAdapter dependencyResolver, IOptions options = null) { options = options ?? new Options(); dependencyResolver.AssociatedCommandingRuntime = this; ICommandHandlerExecuter commandHandlerExecuter = new CommandHandlerExecuter(); dependencyResolver.RegisterInstance(commandHandlerExecuter); IOptionsProvider optionsProvider = new OptionsProvider(options); dependencyResolver.RegisterInstance(optionsProvider); // the registry is always shared, but vagaries of different IoC containers mean its dangerous to rely // on dependecy resolver checks for an existing registration lock (_registryLockObject) { if (_registry == null || options.Reset) { Action <Type> resolverContainerRegistration = type => dependencyResolver.TypeMapping(type, type); _registry = new CommandRegistry(commandHandlerExecuter, options.CommandHandlerContainerRegistration ?? resolverContainerRegistration); } dependencyResolver.RegisterInstance(_registry); } // the enricher is always shared, but vagaries of different IoC containers mean its dangerous to rely // on dependecy resolver checks for an existing registration lock (_enrichmentLockObject) { if (_dispatchContextEnrichment == null || options.Reset) { _dispatchContextEnrichment = new CommandDispatchContextEnrichment(options.Enrichers ?? new List <ICommandDispatchContextEnricher>()); } else if (options.Enrichers != null) { _dispatchContextEnrichment.AddEnrichers(options.Enrichers); } dependencyResolver.RegisterInstance(_dispatchContextEnrichment); } lock (_auditItemEnricherPipelineLockObject) { if (_auditItemEnricherPipeline == null || options.Reset) { _auditItemEnricherPipeline = new AuditItemEnricherPipeline( options.AuditItemEnricherFactoryFunc ?? (type => (IAuditItemEnricher)dependencyResolver.Resolve(type))); } dependencyResolver.RegisterInstance(_auditItemEnricherPipeline); } lock (_auditorPipelineLockObject) { if (_auditorPipeline == null || options.Reset) { _auditorPipeline = new CommandAuditPipeline(t => (ICommandAuditor)dependencyResolver.Resolve(t), dependencyResolver.Resolve <ICommandAuditSerializer>, _auditItemEnricherPipeline); } dependencyResolver.RegisterInstance(_auditorPipeline); } ICommandHandlerFactory commandHandlerFactory = new CommandHandlerFactory(options.CommandHandlerFactoryFunc ?? dependencyResolver.Resolve); IPipelineAwareCommandHandlerExecuter pipelineAwareCommandHandlerExecuter = new PipelineAwareCommandHandlerExecuter(); dependencyResolver.RegisterInstance(commandHandlerFactory); dependencyResolver.RegisterInstance(pipelineAwareCommandHandlerExecuter); dependencyResolver.TypeMapping <ICommandAuditorFactory, NullCommandAuditorFactory>(); dependencyResolver.TypeMapping <ICommandScopeManager, AsyncLocalCommandScopeManager>(); dependencyResolver.TypeMapping <IFrameworkCommandDispatcher, CommandDispatcher>(); dependencyResolver.TypeMapping <ICommandDispatcher, CommandDispatcher>(); dependencyResolver.TypeMapping <IFrameworkCommandExecuter, CommandExecuter>(); dependencyResolver.TypeMapping <ICommandExecuter, CommandExecuter>(); dependencyResolver.TypeMapping <IDirectCommandExecuter, DirectCommandExecuter>(); if (options.DisableCorrelationIds) { dependencyResolver.TypeMapping <ICommandCorrelationIdProvider, DisabledCorrelationIdProvider>(); } else { if (options.UseLocallyUniqueCorrelationIds) { dependencyResolver .TypeMapping <ICommandCorrelationIdProvider, LocallyUniqueCommandCorrelationIdProvider>(); } else { dependencyResolver.TypeMapping <ICommandCorrelationIdProvider, CommandCorrelationIdProvider>(); } } dependencyResolver.TypeMapping <ICommandAuditSerializer, CommandAuditSerializer>(); dependencyResolver.TypeMapping(typeof(ICommandExecutionExceptionHandler), options.CommandExecutionExceptionHandler ?? typeof(DefaultCommandExecutionExceptionHandler)); return(_registry); }