C# Container.RegisterSingle方法代码示例

 public void Register(Container container)
 {
     container.RegisterSingle<IMapper, Mapper>();
     container.RegisterSingle<IConnectionStringProvider, ConnectionStringProvider>();
     container.RegisterSingle<IDbConnectionProvider, SqlConnectionProvider>();
     container.RegisterSingle<IEmailSender, EmailSender>();
 }

 static App()
 {
     Container = new Container();
     Container.RegisterSingle(() => new Step1VM());
     Container.RegisterSingle(() => new Step2VM());
     Container.RegisterSingle(() => new Step3VM());
     Container.RegisterSingle(() => new Step4VM());
 }

        public void RegisterServices(Container container) {
            container.Options.AllowOverridingRegistrations = true;
            container.RegisterPackage<Core.Bootstrapper>();

            container.RegisterSingle<IMembershipSecurity, DefaultMembershipSecurity>();
            container.RegisterSingle<IMembershipProvider, MembershipProvider>();

            if (Settings.Current.EnableJobsModule)
                DynamicModuleUtility.RegisterModule(typeof(ExceptionlessJobHttpModule));
        }

        public static void Initialize()
        {
            // Create the container as usual.
            var container = new Container();

            //setup logger
            container.RegisterSingle<ILogger>(() =>
                new LoggerConfiguration()
                .WriteTo.ColoredConsole()
                .WriteTo.Trace()
                .CreateLogger()
            );
            
            //instagram config for InstaSharp
            container.RegisterSingle<InstagramConfig>(() =>
            {
                var clientId = ConfigurationManager.AppSettings["clientId"];
                var clientSecret = ConfigurationManager.AppSettings["clientSecret"];
                var callbackUri = ConfigurationManager.AppSettings["callbackUri"];
                var redirectUri = ConfigurationManager.AppSettings["redirectUri"];

                var icfg = new InstagramConfig(clientId, clientSecret);
                icfg.CallbackUri = callbackUri;
                icfg.RedirectUri = redirectUri;
                return icfg;
            }
            );

            // Azure storage account
            container.RegisterSingle(() =>
            {
                var connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
                return CloudStorageAccount.Parse(connectionString);
            });

            // Azure table client
            container.RegisterSingle(() => container.GetInstance<CloudStorageAccount>().CreateCloudTableClient());

            //register our tablesets, in this case we only have one
            container.RegisterWebApiRequest<ITableSet<RealtimeSubscription>>(() =>
                new TableSet<RealtimeSubscription>(container.GetInstance<CloudTableClient>())
                );

            //register repositories
            container.Register<ISubscriptionRepository, SubscriptionRepository>(Lifestyle.Singleton);

            // This is an extension method from the integration package.
            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

            container.Verify();

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

 public void Register(Container container)
 {
     container.RegisterSingle(() =>
     {
         var rabbitMqHost = ConfigurationManager.AppSettings["RabbitMQHost"];
         if (string.IsNullOrEmpty(rabbitMqHost)) throw new Exception("You must provide a 'RabbitMQHost' app setting.");
         return RabbitHutch.CreateBus("host=" + rabbitMqHost);
     });
     container.RegisterSingle<ICommandBus, CommandBus>();
     container.RegisterSingle<IEventBus, EventBus>();
     container.RegisterSingle<IBusLifetime, BusLifetime>();
 }

        private void InjectDependencies(HttpConfiguration config)
        {
            var container = new Container();

            container.RegisterSingle(() => ChecklistRepository);
            container.RegisterSingle(() => ControllerConfiguration);

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

            config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
        }

        public static void RegisterImplementations()
        {
            var container = new Container();

            container.RegisterSingle<IDbContextFactory, DbContextFactory>();
            container.RegisterSingle<ICacheStorage<string>, LocalCacheStorage>();
            container.RegisterSingle<ILogger, NLogLogger>();

            container.Verify();

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

        public void Register(Container container)
        {
            container.RegisterSingle<IUserStore<ApplicationUser, Guid>, ApplicationUserStore>();
            container.RegisterSingle<IIdentityMessageService, ApplicationIdentityMessageService>();
            container.RegisterSingle<ApplicationUserManager>();

            container.RegisterPerWebRequest<ApplicationSignInManager>();
            container.RegisterPerWebRequest<IUserContext, UserContext>();
            container.RegisterPerWebRequest<IContextService, ContextService>();

            container.RegisterMvcIntegratedFilterProvider();

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

        private static void InitSiteContainer(Container container)
        {
            container.Register<Fx.Domain.Account.IService.IAccountService, Fx.Domain.Account.UserAccountService>();
            container.Register<Fx.Domain.FxSite.IService.IChannelService, Fx.Domain.FxSite.ChannelService>();
            container.Register<Fx.Domain.FxSite.IService.ISite, Fx.Domain.FxSite.SiteService>();

            container.Register<Fx.Domain.FxSite.IService.IGoods, Fx.Domain.FxSite.GoodsService>();
            container.Register<Fx.Domain.FxSite.IService.ICar, Fx.Domain.FxSite.CarService>();
            container.Register<Fx.Domain.FxSite.IService.IHouse, Fx.Domain.FxSite.HouseService>();

            //FxGoods
            container.Register<Fx.Domain.FxGoods.IService.ITransferGoods, Fx.Domain.FxGoods.FxTransferGoodService>();
            container.Register<Fx.Domain.FxGoods.IService.IBuyGoods, Fx.Domain.FxGoods.FxBuyGoodsService>();

            //FxCar
            container.Register<Fx.Domain.FxCar.IService.ITransferCar, Fx.Domain.FxCar.FxTransferCarService>();
            container.Register<Fx.Domain.FxCar.IService.IBuyCar, Fx.Domain.FxCar.FxBuyCarService>();

            //FxHouse
            container.Register<Fx.Domain.FxHouse.IService.ITransferHouse, Fx.Domain.FxHouse.FxTransferHouseService>();
            container.Register<Fx.Domain.FxHouse.IService.IBuyHouse, Fx.Domain.FxHouse.FxBuyHouseService>();

            //�������
            container.RegisterSingle<Fx.Infrastructure.Caching.ICacheManager, Fx.Infrastructure.Caching.CacheManager>();
        }

        private static void InitializeContainer(Container container)
        {
            container.RegisterPerWebRequest<IDataContext, DataContext>();

            container.RegisterPerWebRequest<IUsersRepository, UsersRepository>();
            container.RegisterPerWebRequest<IRolesRepository, RolesRepository>();

            container.RegisterSingle<IConstantsProvider, DevConstantProvider>();

            container.RegisterPerWebRequest<IAuthenticationService, AuthenticationService>();
            container.RegisterPerWebRequest<IUsersService, UsersService>();
            container.RegisterPerWebRequest<IRolesService, RolesService>();
            container.RegisterSingle<IHashService, HashService>();

            container.RegisterPerWebRequest<ICurrentUserProxy, CurrentUserProxy>();
        }

        /// <summary>
        /// Discovers any Func dependencies of the specified type and attempts to register them.
        /// </summary>
        /// <param name="concreteType">Concrete type for which the dependencies should be discovered
        /// and registered</param>
        /// <param name="container">SimpleInjector container in which the dependencies should be registered.</param>
        /// <param name="options">Options to apply to the discovery and registration process.</param>
        public void RegisterDependencies(Type concreteType, Container container, IAutoRegistrationOptions options)
        {
            foreach (var ctor in concreteType.GetConstructors().Where((x) => x.IsPublic))
            {
                foreach (var param in ctor.GetParameters().Where((x) => x.ParameterType.Name.StartsWith("Func`")))
                {
                    var funcParamType = param.ParameterType;
                    var genericArgType = funcParamType.GenericTypeArguments.FirstOrDefault();

                    if (genericArgType != null 
                     && genericArgType.IsInterface 
                     && options.AutoRegistrationEnabledProvider.IsAutoRegistrationEnabled(genericArgType))
                    {
                        //Since Funcs<> do not retain any state and the wrapped Func<> accounts for the
                        //lifestyle of the object, it can always be made singleton, while the wrapped
                        //type may be transient.
                        container.RegisterSingle(funcParamType, () =>
                        {
                            //Create a Func<> with the container in context to create an instance of the type
                            var method = typeof(ContextualFuncCreationHelper).GetMethod("GetFunc").MakeGenericMethod(genericArgType);
                            var funcInstance = new ContextualFuncCreationHelper(container);

                            return Delegate.CreateDelegate(funcParamType, funcInstance, method);
                        });
                    }
                }
            }
        }

        public static Container RegisterTypes()
        {
            Container container = new Container();

            #region Queue IoC

            container.RegisterSingle<IPublisher>(new Publisher(container));

            container.RegisterSingle(new MessageEmitter(container));

            container.RegisterSingle(new RabbitMQIntegrationModule(container));

            #endregion

            container.Verify();
            return container;
        }

        private static void InitJobContainer(Container container)
        {
            container.RegisterSingle<FxTask.AppSettings>();
            container.RegisterSingle<FxTask.Filter>();

            //FxTaskFxCar
            container.Register<Fx.Domain.FxCar.IService.ICarBuyJob, Fx.Domain.FxCar.CarBuyJobService>();
            container.Register<Fx.Domain.FxCar.IService.ICarTransferJob, Fx.Domain.FxCar.CarTransferJobService>();


            //FxTaskFxGoods
            container.Register<Fx.Domain.FxGoods.IService.IGoodsBuyJob, Fx.Domain.FxGoods.GoodsBuyJobService>();
            container.Register<Fx.Domain.FxGoods.IService.IGoodsTransferJob, Fx.Domain.FxGoods.GoodsTransferJobService>();

            //FxTaskFxHouse
            container.Register<Fx.Domain.FxHouse.IService.IHouseBuyJob, Fx.Domain.FxHouse.HouseBuyJobService>();
            container.Register<Fx.Domain.FxHouse.IService.IHouseTransferJob, Fx.Domain.FxHouse.HouseTransferJobService>();
        }

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

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