C# IContainer.RegisterCollection方法代码示例

        private void RegisterService(IContainer container)
        {
            if (Metrics != null)
            {
                container.Register<IMetrics>(() => Metrics, LifeStyles.Singleton);
            }

            if (Des && Gzip)
            {
                container.RegisterCollection<IMessageInterceptor>(new[]
                {
                    typeof (GZipMessageInterceptor), //gzip compression
                    typeof (TripleDesMessageInterceptor) //encryption
                });
                container.Register(() => DesConfiguration, LifeStyles.Singleton);
            }
            else if (Gzip)
            {
                container.RegisterCollection<IMessageInterceptor>(new[]
                {
                    typeof (GZipMessageInterceptor) //gzip compression
                });
            }
            else if (Des)
            {
                container.RegisterCollection<IMessageInterceptor>(new[]
                {
                    typeof (TripleDesMessageInterceptor) //encryption
                });
                container.Register(() => DesConfiguration,
                    LifeStyles.Singleton);
            }
        }

        public void RegisterServices(IContainer container, CompositionRootSettings settings)
        {
            Guard.ArgumentIsNotNull(settings.ApplicationAssemblies, nameof(settings.ApplicationAssemblies));

            container.RegisterSingleton<IQueryDispatcher, QueryDispatcher>();

            container.RegisterCollection(typeof(IQueryHandler<,>), settings.ApplicationAssemblies);
            container.RegisterCollection(typeof(IQueryAsyncHandler<,>), settings.ApplicationAssemblies);

            container.RegisterDecoratorSingleton(
                typeof(IQueryHandler<,>),
                typeof(QueryLoggerDecorator<,>));

            container.RegisterDecoratorSingleton(
                typeof(IQueryHandler<,>),
                typeof(QueryLifetimeScopeDecorator<,>));

            container.RegisterDecoratorSingleton(
                typeof(IQueryAsyncHandler<,>),
                typeof(QueryAsyncLoggerDecorator<,>));

            container.RegisterDecoratorSingleton(
                typeof(IQueryAsyncHandler<,>),
                typeof(QueryAsyncLifetimeScopeDecorator<,>));
        }

        public void RegisterServices(IContainer container, CompositionRootSettings settings)
        {
            Guard.ArgumentIsNotNull(settings.ApplicationAssemblies, nameof(settings.ApplicationAssemblies));

            container.RegisterSingleton<IApplicationEventDispatcher, ApplicationEventDispatcher>();
            container.RegisterCollection(typeof (IApplicationEventHandler<>), settings.ApplicationAssemblies);

            container.RegisterSingleton<IDomainEventDispatcher, DomainEventDispatcher>();
            container.RegisterCollection(typeof (IDomainEventHandler<>), settings.ApplicationAssemblies);

            container.RegisterDecoratorSingleton(
                typeof (IApplicationEventHandler<>),
                typeof (ApplicationEventLoggerDecorator<>));

            container.RegisterDecoratorSingleton(
                typeof (IDomainEventHandler<>),
                typeof (DomainEventLoggerDecorator<>));

            container.RegisterDecoratorSingleton(
                typeof(IApplicationEventHandler<>),
                typeof(ApplicationEventLifetimeScopeDecorator<>));
        }

