C# IUnityContainer.RegisterType方法代码示例

        /// <summary>
        /// Registers the type mappings with the Unity container.
        /// </summary>
        /// <param name="container">The unity container to configure.</param>
        /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
        /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
        public static void RegisterTypes(IUnityContainer container)
        {
            // Register all of the needed services
            container.RegisterType<IPlayerService, PlayerService>()
                     .RegisterType<IGameService, GameService>()
                     .RegisterType<IHoleService, HoleService>()
                     .RegisterType<IShotService, ShotService>()
                     .RegisterType<IShotTypeService, ShotTypeService>()
                     .RegisterType<IRankingService, RankingService>();

            // Register all of the needed repositories
            container.RegisterType<IGameRepository, GameRepository>()
                     .RegisterType<IPlayerRepository, PlayerRepository>()
                     .RegisterType<IHoleRepository, HoleRepository>()
                     .RegisterType<IShotRepository, ShotRepository>()
                     .RegisterType<IRankingRepository, RankingRepository>()
                     .RegisterType<IGameStatisticsRepository, GameStatisticsRepository>()
                     .RegisterType<IPlayerStatisticsRepository, PlayerStatisticsRepository>()
                     .RegisterType<IHoleStatisticsRepository, HoleStatisticsRepository>()
                     .RegisterType<IPlayerHoleStatisticsRepository, PlayerHoleStatisticsRepository>()
                     .RegisterType<IPlayerGameStatisticsRepository, PlayerGameStatisticsRepository>()
                     .RegisterType<IPlayerCareerStatisticsRepository, PlayerCareerStatisticsRepository>()
                     .RegisterType<IPlayerRivalryStatisticsRepository, PlayerRivalryStatisticsRepository>()
                     .RegisterType<IShotTypeRepository, ShotTypeRepository>(); 
        }

        /// <summary>
        ///     Register types with convention Interface must inheritance
        ///     <see cref="IDependency"/>/
        ///     <see cref="IPerRequestDependency"/>/
        ///     <see cref="ISingletonDependency"/>
        /// </summary>
        /// <param name="container"></param>
        /// <param name="listClass"></param>
        public static void RegisterTypesWithConvention(IUnityContainer container, IEnumerable<Type> listClass)
        {
            Validate(container);

            foreach (Type @class in listClass)
            {
                var listInterface = @class.GetInterfacesToBeRegistered();
                Type @localClass = @class;
                foreach (Type @interface in listInterface.Where(x => x.IsGenericType == localClass.IsGenericType))
                {
                    if (typeof(ISingletonDependency).IsAssignableFrom(@interface))
                    {
                        // Type extend from ISingletonDependency interface,
                        // so register it as Singleton
                        container.RegisterType(@interface, @class, new ContainerControlledLifetimeManager());
                    }
                    else if (typeof(IPerRequestDependency).IsAssignableFrom(@interface))
                    {
                        // Type extend from IPerRequestDependency interface,
                        // so register it as Instant per Request
                        container.RegisterType(@interface, @class, new PerRequestLifetimeManager());
                    }
                    else if (typeof(IDependency).IsAssignableFrom(@interface))
                    {
                        // Type extend from IDependency interface,
                        // so register it as Instant per Dependency
                        container.RegisterType(@interface, @class, new HierarchicalLifetimeManager());
                    }
                }
            }

            PrintRegisterInformation(container);
        }

 private void RegisterSerializers(IUnityContainer container) {
     container.RegisterType(typeof (ISolrDocumentSerializer<>), typeof (SolrDocumentSerializer<>));
     container.RegisterType(typeof (ISolrDocumentSerializer<Dictionary<string, object>>), typeof (SolrDictionarySerializer));
     container.RegisterType<ISolrFieldSerializer, DefaultFieldSerializer>();
     container.RegisterType<ISolrQuerySerializer, DefaultQuerySerializer>();
     container.RegisterType<ISolrFacetQuerySerializer, DefaultFacetQuerySerializer>();
 }

 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterType<IPersonRepository, PersonRepository>();
     container.RegisterType<ILogRepository, LogRepository>();
     container.RegisterType<IExerciseRepository, ExerciseRepository>();
     container.RegisterType<ISetRepository, SetRepository>();
 }

 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterType<IProvinceDao, ProvinceDao>(new ContainerControlledLifetimeManager());
     container.RegisterType<ICityDao, CityDao>(new ContainerControlledLifetimeManager());
     container.RegisterType<IProvinceService, ProvinceService>(new ContainerControlledLifetimeManager());
     container.RegisterType<ICityService, CityService>(new ContainerControlledLifetimeManager());
 }

        /// <summary>Registers the type mappings with the Unity container.</summary>
        /// <param name="container">The unity container to configure.</param>
        /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
        /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
        public static void RegisterTypes(IUnityContainer container) {
            // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
            // container.LoadConfiguration();
            //Standard configuration

            try {

                StandardUnityConfig.RegisterStandardFacetFactories(container);
                StandardUnityConfig.RegisterCoreContainerControlledTypes(container);
                StandardUnityConfig.RegisterCorePerTransactionTypes<PerResolveLifetimeManager>(container);

                // config 
                container.RegisterInstance<IReflectorConfiguration>(NakedObjectsRunSettings.ReflectorConfig(), (new ContainerControlledLifetimeManager()));
                container.RegisterInstance<IEntityObjectStoreConfiguration>(NakedObjectsRunSettings.EntityObjectStoreConfig(), new ContainerControlledLifetimeManager());

                // frameworkFacade
                container.RegisterType<IOidTranslator, OidTranslatorSlashSeparatedTypeAndIds>(new PerResolveLifetimeManager());

                container.RegisterType<IOidStrategy, EntityOidStrategy>(new PerResolveLifetimeManager());
                container.RegisterType<IStringHasher, SimpleStringHasher>(new PerResolveLifetimeManager());
                container.RegisterType<IFrameworkFacade, FrameworkFacade>(new PerResolveLifetimeManager());

                //Externals
                container.RegisterType<IPrincipal>(new InjectionFactory(c => HttpContext.Current.User));
            }
            catch (Exception e) {
                Logger.Error($"Error on Unity RegisterTypes : {e.Message}");
                throw;
            }

        }

 public void Configure(IUnityContainer container)
 {
     container.RegisterType<IModuleRepository, DefaultModuleRepository>();
     container.RegisterType<IModuleSchemaProvider, DefaultModuleSchemaProvider>();
     container.RegisterType<IHelperHandlerFactory, DefaultRenderingHelperHandlerFactory>();
     container.RegisterType<IMemberLocator, MemberLocatorFromNamingRule>();
 }

 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterType<ElectionMonitoringController>();
     container.RegisterType<IRaceRepository, RaceRepository>();
     container.RegisterType<IRaceResultService, RaceResultService>();
     container.RegisterType<IRegionRepository, RegionRepository>();
 }

        public static void Init(TestContext context)
        {
            GetMockSubscribeService();
            GetMockCurrentHttpContext();
            CreateBasicSubmission();
            CreateComplexSubmission();
            CreateBasicEnergySubmission();
            CreateComplexEnergySubmission();
            CreateBasicCargoSubmission();
            CreateComplexCargoSubmission();
            CreateBasicHullSubmission();
            CreateComplexHullSubmission();
            CreateBasicMarineSubmission();
            CreateComplexMarineSubmission();
                        
            _container = new UnityContainer();
            _container.AddNewExtension<EnterpriseLibraryCoreExtension>();
            _container.RegisterType<ILogHandler, LogHandler>();
            _container.RegisterType<IConsoleRepository, ConsoleRepository>();
            _container.RegisterType<IWebSiteModuleManager, WebSiteModuleManager>();
            var mockPolicyData = new Mock<IPolicyData>();
            //_container.RegisterType<IPolicyData, PolicyData>();
            _container.RegisterInstance(typeof(IPolicyData), mockPolicyData.Object);
            var consoleRepository = _container.Resolve<IConsoleRepository>();

            SaveTestSubmission(consoleRepository);

            _submissionModule =
                _container.Resolve<SubmissionModule>(new ParameterOverride("currentHttpContext", _currentHttpContext),
                                                    new ParameterOverride("subscribeService", _mockSubscribeService));
        }

 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterType<IEmailSender, SendGridEmailSender>();
     container.RegisterType<IUserRepository, UserRepository>();
     container.RegisterType<IProjectRepository, ProjectRepository>();
     container.RegisterType<IPaymentVoucherRepository, PaymentVoucherRepository>();
 }

        public static void RegisterTypes(IUnityContainer container)
        {
            // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
            // container.LoadConfiguration();

            // TODO: Register your types here
            #region Register logger
            #endregion
            #region Register Account Controller dependencies
            //container
            //    .RegisterType<UserStore<ApplicationUser>>(new PerRequestLifetimeManager(), new InjectionConstructor(new AuthenticationDbContext("Name=LongAnConnection")))
            //    .RegisterType<IUserStore<ApplicationUser>, UserStore<ApplicationUser>>(new PerRequestLifetimeManager())
            //    .RegisterType<UserManager<ApplicationUser>>(new PerRequestLifetimeManager());

            container
                .RegisterType<IAreaService, AreaService>(new PerRequestLifetimeManager())
                .RegisterType<IUserService, UserService>(new PerRequestLifetimeManager())
                .RegisterType<INewsService, NewsService>(new PerRequestLifetimeManager())
                .RegisterType<IAreaService, AreaService>(new PerRequestLifetimeManager())
                .RegisterType<IProjectTypeService, ProjectTypeService>(new PerRequestLifetimeManager())
                .RegisterType<IPriceService, PriceService>(new PerRequestLifetimeManager())
                .RegisterType<IProjectService, ProjectService>(new PerRequestLifetimeManager())
                .RegisterType<IAdsService, AdsService>(new PerRequestLifetimeManager())
                .RegisterType<IContractorServices, ContractorServices>(new PerRequestLifetimeManager())

                ;
            #endregion
            #region Register Repository

            container
                .RegisterType(typeof(Repository.Pattern.Repositories.IRepositoryAsync<>), typeof(Repository.Pattern.Ef6.Repository<>), new PerRequestLifetimeManager())
                .RegisterType<Repository.Pattern.Repositories.IRepositoryAsync<Area>, Repository.Pattern.Ef6.Repository<Area>>(new PerRequestLifetimeManager())
                .RegisterType<Repository.Pattern.Repositories.IRepositoryAsync<Users>, Repository.Pattern.Ef6.Repository<Users>>(new PerRequestLifetimeManager())
                .RegisterType<Repository.Pattern.Repositories.IRepositoryAsync<News>, Repository.Pattern.Ef6.Repository<News>>(new PerRequestLifetimeManager())
                .RegisterType<Repository.Pattern.Repositories.IRepositoryAsync<ProjectType>, Repository.Pattern.Ef6.Repository<ProjectType>>(new PerRequestLifetimeManager())
                .RegisterType<Repository.Pattern.Repositories.IRepositoryAsync<Area>, Repository.Pattern.Ef6.Repository<Area>>(new PerRequestLifetimeManager())
                .RegisterType<Repository.Pattern.Repositories.IRepositoryAsync<Price>, Repository.Pattern.Ef6.Repository<Price>>(new PerRequestLifetimeManager())
                .RegisterType<Repository.Pattern.Repositories.IRepositoryAsync<Project>, Repository.Pattern.Ef6.Repository<Project>>(new PerRequestLifetimeManager())
                .RegisterType<Repository.Pattern.Repositories.IRepositoryAsync<Ads>, Repository.Pattern.Ef6.Repository<Ads>>(new PerRequestLifetimeManager())
                .RegisterType<Repository.Pattern.Repositories.IRepositoryAsync<Contractor>, Repository.Pattern.Ef6.Repository<Contractor>>(new PerRequestLifetimeManager())
                ;
            #endregion
            #region Register Unit of work
            container
                .RegisterType<Repository.Pattern.UnitOfWork.IUnitOfWorkAsync, Repository.Pattern.Ef6.UnitOfWork>(new PerRequestLifetimeManager());

            #endregion

            #region Register dbContext
            //container
            //.RegisterType<Repository.Pattern.DataContext.IDataContextAsync, DataContext>(new PerRequestLifetimeManager(),new InjectionConstructor(new ResolvedParameter<IDataContextAsync>("")));
            ////container.RegisterType<IDataContextAsync>(new InjectionFactory((c)=>
            //   {
            //        var name = new DataContext();
            //        return c.Resolve<IDataContextAsync>(name);
            //   });
            container
                .RegisterType<IDataContextAsync, SHDataContext>(new PerRequestLifetimeManager());
            #endregion
        }

 /// <summary>Registers the type mappings with the Unity container.</summary>
 /// <param name="container">The unity container to configure.</param>
 /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
 /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterType<IServiceClient, WebApiClient>(
             new InjectionConstructor(ConfigurationManager.AppSettings[ArbConstants.WebApiServiceAddress])
         );
     container.RegisterType<IAuthentication, ArbAuthentication>();
 }

 private static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterType<IExcelReaderService, ExcelReaderService>();
     container.RegisterType<IJsonService, JsonService>();
     container.RegisterType<IRestService, RestService>();
     container.RegisterType<IWebClientService, WebClientService>();
 }

    public static void RegisterTypes(IUnityContainer container)
    {
        container.RegisterTypes(
           AllClasses.FromLoadedAssemblies(),
           WithMappings.FromMatchingInterface,
           WithName.Default);

        //Injection Constructor
        //container.RegisterType<IProteinRepository, ProteinRepository>(new InjectionConstructor("test data"));
        
        //Using register Instance
        //container.RegisterInstance(typeof(IProteinRepository), new ProteinRepository("test data 123"));

        //Named Registration
        container.RegisterType<IProteinRepository, ProteinRepository>("StandardRepository", new InjectionConstructor("test"));
        container.RegisterType<IProteinRepository, DebugProteinRepository>("DebugProteinRepository");

        //Named Registration
        var repositoryType = WebConfigurationManager.AppSettings["RepositoryType"];
        container.RegisterType<IProteinTrackingService, ProteinTrackingService>(
            new InjectionConstructor(container.Resolve<IProteinRepository>(repositoryType)));

        //container.RegisterType<IProteinTrackingService, ProteinTrackingService>();
        //container.RegisterType<IProteinRepository, ProteinRepository>();
    }

 /// <summary>
 /// Additionally configures unity container with classes in UMA Vetuma project
 /// </summary>
 /// <param name="container">Unity container instance</param>
 public static void RegisterDependencies(IUnityContainer container)
 {
     container.RegisterType<IStrongAuthenticationService, StrongAuthenticationService>();
     container.RegisterType<IPaymentService, PaymentService>();
     container.RegisterType<IVetumaService, VetumaServiceSubmit>();
     container.RegisterType<IVetumaUtilities, VetumaUtilities>();
 }