C# Container.RegisterDecorator方法代码示例

        public void RegisterServices(Container container, CompositionRootSettings settings)
        {
            if (settings.ViewModelAssemblies == null) return;

            container.RegisterSingleton<IProcessViewModels, ViewModelProcessor>();

            container.Register(typeof(IHandleViewModel<>), settings.ViewModelAssemblies);
            container.Register(typeof(IHandleViewModel<,>), settings.ViewModelAssemblies);

            container.RegisterDecorator(
                typeof(IHandleViewModel<>),
                typeof(ViewModelLifetimeScopeDecorator<>),
                Lifestyle.Singleton
            );

            container.RegisterDecorator(
                typeof(IHandleViewModel<,>),
                typeof(ViewModelWithArgumentLifetimeScopeDecorator<,>),
                Lifestyle.Singleton
            );

            container.RegisterDecorator(
                 typeof(IHandleViewModel<,>),
                 typeof(ViewModelWithArgumentNotNullDecorator<,>),
                Lifestyle.Singleton
            );
        }

        public void RegisterServices(Container container, CompositionRootSettings settings)
        {
            if (settings.TransactionAssemblies == null) return;

            container.Register<IProcessQueries, QueryProcessor>(Lifestyle.Singleton);

            container.Register(typeof (IHandleQuery<,>), settings.TransactionAssemblies);

            container.RegisterDecorator(
                  typeof(IHandleQuery<,>),
                  typeof(QueryEventProcessingDecorator<,>),
                  c =>
                  {
                        var attribute = c.ImplementationType.GetCustomAttribute<RaiseEventAttribute>();
                        return attribute != null && attribute.Enabled;
                  }
            );

            container.RegisterDecorator(
                typeof (IHandleQuery<,>),
                typeof (ValidateQueryDecorator<,>)
                );

            container.RegisterDecorator(
                typeof (IHandleQuery<,>),
                typeof (QueryLifetimeScopeDecorator<,>),
                Lifestyle.Singleton
                );

            container.RegisterDecorator(
                typeof (IHandleQuery<,>),
                typeof (QueryNotNullDecorator<,>),
                Lifestyle.Singleton
                );
        }

        public static void RegisterDependencies()
        {
            var container = new Container {Options = {DefaultScopedLifestyle = new WebRequestLifestyle()}};

            // Container
            container.Register<IServiceProvider>(() => container);

            // Request (command/query) dispatcher
            container.Register<IRequestDispatcher, RequestDispatcher>();

            // Command handlers
            container.Register(typeof (ICommandHandler<>), new[] {typeof (TabService).Assembly});
            container.RegisterDecorator(typeof (ICommandHandler<>), typeof (ValidationDecoratorCommandHandler<>));
            container.RegisterDecorator(typeof (ICommandHandler<>), typeof (LoggingDecoratorCommandHandler<>));

            // Query handlers
            container.Register(typeof (IQueryHandler<,>), new[] {typeof (TabReadModel).Assembly});

            // Validators
            container.RegisterSingleton(typeof (IValidator<>), typeof (CompositeValidator<>));
            container.AppendToCollection(typeof (IValidator<>), typeof (DataAnnotationsValidator<>));
            container.RegisterCollection(typeof (IValidator<>), typeof (MvcApplication).Assembly);

            // Data annotations validators
            container.Register(typeof (IValidationAttributeValidator<>), new[] {typeof (IValidationAttributeValidator<>).Assembly});

            // Loggers
            container.RegisterSingleton<ILoggerFactory, NLogLoggerFactory>();

            // Action filters
            container.RegisterCollection(typeof (IActionFilter<>), typeof (MvcApplication).Assembly);

            // Repository
            container.Register<IEventStore, InMemoryEventStore>();

            // Aggregate factory
            container.Register<IAggregateFactory, AggregateFactory>();

            // Event publisher
            container.Register<IEventPublisher>(() => new EventPublisher(type => container.GetAllInstances(type), container.GetInstance<ILoggerFactory>()));

            // Event handlers
            container.RegisterCollection(typeof (IEventSubscriber<>), new[] {typeof (TabReadModel).Assembly});

            // View model database
            container.RegisterSingleton<IReadModelDatabase, InMemoryReadModelDatabase>();

            // Verify
            container.Verify();

            System.Web.Mvc.DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
            System.Web.Mvc.GlobalFilters.Filters.Add(new ActionFilterDispatcher(type => container.GetAllInstances(type)));
            ServiceProvider = container;
        }

        public static void Bootstrap(Container container)
        {
            if (container == null)
            {
                throw new ArgumentNullException("container");
            }

            container.RegisterSingle<IValidator>(new DataAnnotationsValidator(container));

            container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), Assembly.GetExecutingAssembly());
            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(ValidationCommandHandlerDecorator<>));
            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(AuthorizationCommandHandlerDecorator<>));

            container.RegisterManyForOpenGeneric(typeof(IQueryHandler<,>), Assembly.GetExecutingAssembly());
            container.RegisterDecorator(typeof(IQueryHandler<,>), typeof(AuthorizationQueryHandlerDecorator<,>));
        }

        public static Container Compose()
        {
            var container = new Container();

            container.Register(typeof(INetlinkServiceBusMessage), typeof(NetlinkPointNotificationMessage));
            container.Register(typeof(IServiceBusQueueNameFactory), typeof(QueueNameFactory));
            container.Register(typeof(IServiceBusConnectionStringFactory), typeof(ConnectionStringFactory));
            container.Register(
                typeof (
                    IServiceBusClient
                        <IServiceBusQueueNameFactory, IServiceBusConnectionStringFactory,
                            INetlinkServiceBusMessage>), typeof (AzureStorageQueueClient));

            container.Register(typeof(IRuleEngineFactory<>), typeof(BooleanRuleEngineFactory));
            container.Register(typeof(IRuleEngineFactory<>), typeof(IntegerRuleEngineFactory));
            container.Register(typeof(IRuleEngineFactory<>), typeof(DoubleRuleEngineFactory));
            container.RegisterCollection(typeof(IRuleExecutionResponse), AppDomain.CurrentDomain.GetAssemblies());
            container.RegisterCollection(typeof(IPreRuleHandler<>), AppDomain.CurrentDomain.GetAssemblies());
            container.RegisterCollection(typeof(IRuleHandler<,>), AppDomain.CurrentDomain.GetAssemblies());
            container.RegisterCollection(typeof(IPostRuleHandler<,>), AppDomain.CurrentDomain.GetAssemblies());
            container.RegisterCollection(typeof(IRuleExecutor), AppDomain.CurrentDomain.GetAssemblies());
            container.RegisterCollection(typeof(IRuleFactory<>), AppDomain.CurrentDomain.GetAssemblies());

            container.RegisterDecorator(typeof(IRuleHandler<,>), typeof(RuleMediatorPipeline<,>));

            container.Verify(VerificationOption.VerifyAndDiagnose);

            return container;
        }

        protected override void OnStart(string[] args)
        {
            _container = new Container();

            _container.RegisterSingleton<IAchievementPushService, AchievementPushService>();
            _container.RegisterSingleton<IAchievementService, AchievementService>();
            _container.RegisterSingleton<IActivityGroupingService, ActivityGroupingService>();
            _container.RegisterSingleton<IDatabaseService, DatabaseService>();
            _container.RegisterSingleton<IFitocracyService, FitocracyService>();
            _container.RegisterSingleton<IScrapingService, ScrapingService>();
            _container.RegisterSingleton<IUserPullService, UserPullService>();
            _container.RegisterSingleton<IWebRequestService, WebRequestService>();
            _container.RegisterSingleton<IWorkoutPullService, WorkoutPullService>();

            _container.RegisterCollection<IAchievementProvider>(
                GetType().Assembly.GetTypes()
                         .Where(typeof (IAchievementProvider).IsAssignableFrom)
                         .Where(type => type.IsClass));

            _container.RegisterDecorator<IWebRequestService, ThrottledWebRequestDecorator>(Lifestyle.Singleton);

            _container.Verify();

            _cancelSource = new CancellationTokenSource();
            _task = Task.Factory.StartNew(Run, _cancelSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
        }

        public static void Bootstrap(Container container)
        {
            if (container == null)
            {
                throw new ArgumentNullException(nameof(container));
            }

            container.RegisterSingleton<IValidator>(new DataAnnotationsValidator(container));
            
            container.Register(typeof(ICommandHandler<>), businessLayerAssemblies);
            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(ValidationCommandHandlerDecorator<>));
            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(AuthorizationCommandHandlerDecorator<>));

            container.Register(typeof(IQueryHandler<,>), businessLayerAssemblies);
            container.RegisterDecorator(typeof(IQueryHandler<,>), typeof(AuthorizationQueryHandlerDecorator<,>));
        }

        public RegisterDecoratorLifestyleNonGeneric()
        {
            var container = new Container();

            container.RegisterDecorator(typeof(ICommon), typeof(CommonImpl1),
                Lifestyle.CreateHybrid(() => true, Lifestyle.Transient, Lifestyle.Singleton));
        }

        public RegisterDecoratorLifestylePredicateNonGeneric()
        {
            var container = new Container();

            var custom = Lifestyle.CreateCustom("custom", transientInstanceCreator => () => transientInstanceCreator());

            container.RegisterDecorator(typeof(ICommon), typeof(CommonImpl1), custom, context => true);
        }

 public void RegisterServices(Container container)
 {
     container.Register(() => new SmtpClient(), Lifestyle.Singleton);
     container.Register<IDeliverEmail, DeliverEmail>(Lifestyle.Singleton);
     container.RegisterDecorator(
         typeof(IDeliverEmail),
         typeof(DeliverEmailAsynchronouslyProxyDecorator),
         Lifestyle.Singleton
     );
 }

 private static void InitializeContainer(Container container)
 {
     container.RegisterPerWebRequest<IDbConnection>(CreateConnection);
     container.RegisterSingle<Logger>();
     container.Register<IDbCommand>(() => new SqlCommand(string.Empty,container.GetInstance<IDbConnection>() as SqlConnection));
     container.RegisterPerWebRequest<IContactRepository, ContactRepository>();
     //container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), typeof(Contact).Assembly);
     container.RegisterPerWebRequest<ICommandHandler<CreateContactCommand>, CreateContactHandler>();
     container.RegisterDecorator(typeof (ICommandHandler<>), typeof (CommandAuditingHandler<>));
     container.Register<UnitOfWork>();
 }

        static void Main(string[] args)
        {
            var container = new Container();
            container.Register<ISomethingHandler, SimpleSomethingHandler>();
            container.RegisterDecorator(
                typeof(ISomethingHandler),
                typeof(DoSomethingHandler),
                ctx => ShouldDecorate(ctx.ServiceType));
            container.Verify();

            container.GetInstance<ISomethingHandler>().Handle();
        }

        public static void ConfigureMediator(Container container)
        {
            container.Register<IMediator>(() => new Mediator(container.GetInstance<Resolver>()));
            container.Register(() => Console.Out);
            container.Register<Resolver>(() => t => container.GetInstance(t));

            container.RegisterDecorator(
                typeof (CommandHandler<,>),
                typeof (ValidatorHandlerDecorator<,>));

            container.RegisterDecorator(
                typeof(CommandHandler<,>),
                typeof(TransactionHandlerDecorator<,>), c => c.ImplementationType.Namespace.Contains("Commands")
                );

            container.RegisterDecorator(
                typeof (CommandHandler<,>),
                typeof (AuditTrailHandlerDecorator<,>),
                d => d.ImplementationType.GetInterfaces().Contains(typeof(Auditable))
                );
        }

        public static Container Compose()
        {
            var container = new Container();

            // TODO: manual registration (one by one) not recommended
            container.Register<CustomerRepository, InMemoryCustomerRepository>();
            container.Register<Transactional, FakeTransactional>();

            container.Register(typeof(CommandHandler<>), new[] { typeof(CommandHandler<>).Assembly });
            container.RegisterDecorator(typeof(CommandHandler<>), typeof(TransactionalCommandHandler<>));

            return container;
        }

		static void Main(string[] args)
		{
			Container container = new Container();
			container.Register<ILogger, NerdAmigo.Abstractions.Default.DefaultLogger>(Lifestyle.Singleton);
			container.Register<IPathMapper, CliPathMapper>(Lifestyle.Singleton);
			container.Register(typeof(IConfigurationProvider<>), typeof(NerdAmigo.Common.Configuration.ConfigurationProvider<>), Lifestyle.Singleton);

			container.Register<IQueueIdentifierProvider, QueueIdentifierProvider>(Lifestyle.Singleton);
			container.Register(typeof(IQueueClient<>), typeof(SQSClient<>), Lifestyle.Singleton);
			container.Register(typeof(IQueueMessageWorker<>), new[] { System.Reflection.Assembly.GetExecutingAssembly() });
			container.Register(typeof(QueueMessageProcessor<>), new[] { System.Reflection.Assembly.GetExecutingAssembly() });

			container.RegisterDecorator(typeof(IQueueClient<>), typeof(QueueClientLogDecorator<>));

			container.Verify();
			
			IQueueClient<SampleMessage> queueClient = container.GetInstance<IQueueClient<SampleMessage>>();
			using (CancellationTokenSource cts = new CancellationTokenSource())
			{
				Task sender = Task.Factory.StartNew(() =>
				{
					int idx = 0;
					Random r = new Random();
					while (!cts.Token.IsCancellationRequested)
					{
						queueClient.Enqueue(new SampleMessage() { Name = DateTime.Now.ToShortTimeString(), Id = ++idx }, cts.Token);

						cts.Token.WaitHandle.WaitOne(TimeSpan.FromSeconds(r.Next(60)));
					}
				}, cts.Token);

				QueueMessageProcessor<SampleMessage> messageProcessor = container.GetInstance<QueueMessageProcessor<SampleMessage>>();
				messageProcessor.QueueMessageWorkerActivator = new SimpleInjectorQueueMessageWorkerActivator(container);
				messageProcessor.Begin(cts.Token);

				Console.ReadKey();
				cts.Cancel();

				try
				{
					sender.Wait();
				}
				catch (AggregateException ex)
				{
					foreach (Exception iEx in ex.InnerExceptions)
					{
						Console.WriteLine("Task Exception: " + iEx.Message);
					}
				}
			}
		}