C# IContainer.RegisterDecorator方法代码示例

//.........这里部分代码省略.........
            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);
        }

        /// <summary>
        /// Registers the implementations.
        /// </summary>
        /// <param name="container">The container.</param>
        /// <param name="registrationType">Type of the registration.</param>
        /// <param name="connection">The connection.</param>
        /// <param name="queue">The queue.</param>
        public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, string connection, string queue)
        {
            Guard.NotNull(() => container, container);

            //**all
            container.Register<PostgreSqlMessageQueueSchema>(LifeStyles.Singleton);
            container.Register<IQueueCreation, PostgreSqlMessageQueueCreation>(LifeStyles.Singleton);
            container.Register<PostgreSqlMessageQueueStatusQueries>(LifeStyles.Singleton);
            container.Register<IQueueStatusProvider, PostgreSqlQueueStatusProvider>(LifeStyles.Singleton);
            container.Register<IJobSchedulerLastKnownEvent, PostgreSqlJobSchedulerLastKnownEvent>(LifeStyles.Singleton);
            container.Register<IJobTableCreation, PostgreSqlJobTableCreation>(LifeStyles.Singleton);
            container.Register<PostgreSqlJobSchema>(LifeStyles.Singleton);
            container.Register<ISendJobToQueue, PostgreSqlSendJobToQueue>(LifeStyles.Singleton);
            container.Register<CreateJobMetaData>(LifeStyles.Singleton);

            container.Register<IGetTime, PostgreSqlTime>(LifeStyles.Singleton);
            container.Register<IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTime>(LifeStyles.Singleton);
            container
                .Register
                <IPostgreSqlMessageQueueTransportOptionsFactory, PostgreSqlMessageQueueTransportOptionsFactory>(
                    LifeStyles.Singleton);

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

            container.Register<IConnectionInformation>(() => new SqlConnectionInformation(queue, connection), LifeStyles.Singleton);
            container.Register<ICorrelationIdFactory, PostgreSqlMessageQueueCorrelationIdFactory>(
                LifeStyles.Singleton);

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

            container.Register<TableNameHelper>(LifeStyles.Singleton);
            container.Register<SqlHeaders>(LifeStyles.Singleton);

            container.Register<ThreadSafeRandom>(LifeStyles.Singleton);
            container.Register<IClearExpiredMessages, PostgreSqlMessageQueueClearExpiredMessages>(LifeStyles.Singleton);
            //**all

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


            //**receive
            container.Register<IReceiveMessages, PostgreSqlMessageQueueReceive>(LifeStyles.Transient);
            container.Register<IConnectionFactory, ConnectionFactory>(LifeStyles.Singleton);
            container.Register<CommitMessage>(LifeStyles.Transient);
            container.Register<RollbackMessage>(LifeStyles.Transient);
            container.Register<HandleMessage>(LifeStyles.Transient);
            container.Register<ReceiveMessage>(LifeStyles.Transient);

            container.Register<IResetHeartBeat, PostgreSqlMessageQueueResetHeartBeat>(LifeStyles.Singleton);
            container.Register<ISendHeartBeat, PostgreSqlMessageQueueSendHeartBeat>(LifeStyles.Singleton);
            container.Register<IReceiveMessagesFactory, ReceiveMessagesFactory>(LifeStyles.Singleton);
            container.Register<IReceivePoisonMessage, PostgreSqlQueueReceivePoisonMessage>(LifeStyles.Singleton);
            container.Register<IReceiveMessagesError, PostgreSqlMessageQueueReceiveErrorMessage>(LifeStyles.Singleton);
            //**receive

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

            //commands and decorators
            // Go look in all assemblies and register all implementations
            // of ICommandHandlerWithOutput<T> by their closed interface:
            container.Register(typeof (ICommandHandlerWithOutput<,>), LifeStyles.Singleton,
                target);

            //commands and decorators
            // Go look in all assemblies and register all implementations
            // of ICommandHandlerWithOutputAsync<T> by their closed interface:
            container.Register(typeof(ICommandHandlerWithOutputAsync<,>), LifeStyles.Singleton,
                target);

            // Go look in all assemblies and register all implementations
            // of ICommandHandler<T> by their closed interface:
            container.Register(typeof (ICommandHandler<>), LifeStyles.Singleton,
                target);

            // Go look in all assemblies and register all implementations
            // of IQueryHandler<T> by their closed interface:
            container.Register(typeof (IQueryHandler<,>), LifeStyles.Singleton,
                target);

            container.RegisterDecorator(typeof (ICommandHandlerWithOutput<,>),
                typeof (RetryCommandHandlerOutputDecorator<,>), LifeStyles.Singleton);

            container.RegisterDecorator(typeof(ICommandHandler<>),
                typeof(RetryCommandHandlerDecorator<>), LifeStyles.Singleton);

            container.RegisterDecorator(typeof(ICommandHandlerWithOutputAsync<,>),
                typeof(RetryCommandHandlerOutputDecoratorAsync<,>), LifeStyles.Singleton);

            container.RegisterDecorator(typeof(IQueryHandler<,>),
               typeof(RetryQueryHandlerDecorator<,>), LifeStyles.Singleton);
//.........这里部分代码省略.........

 /// <summary>
 /// Registers the logger decorators.
 /// </summary>
 /// <param name="container">The container.</param>
 private static void RegisterLoggerDecorators(IContainer container)
 {
     container.RegisterDecorator<IAbortWorkerThread, AbortWorkerThreadDecorator>(LifeStyles.Singleton);
     container.RegisterDecorator<IRollbackMessage, RollbackMessageDecorator>(LifeStyles.Singleton);
     container.RegisterDecorator<IClearExpiredMessages, Logging.Decorator.ClearExpiredMessagesDecorator>(LifeStyles.Singleton);
     container.RegisterDecorator<IResetHeartBeat, Logging.Decorator.ResetHeartBeatDecorator>(LifeStyles.Singleton);
     container.RegisterDecorator<IReceivePoisonMessage, Logging.Decorator.ReceivePoisonMessageDecorator>(LifeStyles.Singleton);
 }

        /// <summary>
        /// Registers the decorator metrics.
        /// </summary>
        /// <param name="container">The container.</param>
        private static void RegisterMetricDecorators(IContainer container)
        {
            //common decorators for metrics
            container.RegisterDecorator<ISerializer, SerializerDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IQueueCreation, QueueCreationDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IMessageHandler, MessageHandlerDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IMessageHandlerAsync, MessageHandlerAsyncDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IResetHeartBeat, ResetHeartBeatDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IInternalSerializer, InternalSerializerDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<ISendHeartBeat, SendHeartBeatDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<ISendMessages, SendMessagesDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IReceiveMessages, ReceiveMessagesDecorator>(LifeStyles.Transient);
            container.RegisterDecorator<IReceiveMessagesError, ReceiveMessagesErrorDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IReceivePoisonMessage, ReceivePoisonMessageDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<ICommitMessage, CommitMessageDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IRollbackMessage, RollbackMessageDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IClearExpiredMessages, ClearExpiredMessagesDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IExpressionSerializer, ExpressionSerializerDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<IMessageMethodHandling, MessageMethodHandlingDecorator>(LifeStyles.Singleton);
            container.RegisterDecorator<ILinqCompiler, LinqCompilerDecorator>(LifeStyles.Singleton);

            //while this is registered as transient, it ends up being a singleton because the interceptor host is a singleton
            container.RegisterDecorator<IMessageInterceptor, MessageInterceptorDecorator>(LifeStyles.Transient);
        }

        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);
        }