C# Container.RegisterManyForOpenGeneric方法代码示例

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

        private void SetupIoc()
        {
            container = new Container();
            container.Register<ICommandHandlerDisptcher, CommandHandlerDisptcher>();
            container.Register<IQueryHandlerDispatcher, QueryHandlerDispatcher>();

            container.RegisterManyForOpenGeneric(typeof(IQueryHandlerAsync<,>), typeof(GetQuestionnaireQueryHandler).Assembly);
            container.RegisterManyForOpenGeneric(typeof(ICommandHandlerAsync<,>), typeof(CreateAnswersCommandHandler).Assembly);

            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
            container.RegisterMvcControllers();

            container.Verify();

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

 public void Execute_InvokesQueryHandler_UsingContainerForResolution()
 {
     var container = new Container();
     container.RegisterSingle<IProcessQueries, QueryProcessor>();
     container.RegisterManyForOpenGeneric(typeof(IHandleQuery<,>), Assembly.GetExecutingAssembly());
     container.Verify();
     var queries = container.GetInstance<IProcessQueries>();
     var result = queries.Execute(new FakeQueryWithoutValidator());
     result.ShouldEqual("faked");
 }

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

            container.Register<A, AImpl>();
            container.RegisterManyForOpenGeneric(typeof(B<>), typeof(A).Assembly);
            container.RegisterManyForOpenGeneric(typeof(C<,>), ((t, impls) =>
            {
                foreach (var impl in impls.Where(impl => !impl.IsAbstract))
                {
                    container.Register(impl);
                }
            }), typeof(A).Assembly);
            container.RegisterManyForOpenGeneric(typeof(D<>), typeof(A).Assembly);
            container.RegisterManyForOpenGeneric(typeof(E<,>), typeof(A).Assembly);
            container.RegisterManyForOpenGeneric(typeof(F<,>), typeof(A).Assembly);
            AllowToResolveVariantCollections(container);

            ServiceLocator = new SimpleInjectorServiceLocatorAdapter(container);
        }

 public void ValidateQuery_InvokesValidator_UsingContainerForResolution()
 {
     var container = new Container();
     container.RegisterSingle<IProcessValidation, ValidationProcessor>();
     container.RegisterManyForOpenGeneric(typeof(IValidator<>), Assembly.GetExecutingAssembly());
     container.Verify();
     var validation = container.GetInstance<IProcessValidation>();
     var result = validation.Validate(new FakeQueryWithValidator { InputValue = null });
     result.IsValid.ShouldBeFalse();
     result.Errors.Count.ShouldEqual(1);
 }

        public void Execute_InvokesCommandHandler_UsingContainerForResolution()
        {
            var container = new Container();
            container.RegisterSingle<IProcessCommands, CommandProcessor>();
            container.RegisterManyForOpenGeneric(typeof(IHandleCommand<>), Assembly.GetExecutingAssembly());
            container.Verify();
            var commands = container.GetInstance<IProcessCommands>();
            var command = new FakeCommandWithoutValidator();

            commands.Execute(command);

            command.ReturnValue.ShouldEqual("faked");
        }

        public static void Register(HttpConfiguration config)
        {
            var container = new Container();
            var webapiLifestyle = new WebApiRequestLifestyle();
            container.RegisterWebApiRequest<ITransactionEngine, TransactionEngine>();

            BuildManager.GetReferencedAssemblies();
            AppDomain currentDomain = AppDomain.CurrentDomain;

            container.RegisterManyForOpenGeneric(typeof(IQueryHandler<,>), webapiLifestyle, currentDomain.GetAssemblies());
            container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), webapiLifestyle, currentDomain.GetAssemblies());

            // Veroorzaakt een StackOverFlowException bij opvragen:
            container.RegisterOpenGeneric(typeof(ICommandHandler<>), typeof(UpdateFeaturesCommandHandler<,>), webapiLifestyle,
                c => !c.Handled);

            container.RegisterSingle<ITransactionalCommandHandlerFactory>(new TransactionalCommandHandlerFactory(container));

            container.RegisterWebApiControllers(config);
            container.Verify();

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

        /// <summary>
        /// Initializes the container.
        /// </summary>
        /// <param name="container">The container.</param>
        private static void InitializeContainer(Container container)
        {
            container.RegisterPerWebRequest<IRepository, DatabaseContext>();
            container.RegisterSingle<IMessageService, EmailMessageService>();

            container.Register<ICommandHandler<DeleteCommand<BlogEntryComment>>, DeleteCommandHandler<BlogEntryComment>>();
            container.Register<ICommandHandler<UpdateCommand<BlogEntry>>, UpdateCommandHandler<BlogEntry>>();
            container.Register<ICommandHandler<UpdateCommand<BlogEntryFile>>, UpdateCommandHandler<BlogEntryFile>>();

            container.RegisterManyForOpenGeneric(
                typeof(ICommandHandler<>),
                typeof(ICommandHandler<>).Assembly);

            container.RegisterDecorator(
                typeof(ICommandHandler<>),
                typeof(CommandLoggingDecorator<>));
        }

        private static void InitializeContainer(Container container)
        {
            // Pre-requisites:
            container.RegisterSingle<ILogger, EmptyLogger>();
            container.RegisterSingle<ITextKeyFactory, DefaultTextKeyFactory>();
            container.RegisterSingle<ITypeNameFactory, DefaultTypeNameFactory>();

            // Xml file repository:
            var translationsPath = HttpContext.Current.Server.MapPath("~/App_Data/translations.xml");
            container.RegisterSingle<ILocalizedRepository>(() => new XmlFileRepository(translationsPath));

            var fallbackCulture = CultureInfo.GetCultureInfo("en-US");

            // View localization:
            container.RegisterSingle<IViewNameFactory, DefaultViewNameFactory>();
            container.RegisterSingle<ILocalizedStringProvider>(
                () =>
                new DefaultLocalizedStringProvider(
                    // provider used for views and legacy classes localization
                    container.GetInstance<ILocalizedRepository>(),
                    container.GetInstance<ITextKeyFactory>(),
                    container.GetInstance<ILogger>(),
                    CultureInfo.GetCultureInfo("fr-FR"), // native text is in french...
                    fallbackCulture,
                    DefaultMissingLocalizedStringExtensionPoint.Instance
                    ));

            // Legacy class localization:
            container.RegisterManyForOpenGeneric(typeof(StringProvider<>), typeof(StringProvider<>).Assembly);

            // Model metadata localization:
            container.RegisterSingle<Localization.MvcProviders.ModelMetadataProvider>(() => new Localization.MvcProviders.ModelMetadataProvider(
                                                                           new DefaultLocalizedStringProvider(
                                                                               container.GetInstance<ILocalizedRepository>(),
                                                                               container.GetInstance<ITextKeyFactory>(),
                                                                               container.GetInstance<ILogger>(),
                                                                               CultureInfo.GetCultureInfo("en-US"), // Names of model properties are in english...
                                                                               fallbackCulture,
                                                                               DefaultMissingLocalizedStringExtensionPoint.Instance),
                                                                            container.GetInstance<ITypeNameFactory>(),
                                                                            container.GetInstance<ILogger>()));
        }

        /// <summary>Initialize the container and register it as MVC3 Dependency Resolver.</summary>
        public static void Initialize()
        {
            // Did you know the container can diagnose your configuration? Go to: https://bit.ly/YE8OJj.
            var container = new Container();
            
            InitializeContainer(container);

            // Register controllers
            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

            // Register validators
            container.RegisterManyForOpenGeneric(typeof(IValidator<>), typeof(OrderValidator).Assembly);

            // Verify registrations
            container.Verify();

            // Set validator factory
            FluentValidationModelValidatorProvider.Configure(GlobalConfiguration.Configuration,
                provider => provider.ValidatorFactory = new FluentValidatorFactory(container));

            // Set dependency resolver
            GlobalConfiguration.Configuration.DependencyResolver =
                new SimpleInjectorWebApiDependencyResolver(container);
        }

        static void Main()
        {
            var container = new Container();
            container.Register<IUserRepository, InMemoryUserRepository>();
            container.Register<ILogger, ConsoleLogger>();
            container.RegisterManyForOpenGeneric(typeof(IHandle<>), AppDomain.CurrentDomain.GetAssemblies());
            container.RegisterDecorator(typeof(IHandle<>), typeof(LoggingDecorator<>));

            var simpleInjectorServiceLocatorAdapter = new SimpleInjectorServiceLocatorAdapter(container);

            AppDispatcher.Initialize(app =>
            {
                // Decorating the pipline AND using IoC: you will see
                // the action pipleine below wraps any IoC decorators
                app.GlobalPipeline(pipeline => pipeline.Decorate(handler =>
                {
                    Console.WriteLine("before a");
                    handler();
                    Console.WriteLine("after a");
                }).Decorate(handler =>
                {
                    Console.WriteLine("before b");
                    handler();
                    Console.WriteLine("after b");
                }), true);

                app.UseCommonServiceLocator(simpleInjectorServiceLocatorAdapter);

            });

            var request = new CreateUser { Name = "Jane Smith" };

            AppDispatcher.Handle(request);

            Console.ReadLine();
        }

        public static Container Build()
        {
            var container = new Container();
            container.RegisterPerWebRequest<IDbContext>(() => new AppDbContext("AppDb"));
            container.RegisterPerWebRequest<ICurrentUser,FormsAuthenticationCurrentUser>();
            container.RegisterSingle<ICacheProvider,AppCacheProvider>();
            container.Register<ILogger,NLogLogger>();

            container.RegisterManyForOpenGeneric(typeof(IGridModelBuilder<,>), typeof(IGridModelBuilder<,>).Assembly);
            container.RegisterManyForOpenGeneric(typeof(IModelBuilder<>), typeof(IModelBuilder<>).Assembly);
            container.RegisterManyForOpenGeneric(typeof(IModelBuilder<,>), typeof(IModelBuilder<,>).Assembly);
            container.RegisterManyForOpenGeneric(typeof(IModelHandler<>), typeof(IModelHandler<>).Assembly);
            container.RegisterManyForOpenGeneric(typeof(IModelHandler<,>), typeof(IModelHandler<,>).Assembly);
            container.RegisterManyForOpenGeneric(typeof(IFileModelBuilder<>), typeof(IFileModelBuilder<>).Assembly);
            container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
            container.RegisterMvcIntegratedFilterProvider();

            container.Verify();
            return container;
        }

 public void RegisterServices(Container container)
 {
     container.RegisterManyForOpenGeneric(typeof(IActionFilter<>), container.RegisterAll, typeof(IActionFilter<>).Assembly);
 }

 private static void InitializeContainer(Container container)
 {
     container.RegisterSingle<IServiceProvider>(container);
     container.RegisterManyForOpenGeneric(typeof(IValidator<>), Assembly.GetExecutingAssembly());
 }

        public static void Bind(Container container)
        {
            //inject IPrincipal
            //            container.Register(() =>
            //            {
            //                if (HttpContext.Current == null || HttpContext.Current.User == null)
            //                    return (null as IPrincipal);
            //
            //                return HttpContext.Current.User;
            //            });

            //refer to assemblies containing handlers
            container.RegisterManyForOpenGeneric(typeof (IQueryHandler<,>), new[]
            {
                typeof (CreateContactCommand).Assembly
            });

            container.RegisterManyForOpenGeneric(typeof (ICommandHandler<>), new[]
            {
                typeof (CreateContactCommand).Assembly
            });

            //register repository implementations (you would do this by convention normally)
            container.RegisterWebApiRequest<ICreateAContact, ContactCreator>();

            container.RegisterWebApiRequest<IReadOnlyRepository>(() =>
            {
                //you may wish to get this from the container, but it could be in scope with a consumer that writes
                var context = new ContactAppEntities();
                context.Configuration.AutoDetectChangesEnabled = false;
                return new ReadOnlyRepository(context);
            });

            container.RegisterWebApiRequest<ContactAppEntities>();
            container.RegisterWebApiRequest<EfUnitOfWork>();
            container.Register<DbContext>(container.GetInstance<ContactAppEntities>);
            container.Register<IUnitOfWork>(container.GetInstance<EfUnitOfWork>);
            container.RegisterDecorator(typeof (ICommandHandler<>),
                typeof (EfUnitOfWorkTransactionCommandHandlerDecorator<>));
            container.RegisterDecorator(typeof (ICommandHandler<>), typeof (PostCommitCommandHandlerDecorator<>));

            container.RegisterWebApiRequest<PostCommitRegistrar>();
            container.Register<IPostCommitRegistrar>(container.GetInstance<PostCommitRegistrar>);

            //TODO auditing should log via a bus or separate asynchronous repository, not to a logger
            bool traceEnabled;
            bool.TryParse(ConfigurationManager.AppSettings["Audit:Enabled"], out traceEnabled);
            if (traceEnabled)
            {
                container.RegisterDecorator(typeof (ICommandHandler<>), typeof (CommandAuditor<>));
                container.RegisterDecorator(typeof (IQueryHandler<,>), typeof (QueryAuditor<,>));
            }
            //TODO no need, this is config based
            //            else
            //            {
            //                container.RegisterSingle<ILog, NullLogger>();
            //            }

            container.RegisterDecorator(typeof (IQueryHandler<,>), typeof (CacheablePerUserQueryHandler<,>));
            container.RegisterDecorator(typeof (ICommandHandler<>), typeof (CommandValidator<>));
            container.RegisterDecorator(typeof (IQueryHandler<,>), typeof (QueryValidator<,>));

            container.RegisterWebApiRequest<IMediator, WebApiMediator>();

            /* we are using data annotations for validation, so we must inform simple injector
             * to use this container when IServiceProvider is requested for validation */
            container.RegisterWebApiRequest<IServiceProvider>(() => container);
        }