C# Container.RegisterCollection方法代码示例

        public static void RegisterServices(Container container, ILoggerFactory loggerFactory) {
            container.RegisterSingleton<ILoggerFactory>(loggerFactory);
            container.RegisterSingleton(typeof(ILogger<>), typeof(Logger<>));

            ServiceProvider.Current = container;
            container.RegisterSingleton<ISerializer>(() => new JsonNetSerializer());

            var metricsClient = new InMemoryMetricsClient();
            container.RegisterSingleton<IMetricsClient>(metricsClient);
            container.RegisterSingleton<ICacheClient, InMemoryCacheClient>();

            container.RegisterCollection(typeof(IQueueBehavior<ValuesPost>), new[] {
                Lifestyle.Singleton.CreateRegistration(
                    () => new MetricsQueueBehavior<ValuesPost>(metricsClient), container)
            });
            container.RegisterSingleton<IQueue<ValuesPost>>(() => new InMemoryQueue<ValuesPost>(behaviors: container.GetAllInstances<IQueueBehavior<ValuesPost>>()));
            
            container.RegisterCollection(typeof(IQueueBehavior<WorkItemData>), new[] {
                Lifestyle.Singleton.CreateRegistration(
                    () => new MetricsQueueBehavior<WorkItemData>(metricsClient), container)
            });

            var handlers = new WorkItemHandlers();
            handlers.Register<DeleteValueWorkItem, DeleteValueWorkItemHandler>();
            container.RegisterSingleton(handlers);

            container.RegisterSingleton<IQueue<WorkItemData>>(() => new InMemoryQueue<WorkItemData>(behaviors: container.GetAllInstances<IQueueBehavior<WorkItemData>>(), workItemTimeout: TimeSpan.FromHours(1)));
            
            container.RegisterSingleton<IMessageBus, InMemoryMessageBus>();
            container.RegisterSingleton<IMessagePublisher>(container.GetInstance<IMessageBus>);
            container.RegisterSingleton<IMessageSubscriber>(container.GetInstance<IMessageBus>);

            container.RegisterSingleton<ILockProvider, CacheLockProvider>();
            container.RegisterSingleton<IFileStorage>(new InMemoryFileStorage());
        }

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

        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 Container Create(ApplicationBootstrapConfig config)
        {
            var container = new Container();
            container.Options.AllowOverridingRegistrations = true;
            container.Register<IServiceProvider>(() => container);

            container.RegisterMediator(config.Assemblies.ToArray());
            container.Register<ITaskRepository, EfTaskRepository>();
            container.Register<IUnitOfWork>(() => new UnitOfWork(new MyAppContext().AsCommandContext()), config.UnitOfWorkLifestyle);
            container.Register<IQueryContext>(() => new QueryContext(new MyAppContext().AsQueryContext()), config.UnitOfWorkLifestyle);
            container.RegisterSingleton<IConnectionProvider, ConnectionProvider>();
            container.RegisterCollection(typeof(IValidator<>), config.Assemblies);

            var commandDecorators = new List<Type>
            {
                typeof(UnitOfWorkHandler<,>),
                typeof(TransactionHandler<,>),
                typeof(ValidatorHandler<,>),
                typeof(LogHandler<,>)
            };

            container.RegisterRequestHandlerDecorators(GetCommandDecorators(), context =>
            {
                var argument = context.ServiceType.GetGenericArguments()[0];
                return argument.Namespace.EndsWith("Commands");
            });

            container.RegisterRequestHandlerDecorators(GetQueryDecorators(), context =>
            {
                var argument = context.ServiceType.GetGenericArguments()[0];
                return argument.Namespace.EndsWith("Queries");
            });

            return container;
        }

        public static void Register(Container container)
        {
            container.Register(typeof (IQueryHandler<,>), new[] {typeof (IQueryHandler<,>).Assembly});
            container.Register(typeof (ICommandHandler<,>), new[] {typeof (ICommandHandler<,>).Assembly});

            container.RegisterCollection(typeof (IHyperMediaState), typeof (IHyperMediaState).Assembly);
            container.Register<IBoardState, BoardState>();
            container.Register<IBoardTaskState, BoardTaskState>();
            container.Register<IBoardColumnState, BoardColumnState>();

            container.Register<ISlugService, SlugService>();

            container.Register<ICommandDispatcher, CommandDispatcher>();
            container.Register<IQueryDispatcher, QueryDispatcher>();
            container.Register<ILinkFactory, LinkFactory>();
            container.Register<IHyperMediaFactory, HyperMediaFactory>();
            container.Register<IMappingService, MappingService>();

            container.RegisterWebApiRequest<IDataContext, DataContext>();

            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
            container.EnableHttpRequestMessageTracking(GlobalConfiguration.Configuration);
            container.RegisterSingleton<IRequestMessageProvider>(new RequestMessageProvider(container));

            container.Register<IValidator<Board>, BoardValidator>();
            container.Register<IValidator<BoardColumn>, BoardColumnValidator>();
            container.Register<IValidator<BoardTask>, BoardTaskValidator>();

            container.Verify();

            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
        }

        static void Main(string[] args)
        {
            var container = new Container();
            RegisterInfrastructure(container);
            var assemblies = GetAssemblies().ToArray();
            container.RegisterSingleton<IMediator, Mediator>();
            container.RegisterSingleton(new SingleInstanceFactory(container.GetInstance));
            container.RegisterSingleton(new MultiInstanceFactory(container.GetAllInstances));
            container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);
            container.Verify();

            var mediator = container.GetInstance<IMediator>();
            var commandsDbContext = container.GetInstance<ICommandsDbContext>();

            Console.Write("creating users...");
            Task.WaitAll(CreateUsersAsync(commandsDbContext, mediator));
            Console.WriteLine("done!");

            Console.Write("creating areas...");
            Task.WaitAll(CreateAreasAsync(commandsDbContext, mediator));
            Console.WriteLine("done!");

            Console.Write("creating ideas...");
            Task.WaitAll(CreateIdeasAsync(commandsDbContext, mediator));
            Console.WriteLine("done!");

            Console.Write("creating idea comments...");
            Task.WaitAll(CreateIdeaCommentsAsync(commandsDbContext, mediator));
            Console.WriteLine("done!");

            Console.WriteLine("Feeding complete!");
            Console.ReadLine();
        }

        private void PopulateProviderCache()
        {
            if (this.Providers == null)
            {
                this.Providers = new Dictionary<string, IAuditDbProvider>();
            }

            string providerDirectory = AppDomain.CurrentDomain.BaseDirectory;

            var providerAssemblies =
                from file in new DirectoryInfo(providerDirectory).GetFiles()
                where file.Extension.ToLower() == ".dll"
                select Assembly.LoadFile(file.FullName);

            Container container = new Container();

            var providerTypes = container.GetTypesToRegister(typeof(IAuditDbProvider), providerAssemblies);

            container.RegisterCollection<IAuditDbProvider>(providerTypes);

            foreach (var provider in container.GetAllInstances<IAuditDbProvider>())
            {
                Providers.Add(provider.ProviderNamespace.ToLowerInvariant(),provider);
            }
        }

        internal static Container BuildMediator()
        {
            var container = new Container();
            var assemblies = GetAssemblies().ToArray();
            container.RegisterSingleton<IMediator, Mediator>();
            container.Register(typeof(IRequestHandler<,>), assemblies);
            container.Register(typeof(IAsyncRequestHandler<,>), assemblies);
            container.RegisterCollection(typeof(INotificationHandler<>), assemblies);
            container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);
            container.RegisterSingleton(Console.Out);
            container.RegisterSingleton(new SingleInstanceFactory(container.GetInstance));
            container.RegisterSingleton(new MultiInstanceFactory(container.GetAllInstances));

            container.Verify();

            return container;
        }

        public static void Setup()
        {
            var container = new Container();
            var perRequest = new WebRequestLifestyle();
            var dataAccessAssembly = typeof(CinemaContext).Assembly;
            var moviesAssembly = typeof(Seat).Assembly;
            var promotionsAssembly = typeof(Promotions.Promotion).Assembly;
            var applicationAssembly = typeof(RenamePromotionCommand).Assembly;
            var connectionString = ConfigurationManager.ConnectionStrings["DDDCinema"].ConnectionString;

            container.Register(() => new CinemaContext(connectionString), perRequest);
            container.Register(() => new PromotionsContext(connectionString), perRequest);
            container.Register(() => new InfrastructureContext(connectionString), perRequest);
            container.Register(() => new DDDCinemaReadonly(), perRequest);
            var userProviderRegistration = Lifestyle.Singleton.CreateRegistration<ContextUserProvider>(container);
            container.AddRegistration(typeof(ICurrentUserProvider), userProviderRegistration);
            container.AddRegistration(typeof(ContextUserProvider), userProviderRegistration);
            container.Register<IWinChanceCalculatorFactory, SimpleInjectorWinChanceCalculatorFactory>(Lifestyle.Singleton);

            foreach (var repositorType in dataAccessAssembly.GetExportedTypes()
                .Where(t => t.Name.Contains("Repository")))
            {
                container.Register(repositorType.GetInterfaces().Single(), repositorType, perRequest);
            }

            container.RegisterDecorator(typeof(ICommandHandler<LoginCommand>), typeof(AuditingLoginCommandHandler));
            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(AuditingCommandHandler<>),
                p => !p.AppliedDecorators.Any(t => t.Name.Contains("Auditing")));
            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(CinemaTransactionalCommandHandler<>));
            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(PromotionTransactionalCommandHandler<>));
            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(InfrastructureTransactionalCommandHandler<>));
            container.Register(typeof(ICommandHandler<>), new[] { applicationAssembly });

            container.RegisterCollection(typeof(INotificationSender), new[] { moviesAssembly });
            var registration = perRequest.CreateRegistration<SendNotificationWhenSeatTaken>(container);
            container.AppendToCollection(typeof(IDomainEventHandler<>), typeof(AuditOccurrenceEventHandler<>));
            container.RegisterCollection(typeof(IDomainEventHandler<>), moviesAssembly, promotionsAssembly);
            container.RegisterDecorator(typeof(IDomainEventHandler<>), typeof(AuditingEventHandler<>),
                p => !p.ImplementationType.Name.Contains("Audit"));

            container.Register<List<INotificationSender>>(() => container.GetAllInstances<INotificationSender>().ToList(), perRequest);
            container.Register<ISheduler, SagaTimeoutSheduler>(perRequest);
            container.Register<IPromotionCodeGenerator, PromoCodeGenerator>(perRequest);
            DomainEventBus.Current = new SimpleInjectorEventBus(container);
            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
        }

        private static Container Bootstrap()
        {
            var container = new Container();

            container.RegisterSingleton<Jira.REST.Jira>();

            container.RegisterSingleton<MainWindow>();
            container.RegisterSingleton<MainWindowViewModel>();

            container.RegisterSingleton<LoginViewModel>();
            container.RegisterSingleton<ProjectViewModel>();

            container.RegisterSingleton<ScreenViewModel>();

            container.RegisterCollection<IPresentationViewModel>(
                new[] {
                    typeof(LoginViewModel),
                    typeof(ProjectViewModel)
                }
            );

            container.RegisterSingleton<ILoginView, LoginView>();
            container.RegisterSingleton<IProjectView, ProjectView>();

            // Register your windows and view models:
            //container.RegisterSingle<MainWindow>();
            //container.RegisterSingle<MainWindowViewModel>();
            //container.RegisterSingle<StatusViewModel>();

            //container.RegisterSingle<TravelTabDbContext>(() => new TravelTabDbContext());

            //container.Register<ITimeZoneManager, TimeZoneManager>();
            //container.Register<ITimeZoneStrategy, GoogleTimeZoneStrategy>();

            //container.Register<ICoordinatesStrategy, GoogleCoordinatesStrategy>();
            //container.Register<ICoordinatesManager, CoordinatesManager>();

            //container.RegisterAll<ICommerceCategoriesStrategy>(typeof(ViatorCommerceCategoriesStrategy), typeof(TravelTabCommerceCategoriesStrategy));

            //container.Register<ICommerceCategoriesManager, CommerceCategoriesManager>();

            //container.RegisterSingle<ICommerceRankingStrategy, ViatorCommerceRankingStrategy>();
            //container.Register<ICommerceRankingManager, CommerceRankingManager>();

            //container.Register<IViatorService>(() => ViatorService.Factory());

            //var allUpdateTasks = AppDomain.CurrentDomain.GetAssemblies()
            //											.SelectMany(x => x.GetTypes())
            //											.Where(mytype => mytype.GetInterfaces()
            //																	.Contains(typeof(IUpdateTask)) &&
            //																	mytype.Name != "UpdateTask");

            //container.RegisterAll<IUpdateTask>(allUpdateTasks);

            container.Verify();

            return container;
        }

 private static void IocSetup(Container container)
 {
     var assemblies = GetAssemblies().ToArray();
     
     container.RegisterSingleton<IMediator, Mediator>();
     container.RegisterSingleton<ILog, Log>();
     container.Register(typeof(IQueryHandler<,>), assemblies);
     container.RegisterCollection(typeof(IQueryHandler<,>), assemblies);
     container.RegisterSingleton(typeof(DbContext), new DbEntities());
 }

        public void Configuration(IAppBuilder app)
        {
            var mapperConfig = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile<FieldProfile>();
                cfg.AddProfile<ArchiveProfile>();
                cfg.AddProfile<RecordProfile>();
                cfg.AddProfile<SectionProfile>();
                cfg.AddProfile<BatchProfile>();
                cfg.AddProfile<CollectionProfile>();
                cfg.AddProfile<OptionProfile>();
            });
            var container = new Container();
            container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();
            container.Register<IAPContext>(Lifestyle.Scoped);
            container.RegisterSingleton(mapperConfig.CreateMapper());
            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

            // MEDIATR ---------------------------------------------------------------------
            var assemblies = GetAssemblies().ToArray();
            container.RegisterSingleton<IMediator, Mediator>();
            container.Register(typeof(IRequestHandler<,>), assemblies);
            container.Register(typeof(IAsyncRequestHandler<,>), assemblies);
            container.RegisterCollection(typeof(INotificationHandler<>), assemblies);
            container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);
            container.RegisterSingleton(Console.Out);
            container.RegisterSingleton(new SingleInstanceFactory(container.GetInstance));
            container.RegisterSingleton(new MultiInstanceFactory(container.GetAllInstances));
            // ------------------------------------------------------------------------------

            container.Verify();
            GlobalConfiguration.Configuration.DependencyResolver =
                new SimpleInjectorWebApiDependencyResolver(container);

            HttpConfiguration config = new HttpConfiguration()
            {
                DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container)
            };
            ConfigureOAuth(app);
            WebApiConfig.Register(config);
            app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
            app.UseWebApi(config);
        }

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

        public static void ConfigureRemarks(Container container)
        {
            var assembly = typeof(ClaimedRemark).Assembly;

            var types = from type in assembly.GetTypes()
                        where (typeof(Remark).IsAssignableFrom(type))
                        where type.IsClass
                        select type;

            if (!types.Any()) return;

            container.RegisterCollection(typeof(Remark), types);
        }

        static Container Bootstrap()
        {
            Container container = new Container();
            container.RegisterCollection(typeof(IAdapter), new[] { typeof(IAdapter).Assembly });
            Settings settings = new Settings();
            settings.ConnectionString = ConfigurationManager.ConnectionStrings["AdventureWorks2014"].ConnectionString;

            container.RegisterSingleton<Settings>(settings);
            container.Register<PerformaceTester>(Lifestyle.Transient);

            container.Verify();

            return container;
        }