C# Container.Register方法代码示例

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

 private static void RegisterDependencies(Container container)
 {
     container.Register<PlayerService, PlayerService>(Lifestyle.Scoped);
     container.Register<ConfigService, ConfigService>(Lifestyle.Scoped);
     container.Register<ClubService, ClubService>(Lifestyle.Scoped);
     container.Register<TeamService, TeamService>(Lifestyle.Scoped);
 }

        private static void ConfigureAspNetIdentity(Container container)
        {
            container.Register(
                typeof(IUserStore<Administrator>),
                () =>
                {
                    var session = container.GetInstance<IAsyncDocumentSession>();
                    session.Advanced.UseOptimisticConcurrency = true;
                    return new RavenUserStore<Administrator, RavenRole>(session);
                },
                Lifestyle.Scoped);

            container.Register(
                typeof(UserManager<Administrator>),
                () =>
                {
                    var manager = new UserManager<Administrator>(container.GetInstance<IUserStore<Administrator>>());
                    manager.UserValidator = new UserValidator<Administrator>(manager)
                    {
                        AllowOnlyAlphanumericUserNames = false,
                    };
                    return manager;
                },
                Lifestyle.Scoped);
        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            var ambientDbLocater = new AmbientDbContextLocator();

            var container = new Container();
            container.Options.DefaultScopedLifestyle = new LifetimeScopeLifestyle();

            container.Register<IAmbientDbContextLocator, AmbientDbContextLocator>(Lifestyle.Singleton);
            container.Register<IUnitOfWork>(() => new EFUnitOfWork(), Lifestyle.Scoped);

            container.Register<IUnitOfWorkFactory>(
                () => new EFUnitOfWorkFactory(System.Data.IsolationLevel.ReadUncommitted));

            container.Register<IClienteRepository, ClienteRepository>();
            container.Register<IClientesService, ClientesService>();

            container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
            container.RegisterMvcIntegratedFilterProvider();

            container.Verify();

            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
        }

 private static void SetupDataContext(Container container)
 {
     container.Register<ILibraryContext, LibraryContext>(Lifestyle.Singleton);
     container.Register<IBookRepository, BookRepository>(Lifestyle.Scoped);
     container.Register<IAuthorRepository, AuthorRepository>(Lifestyle.Scoped);
     container.Register<IBookAuthorRepository, BookAuthorRepository>(Lifestyle.Scoped);
 }

        public static void ConfigContainer(Container container)
        {
            #region - MAPPER -
            var mapperConfig = AutoMapperConfig.GetMapperConfiguration();
            container.RegisterSingleton<IConfigurationProvider>(mapperConfig);
            container.Register(() => mapperConfig.CreateMapper());
            container.Register<IMapperAdapter, AutoMapperAdapter>();
            #endregion

            #region - CONTEXTS -
            container.Register<DbContext, CoreContext>(Lifestyle.Scoped);
            #endregion

            #region - REPOSITORIES -
            container.Register<IClientRepository, ClientRepository>(Lifestyle.Scoped);
            container.Register<IRefreshTokenRepository, RefreshTokenRepository>(Lifestyle.Scoped);
            container.Register<IUsuarioRepository, UsuarioRepository>(Lifestyle.Scoped);
            #endregion

            #region - DOMAINS -
            var registration = Lifestyle.Scoped.CreateRegistration<UsuarioDomain>(container);
            container.AddRegistration(typeof(IUsuarioDomain), registration);
            container.AddRegistration(typeof(IUserStore<Usuario, long>), registration);

            container.Register<UserManager<Usuario, long>>(Lifestyle.Scoped);
            container.Register<IRefreshTokenDomain, RefreshTokenDomain>(Lifestyle.Scoped);
            container.Register<IClientDomain, ClientDomain>(Lifestyle.Scoped);
            container.Register<IAccountDomain, AccountDomain>(Lifestyle.Scoped);
            #endregion
        }

        public static void Register(Container container)
        {
            container.RegisterOpenGeneric(typeof(IRepository<>), typeof(Repository<>));

            // Single services
            container.Register<IContext, DefaultContext>();
            container.Register<ICommandPersister, DefaultCommandPersister>();
            container.Register<ICommandSerializer, NewtonsoftCommandSerializer>();
            //container.Register<ICommandSerializer, JilCommandSerializer>();

            AddInterfaceForEachDerivedType(container, typeof(TableBase), typeof(ITableBeforeSave<>));
            AddInterfaceForEachDerivedType(container, typeof(TableBase), typeof(ITableAfterSave<>));

            AddInterfaceForEachDerivedType(container, typeof(CommandBase), typeof(ICommandBeforeProcess<>));
            AddInterfaceForEachDerivedType(container, typeof(CommandBase), typeof(ICommandBeforeSave<>));
            AddInterfaceForEachDerivedType(container, typeof(CommandBase), typeof(ICommandAfterSave<>));

            // default persister
            container.RegisterOpenGeneric(typeof(ICommandSave<>), typeof(DefaultSaver<>));

            // override persisters
            container.Options.AllowOverridingRegistrations = true;

            //container.RegisterOpenGeneric(typeof(InsertCommandFor<>), typeof(SimpleCommandsDefaultSaver<>));
            //container.RegisterManyForOpenGeneric(typeof(ICommandSave<>), AppDomain.CurrentDomain.GetAssemblies());
            //container.RegisterManyForOpenGeneric(typeof(ICommandSave<>).MakeGenericType(typeof(InsertCommandFor<>)), AppDomain.CurrentDomain.GetAssemblies());
            /*
            ReplaceInterfaceForEachDerivedType(container, 
                typeof(SimpleCommand<>), 
                typeof(ICommandSave<>).MakeGenericType(typeof(InsertCommandFor<>))
                );*/

            //RegisterAllPersisters();

        }

 public static void Initialize(Container container, Lifestyle lifestyle)
 {
     container.Register<IProdutoRepository, ProdutoRepository>(lifestyle);
     container.Register<ICompraRepository, CompraRepository>(lifestyle);
     container.Register<ICompraItemRepository, CompraItemRepository>(lifestyle);
     container.Register<IFornecedorRepository, FornecedorRepository>(lifestyle);
 }

        /// <summary>
        /// 注册服务
        /// </summary>
        /// <param name="container">容器</param>
        /// <param name="containerWrapper">容器封装类</param>
        public static void RegisterService(Container container, IContainer containerWrapper)
        {
            //注册产品服务类
            container.Register<IProductService>(() =>
            {
                var productService = new ProductService();
                productService.Initialize(containerWrapper, ApplicationMediator.ProductDbSessionCached);
                return productService;
            });

            //注册订单服务类
            container.Register<IOrderService>(() =>
            {
                var orderService = new OrderService();
                orderService.Initialize(containerWrapper, ApplicationMediator.ProductDbSessionCached);
                return orderService;
            });

            //注册功能菜单服务类
            container.Register<IFunctionMenuService>(() =>
            {
                var functionService = new FunctionMenuService();
                functionService.Initialize(containerWrapper, ApplicationMediator.ProductDbSessionCached);
                return functionService;

            });
        }

        public override void Configure(Container container)
        {
            container.Register<IConsole, SystemConsole>();
            container.Register<IThreadService, ThreadService>();

            ViewEngines.Add<RazorViewEngine>();
        }

        /// <summary>Initialize the container and register it as MVC3 Dependency Resolver.</summary>
        public static void Initialize()
        {
            //var container = new Container();
            //container.Options.DefaultScopedLifestyle = new WebRequestLifestyle();

            //InitializeContainer(container);

            //container.RegisterMvcControllers(Assembly.GetExecutingAssembly());

            //container.Verify();

            //DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));

            // 1. Create a new Simple Injector container
            var container = new Container();

            // 2. Configure the container (register)
            container.Register<IUserRepository, SqlUserRepository>(Lifestyle.Transient);

            container.Register<SampleIOC.Logging.ILogging, MailLogger>(Lifestyle.Singleton);

            // 3. Optionally verify the container's configuration.
            container.Verify();

            // 4. Register the container as MVC3 IDependencyResolver.
            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
        }

 public static void RegisterServices(Container container)
 {
     container.Register<ApplicationDbContext>(Lifestyle.Scoped);
     container.RegisterPerWebRequest<IUserStore<ApplicationUser>>(() => new UserStore<ApplicationUser>(new ApplicationDbContext()));
     container.Register<ApplicationUserManager>(Lifestyle.Scoped);
     container.Register<ApplicationSignInManager>(Lifestyle.Scoped);
 }

 public void RegisterServices(Container container)
 {
     container.RegisterWebApiRequest<IDbFactory>(() => new DbFactory(ConfigurationManager.ConnectionStrings["People"].ConnectionString));
     container.Register<IPeopleRepository, PeopleRepository>();
     container.Register<IPeopleService, PeopleService>();
     container.Verify();
 }

        static void Main(string[] args)
        {
            //create the IOC container
            var container = new Container();
            //bind all our types to the interfaces
            container.Register<IContactCreator, ContactCreator>();
            container.Register<IContactLister, ContactLister>();
            container.Register<IContactStore, MemoryContactStore>();
            container.Register<ILog, NoLogging>();
            
            var creator = container.GetInstance<IContactCreator>();
            creator.Create(new Contact()
                {
                    Name = "Guy"
                });
            creator.Create(new Contact()
            {
                Name = "Ascension"
            });
            creator.Create(new Contact()
            {
                Name = "Richard"
            });

            var lister = container.GetInstance<IContactLister>();

            var contacts = lister.GetList();
            foreach (var contact in contacts)
            {
                Console.WriteLine(contact.Name);
            }
            Console.ReadKey();
        }