//.........这里部分代码省略.........
            container.Register<IRedisConnection, RedisConnection>(LifeStyles.Singleton);
            container.Register<RedisNames>(LifeStyles.Singleton);
            container.Register<RedisQueueTransportOptions>(LifeStyles.Singleton);
            container.Register<DelayedProcessingConfiguration>(LifeStyles.Singleton);
            container.Register<ICorrelationIdFactory, RedisQueueCorrelationIdFactory>(
                LifeStyles.Singleton);

            container.Register<ICreationScope, CreationScopeNoOp>(LifeStyles.Singleton);

            container.Register<IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTime>(LifeStyles.Singleton);
            container.Register<IGetTimeFactory, GetRedisTimeFactory>(LifeStyles.Singleton);

            container.Register<LuaScripts>(LifeStyles.Singleton);

            container.Register<IUnixTimeFactory, UnixTimeFactory>(LifeStyles.Singleton);
            
            container.Register<LocalMachineUnixTime>(LifeStyles.Singleton);
            container.Register<RedisServerUnixTime>(LifeStyles.Singleton);
            container.Register<SntpUnixTime>(LifeStyles.Singleton);

            container.Register<SntpTimeConfiguration>(LifeStyles.Singleton);
            container.Register<RedisHeaders>(LifeStyles.Singleton);
            container.Register<IClearExpiredMessages, RedisQueueClearExpiredMessages>(LifeStyles.Singleton);
            //**all

            //**send
            container.Register<ISendMessages, RedisQueueSend>(LifeStyles.Singleton);

            container.Register<CommitMessage>(LifeStyles.Singleton);
            container.Register<RollbackMessage>(LifeStyles.Singleton);
            container.Register<HandleMessage>(LifeStyles.Singleton);

            container.Register<IGetMessageIdFactory, GetMessageIdFactory>(LifeStyles.Singleton);
            container.Register<GetUuidMessageId>(LifeStyles.Singleton);
            container.Register<GetRedisIncrId>(LifeStyles.Singleton);

            container.Register<ISendBatchSize, RedisSimpleBatchSize>(LifeStyles.Singleton);
            //**send


            //**receive
            container.Register<IDelayedProcessingAction, DelayedProcessingAction>(LifeStyles.Singleton);
            container.Register<IQueueMonitor, RedisQueueMonitor>(LifeStyles.Singleton);

            container.Register<IReceiveMessages, RedisQueueReceiveMessages>(LifeStyles.Transient);

            container.Register<IDelayedProcessingMonitor, RedisDelayedProcessingMonitor>(LifeStyles.Singleton);
            container.Register<IResetHeartBeat, RedisQueueResetHeartBeat>(LifeStyles.Singleton);
            container.Register<ISendHeartBeat, RedisQueueSendHeartBeat>(LifeStyles.Singleton);
            container.Register<IReceiveMessagesFactory, ReceiveMessagesFactory>(LifeStyles.Singleton);
            container.Register<IReceivePoisonMessage, RedisQueueReceivePoisonMessage>(LifeStyles.Singleton);
            container.Register<IRedisQueueWorkSubFactory, RedisQueueWorkSubFactory>(LifeStyles.Singleton);
            container.Register<IReceiveMessagesError, RedisQueueReceiveMessagesError>(LifeStyles.Singleton);
            //**receive

            //commands
            var target = Assembly.GetAssembly(GetType());

            container.Register(typeof(ICommandHandlerWithOutput<,>), LifeStyles.Singleton,
                target);

            container.Register(typeof(ICommandHandler<>), LifeStyles.Singleton,
                target);

            container.Register(typeof(IQueryHandler<,>), LifeStyles.Singleton,
                target);

            //LUA scripts
            container.Register<DequeueLua>(LifeStyles.Singleton);
            container.Register<DequeueRpcLua>(LifeStyles.Singleton);
            container.Register<EnqueueLua>(LifeStyles.Singleton);
            container.Register<EnqueueDelayedLua>(LifeStyles.Singleton);
            container.Register<EnqueueExpirationLua>(LifeStyles.Singleton);
            container.Register<EnqueueDelayedAndExpirationLua>(LifeStyles.Singleton);
            container.Register<DeleteLua>(LifeStyles.Singleton);
            container.Register<RollbackLua>(LifeStyles.Singleton);
            container.Register<RollbackDelayLua>(LifeStyles.Singleton);
            container.Register<ErrorLua>(LifeStyles.Singleton);
            container.Register<MoveDelayedToPendingLua>(LifeStyles.Singleton);
            container.Register<SendHeartbeatLua>(LifeStyles.Singleton);
            container.Register<ClearExpiredMessagesLua>(LifeStyles.Singleton);
            container.Register<ResetHeartbeatLua>(LifeStyles.Singleton);
            container.Register<TimeLua>(LifeStyles.Singleton);
            container.Register<EnqueueBatchLua>(LifeStyles.Singleton);
            container.Register<CommitLua>(LifeStyles.Singleton);
            container.Register<DoesJobExistLua>(LifeStyles.Singleton);

            var types = target.GetTypes().Where(x => x.IsSubclassOf(typeof(BaseLua)));
            container.RegisterCollection<BaseLua>(types);

            //metric decorators
            container.RegisterDecorator<IDelayedProcessingAction, DelayedProcessingActionDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IQueryHandler<ReceiveMessageQuery, RedisMessage>, ReceiveMessageQueryDecorator>(
                LifeStyles.Singleton);

            //logging decorators
            container.RegisterDecorator<IQueryHandler<ReceiveMessageQuery, RedisMessage>, Logging.Decorator.ReceiveMessageQueryDecorator>(
                LifeStyles.Singleton);
            container.RegisterDecorator<IDelayedProcessingAction, Logging.Decorator.DelayedProcessingActionDecorator>(LifeStyles.Singleton);
        }

        private static void RegisterSharedDefaults(IContainer container)
        {
            #region Singletons

            container.Register<IContainerFactory, ContainerFactory>(LifeStyles.Singleton);

            //register the generic configuration container
            container.Register<IConfiguration, AdditionalConfiguration>(LifeStyles.Singleton);
            #endregion

            #region Logging

#if (DEBUG)
            container.Register<ILogProvider, ColoredConsoleLogProvider>(LifeStyles.Singleton);
#else
            container.Register<ILogProvider,NoSpecifiedLogProvider>( LifeStyles.Singleton);
#endif
            container.Register<ILogFactory, LogFactory>(LifeStyles.Singleton);

            #endregion

            container.Register<IQueueStatus, QueueStatusHttp>(LifeStyles.Singleton);
            container.Register<BaseTimeConfiguration>(LifeStyles.Singleton);
            container.Register<IGetTimeFactory, GetTimeFactory>(LifeStyles.Singleton);
            container.Register<IGetTime, LocalMachineTime>(LifeStyles.Singleton);

            container.Register<QueueStatusHttpConfiguration>(LifeStyles.Singleton);
            container.Register<IQueueStatusProvider, QueueStatusProviderNoOp>(LifeStyles.Singleton);

            container.Register<IInterceptorFactory, InterceptorFactory>(LifeStyles.Singleton);
            container.RegisterCollection<IMessageInterceptor>(Enumerable.Empty<Type>());

            RegisterMetricDecorators(container);
            RegisterLoggerDecorators(container);

            //register the linq cache decorator
            container.RegisterDecorator<ILinqCompiler, LinqCompileCacheDecorator>(LifeStyles.Singleton);
        }