C# Container.RegisterConditional方法代码示例

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

            ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;

            container.RegisterSingleton<IValidatorFactory, SimpleInjectorValidatorFactory>();
            container.RegisterSingleton<IProcessValidation, ValidationProcessor>();

            container.Register(typeof(IValidator<>), settings.FluentValidationAssemblies);

            // Add unregistered type resolution for objects missing an IValidator<T>
            container.RegisterConditional(typeof(IValidator<>), typeof(ValidateNothingDecorator<>), Lifestyle.Singleton, context => !context.Handled);
        }

        public static void ConfigureGenerics(Container container)
        {
            container.Register(typeof(DataProvider<>),
                new[] { typeof(DataProvider<>).Assembly }, Lifestyle.Singleton);
            container.Register(typeof(CommandHandler<,>), new[] { typeof(CommandHandler<,>).Assembly });
            container.Register(typeof(CommandHandler<>), new[] { typeof(CommandHandler<>).Assembly });

            var commandHandlerTypes = container.GetTypesToRegister(typeof(Command<>),
                new[] { typeof(Command<>).Assembly },
                    new TypesToRegisterOptions { IncludeGenericTypeDefinitions = true} );

            foreach (Type type in commandHandlerTypes.Where(t => t.IsGenericTypeDefinition))
            {
                container.RegisterConditional(typeof(Command<>), type, c => !c.Handled);
            }
        }

        public static Container GetInitializeContainer(
                  IAppBuilder app)
        {
            var container = new Container();
            container.Options.PropertySelectionBehavior = new ImportPropertySelectionBehavior(); // Enable ImportAttribute for property injection
 
            container.RegisterSingleton(app);

            container.Register<IFederationService, FederationService>(Lifestyle.Singleton);
            container.Register<IAppService, AppService>(Lifestyle.Transient);
 
            container.RegisterConditional(typeof(IRepository<>), typeof(Repository<>), c => !c.Handled);

            container.Register<ICheckPasswordService<AppMember>, LegacyCheckPasswordService<AppMember>>(Lifestyle.Transient);
 
            container.RegisterPerWebRequest<IDragonUserStore<AppMember>>(() =>
            {
                var dragonUserStores = new List<IDragonUserStore<AppMember>>
                {
                    new UserStore<AppMember>(new Repository<AppMember>(), null, new Repository<IdentityUserLogin>(),
                        new Repository<IdentityUserService>(), new Repository<IdentityUserApp>())
                };
                if (WebConfigurationManager.ConnectionStrings[RedisConnectionStringName] != null)
                {
                    var connectionMultiplexer = ConnectionMultiplexer.Connect(WebConfigurationManager.ConnectionStrings[RedisConnectionStringName].ConnectionString);
                    connectionMultiplexer.PreserveAsyncOrder = false;
                    dragonUserStores.Insert(0, new Identity.Redis.UserStore<AppMember>(new RedisUserStore<Identity.Redis.IdentityUser>(connectionMultiplexer), connectionMultiplexer));
                }
                var userStore = new ChainedIdentity.Stores.UserStore<AppMember>(dragonUserStores);
                Startup.OpenIdMigrationWebrequestHandler = new OpenIdMigrationWebRequestHandler(userStore);
                return userStore;
            });

            container.Register<IUserService, UserService>(Lifestyle.Transient);

            container.RegisterPerWebRequest(() => ApplicationUserManager.Create(container, Startup.DataProtectionProvider));

            container.RegisterPerWebRequest(() => container.GetOwinContext().Authentication);

            container.RegisterMvcControllers(
                    Assembly.GetExecutingAssembly());
            
            return container;
        }

        public static Container GetInitializeContainer(
                  IAppBuilder app)
        {
            var container = new Container();
 
            container.RegisterSingleton(app);
 
            container.RegisterConditional(typeof(IRepository<>), typeof(Repository<>), c => !c.Handled);
 
            container.RegisterPerWebRequest<IDragonUserStore<AppMember>>(() =>
                new Dragon.SecurityServer.ChainedIdentity.Stores.UserStore<AppMember>(new List<IDragonUserStore<AppMember>>{
                    new UserStore<AppMember>(new Repository<AppMember>(), new Repository<IdentityUserClaim>(), new Repository<IdentityUserLogin>(), null, null)
                }));
 
            container.RegisterPerWebRequest(() => ApplicationUserManager.Create(container));

            container.RegisterPerWebRequest(() => container.GetOwinContext().Authentication);

            container.RegisterMvcControllers(
                    Assembly.GetExecutingAssembly());
            
            return container;
        }

        /// <summary>
        /// Registers all dependencies with the application's container.
        /// </summary>
        /// <param name="container"></param>
        private static void RegisterDependencies(Container container)
        {
            container.Register<IAmikiriConfigurationProvider, AmikiriConfigurationProvider>(Lifestyle.Scoped);
            container.RegisterConditional(
                typeof(ILogger),
                context => typeof(LoggerWrapper<>).MakeGenericType(context.Consumer.ImplementationType),
                Lifestyle.Singleton,
                _ => true);

            ConfigureDelegatingHandlers(container);
            ConfigureAutoMapper(container);
            ConfigureRavenDb(container);
            ConfigureMediatr(container);
            ConfigureFluentValidator(container);
            ConfigureCorsProviders(container);
            ConfigureAspNetIdentity(container);
        }