C# IUnityContainer.RegisterTypes方法代码示例

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

            container.RegisterType<AccountController>(new InjectionConstructor());
            container.RegisterType<ManageController>(new InjectionConstructor());

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default
                );

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().
                    Where(
                        type =>
                            typeof (IRunAtInit).IsAssignableFrom(type) ||
                            typeof (IRunAtStartup).IsAssignableFrom(type) ||
                            typeof (IRunOnError).IsAssignableFrom(type) ||
                            typeof (IRunOnEachRequest).IsAssignableFrom(type) ||
                            typeof (IRunAfterEachRequest).IsAssignableFrom(type) ||
                            typeof (IRunBeforeEachRequest).IsAssignableFrom(type)),
                WithMappings.FromAllInterfaces,
                WithName.TypeName);
        }

		/// <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)
		{

			#region Register repositories

			var rep_a = Assembly.GetAssembly(typeof(IRepository<>));
			container.RegisterTypes(AllClasses.FromAssemblies(rep_a),
				WithMappings.FromMatchingInterface,
				WithName.Default,
				x => new PerRequestLifetimeManager());

			#endregion

			#region Register services

			var serv_a = Assembly.GetAssembly(typeof(IService<>));
			container.RegisterTypes(AllClasses.FromAssemblies(serv_a),
				WithMappings.FromMatchingInterface,
				WithName.Default,
				x => new PerRequestLifetimeManager());

			#endregion

			container.RegisterType<RelaxSummerContext>(new PerRequestLifetimeManager());
		}

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

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default
                );

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().
                    Where(
                        type =>
                            typeof (IRunAtInit).IsAssignableFrom(type) ||
                            typeof (IRunAtStartup).IsAssignableFrom(type) ||
                            typeof (IRunOnError).IsAssignableFrom(type) ||
                            typeof (IRunOnEachRequest).IsAssignableFrom(type) ||
                            typeof (IRunAfterEachRequest).IsAssignableFrom(type) ||
                            typeof (IRunBeforeEachRequest).IsAssignableFrom(type)),
                WithMappings.FromAllInterfaces,
                WithName.TypeName);

            container.RegisterType<IAuthenticationManager>(new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication));

            container.RegisterType<IUserStore<User>, UserStore<User>>(new InjectionConstructor(typeof (ApplicationDbContext)));

            container.RegisterType<IRoleStore<IdentityRole, string>, RoleStore<IdentityRole, string, IdentityUserRole>>(
                new InjectionConstructor(typeof (ApplicationDbContext)));
        }

 public static void RegisterServices(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies().Where(t => t.Namespace.StartsWith("Hangfire.Services.Impl") && !t.IsAbstract),
         FromMatchingInterface, WithName.Default, WithLifetime.ContainerControlled,
         getInjectionMembers: t => InterceptorSupport);
 }

 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterTypes(AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default);
     container.RegisterType<IActivitiesMasterRepository, ActivitiesMasterRepository>();
     container.RegisterType<IDataRepositoryFactory, DataRepositoryFactory>();
     container.RegisterType<IBusinessEngineFactory, BusinessEngineFactory>();
 }

 private static void RegisterControllers(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies()
             .Where(t => t.Namespace.StartsWith("Hangfire.Web.Api.Controllers")),
         WithMappings.None, WithName.Default, WithLifetime.Hierarchical, getInjectionMembers: t => UnityUtils.InterceptorSupport);
 }

 private static void RegisterDao(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies().Where(t => t.Namespace.StartsWith("Hangfire.Dao.EntityFrameworkImpl.Dao") && !t.IsAbstract),
         UnityUtils.FromMatchingInterface, WithName.Default, WithLifetime.PerThread,
         getInjectionMembers: t => UnityUtils.InterceptorSupport);
 }

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

 private static void RegisterByConvention(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies().Where(t => t.Namespace.StartsWith("LycanTally")),
         WithMappings.FromMatchingInterface,
         WithName.Default);
 }

 private void InitializeContainer()
 {
     _container = new UnityContainer();
     _container.RegisterTypes(
         AllClasses.FromAssembliesInBasePath(),
         WithMappings.FromMatchingInterface,
         WithName.Default);
 }

        public static void RegisterTypes(IUnityContainer container)
        {
            container.RegisterTypes(AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default);
            container.RegisterType<IBlogRepository, BlogRepository>();
            container.RegisterType<IOAuthTwitterWrapper, OAuthTwitterWrapper>();

            //container.RegisterType<UserStore<CustomUser>>(new HierarchicalLifetimeManager());
            container.RegisterType<DbContext, IdentityContext>(new HierarchicalLifetimeManager());
        }

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

            container.RegisterType<AccountController>(new InjectionConstructor());
        }

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

            // TODO: Register your types here
             container.RegisterTypes(AllClasses.FromLoadedAssemblies(),
                                     WithMappings.FromMatchingInterface,
                                     WithName.Default);
        }

        public static void RegisterComponents(IUnityContainer container)
        {
            container.RegisterTypes(
                AllClasses.FromAssemblies(Assembly.GetAssembly(typeof(UnityConfig)),
                    Assembly.GetAssembly(typeof(Historian))),
                WithMappings.FromMatchingInterface, WithName.Default);

            container.RegisterType<IWorkItemRepository, WorkItemRepository>(new InjectionFactory(c => new WorkItemRepositoryFactory().CreateRepository()));
            DependencyResolver.SetResolver(new UnityDependencyResolver(container));
        }

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

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