C# ContainerBuilder.RegisterAssemblyTypes方法代码示例

        /// <summary>The load.</summary>
        /// <param name="builder">The builder.</param>
        protected override void Load(ContainerBuilder builder)
        {
            // register data models
            builder.RegisterAssemblyTypes(AssemblySource.Instance.ToArray()).Where(type => type.Name.EndsWith("DataModel")).Where(type => !string.IsNullOrWhiteSpace(type.Namespace)).AsSelf().InstancePerDependency();

            // register view models
            builder.RegisterAssemblyTypes(AssemblySource.Instance.ToArray()).Where(type => type.Name.EndsWith("ViewModel")).Where(type => !string.IsNullOrWhiteSpace(type.Namespace)).AsSelf().InstancePerDependency();

            // register views
            builder.RegisterAssemblyTypes(AssemblySource.Instance.ToArray()).Where(type => type.Name.EndsWith("View")).Where(type => !string.IsNullOrWhiteSpace(type.Namespace)).AsSelf().InstancePerDependency();
        }

        private static IMediator BuildMediator()
        {
            var builder = new ContainerBuilder();
            builder.RegisterSource(new ContravariantRegistrationSource());
            builder.RegisterAssemblyTypes(typeof (IMediator).Assembly).AsImplementedInterfaces();
            builder.RegisterAssemblyTypes(typeof (Ping).Assembly).AsImplementedInterfaces();
            builder.RegisterInstance(Console.Out).As<TextWriter>();

            var lazy = new Lazy<IServiceLocator>(() => new AutofacServiceLocator(builder.Build()));
            var serviceLocatorProvider = new ServiceLocatorProvider(() => lazy.Value);
            builder.RegisterInstance(serviceLocatorProvider);
            
            var mediator = serviceLocatorProvider().GetInstance<IMediator>();

            return mediator;
        }

        private static void RegisterServices(ContainerBuilder builder)
        {
            builder.Register(x => new AppDbContext())
               .As<DbContext>()
               .InstancePerRequest();

<<<<<<< HEAD
            builder.Register(x => new HttpCacheService())
               .As<ICacheService>()
               .InstancePerRequest();

            builder.Register(x => new IdentifierProvider())
               .As<IIdentifierProvider>()
               .InstancePerRequest();

            var servicesAssembly = Assembly.GetAssembly(typeof(IJokesService));
            builder.RegisterAssemblyTypes(servicesAssembly).AsImplementedInterfaces();

            builder.RegisterGeneric(typeof(DbRepository<>))
               .As(typeof(IDbRepository<>))
               .InstancePerRequest();

            builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
                .AssignableTo<BaseController>()
                .PropertiesAutowired();
=======
            builder.RegisterGeneric(typeof(DbRepository<>))
                .As(typeof(IDbRepository<>))
                .InstancePerRequest();

            // builder.Register(x => new HttpCacheService())
            //    .As<ICacheService>()
            //    .InstancePerRequest();
            // builder.Register(x => new IdentifierProvider())
            //    .As<IIdentifierProvider>()
            //    .InstancePerRequest();

            // var servicesAssembly = Assembly.GetAssembly(typeof(IJokesService));
            // builder.RegisterAssemblyTypes(servicesAssembly).AsImplementedInterfaces();



            // builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
            //    .AssignableTo<BaseController>().PropertiesAutowired();
>>>>>>> 6ca5c2744ff07e9ad93c0f5627d37f5deea149bf
        }

 protected override void Load(ContainerBuilder builder)
 {
     builder.RegisterAssemblyTypes(_assembly)
         .Where( t => t.IsClass && !t.IsAbstract && 
             _typeDictionary.Any(l => l.Invoke(t) != null))
         .AsSelf()
         .InstancePerLifetimeScope();
 }

        public void WhenTypesRegisteredAsSelfConcreteTypeIsService()
        {
            var cb = new ContainerBuilder();
            cb.RegisterAssemblyTypes(typeof(AComponent).Assembly)
                .AsSelf();
            var c = cb.Build();

            c.AssertRegistered<AComponent>();
        }

        public void AsClosedTypesOfOpenGenericAbstractClassTypeProvidedClosingGenericTypesRegistered()
        {
            var cb = new ContainerBuilder();
            cb.RegisterAssemblyTypes(typeof(Message<>).GetTypeInfo().Assembly)
                .AsClosedTypesOf(typeof(Message<>));
            var c = cb.Build();

            Assert.IsType<StringMessage>(c.Resolve<Message<string>>());
        }

        public void AsClosedTypesOfClosingInterfaceTypeRegistered()
        {
            var cb = new ContainerBuilder();
            cb.RegisterAssemblyTypes(typeof(ICloseCommand).GetTypeInfo().Assembly)
                .AsClosedTypesOf(typeof(ICommand<>));
            var c = cb.Build();

            Assert.IsType<CloseCommand>(c.Resolve<ICloseCommand>());
        }

        public void AsImplementedInterfacesRegistersImplementedInterfaces()
        {
            var cb = new ContainerBuilder();
            cb.RegisterAssemblyTypes(typeof(AComponent).GetTypeInfo().Assembly)
                .AsImplementedInterfaces();
            var c = cb.Build();

            c.AssertRegistered<IAService>();
            c.AssertRegistered<IBService>();
        }

        public void AsClosedTypesOfOpenGenericInterfaceTypeProvidedClosingGenericTypesRegistered()
        {
            var cb = new ContainerBuilder();
            cb.RegisterAssemblyTypes(typeof(ICommand<>).GetTypeInfo().Assembly)
                .AsClosedTypesOf(typeof(ICommand<>));
            var c = cb.Build();

            Assert.IsType<SaveCommand>(c.Resolve<ICommand<SaveCommandData>>());
            Assert.IsType<DeleteCommand>(c.Resolve<ICommand<DeleteCommandData>>());
        }

        public void AsClosedTypesOfWithServiceKeyMappingShouldAssignKeyResultToEachRegistration()
        {
            var cb = new ContainerBuilder();
            cb.RegisterAssemblyTypes(typeof(ICommand<>).GetTypeInfo().Assembly)
                .AsClosedTypesOf(typeof(ICommand<>), t => t);
            var c = cb.Build();

            Assert.IsType<SaveCommand>(c.ResolveKeyed<ICommand<SaveCommandData>>(typeof(SaveCommand)));
            Assert.IsType<DeleteCommand>(c.ResolveKeyed<ICommand<DeleteCommandData>>(typeof(DeleteCommand)));
        }

        public void AsClosedTypesOfMultipleServicesPerClassExposesAllServices()
        {
            var cb = new ContainerBuilder();
            cb.RegisterAssemblyTypes(typeof(UndoRedoCommand).GetTypeInfo().Assembly)
                .AsClosedTypesOf(typeof(ICommand<>));
            var c = cb.Build();

            var r = c.RegistrationFor<ICommand<UndoCommandData>>();
            Assert.True(r.Services.Contains(new TypedService(typeof(ICommand<RedoCommandData>))));
        }

        public void WhenAssemblyIsScannedTypesRegisteredByDefault()
        {
            var cb = new ContainerBuilder();
            cb.RegisterAssemblyTypes(typeof(AComponent).Assembly);
            var c = cb.Build();

            c.AssertRegistered<AComponent>();
            c.AssertSharing<AComponent>(InstanceSharing.None);
            c.AssertLifetime<AComponent, CurrentScopeLifetime>();
            c.AssertOwnership<AComponent>(InstanceOwnership.OwnedByLifetimeScope);
        }

 public BTDBFuncUseCase()
 {
     var builder = new ContainerBuilder();
     builder.RegisterType<Logger>().As<ILogger>().SingleInstance();
     builder.RegisterAssemblyTypes(typeof(IWebService).Assembly)
         .Where(t => t.Namespace == "IOCPerfTest.IOCDomain")
         .AsImplementedInterfaces()
         .PreserveExistingDefaults();
     _container = builder.Build();
     _factory = _container.Resolve<Func<IWebService>>();
 }

        public void WhenFiltersAppliedNonMatchingTypesExcluded()
        {
            var cb = new ContainerBuilder();
            cb.RegisterAssemblyTypes(typeof(AComponent).Assembly)
                .Where(t => t.Name.StartsWith("A"))
                .Where(t => t.Name.StartsWith("AC"));
            var c = cb.Build();

            c.AssertRegistered<AComponent>();
            c.AssertNotRegistered<BComponent>();
            c.AssertNotRegistered<A2Component>();
        }

        private static IContainer ConfigureAutofac()
        {
            var builder = new ContainerBuilder();

            builder.RegisterAssemblyTypes(AppDomain.CurrentDomain.GetAssemblies())
                   .Where(t => t.Name.EndsWith("Handler"))
                   .AsImplementedInterfaces()
                   .InstancePerLifetimeScope();

            var container = builder.Build();
            return container;
        }