C# ContainerBuilder.RegisterType方法代码示例

 protected override void Load(ContainerBuilder builder)
 {
     base.Load(builder);
     builder.RegisterType<AdditionService>().As<IAdditionService>();
     builder.RegisterType<MultiplicationService>().As<IMultiplicationService>();
     builder.RegisterType<CalculationService>().As<ICalculationService>();
 }

 public void Initialise()
 {
     var builder = new ContainerBuilder();
     builder.RegisterType<Logger>().As<ILogger>();
     builder.RegisterType<Repository>().As<IRepository>();
     builder.Build();
 }

        public void CollectionInNestedLifetimeScope()
        {
            // Issue #711
            // Note #711 was using named collections; this test is not.
            // Named collections don't have different behavior than the standard
            // auto-generated behavior from a resolve standpoint since you
            // can't resolve a specifically named collection.
            var cb = new ContainerBuilder();
            cb.RegisterType<Foo1>().As<IFoo>();
            cb.RegisterType<Foo2>().As<IFoo>();
            using (var container = cb.Build())
            {
                var collection = container.Resolve<IEnumerable<IFoo>>();
                Assert.Equal(2, collection.Count());

                using (var scope = container.BeginLifetimeScope())
                {
                    collection = container.Resolve<IEnumerable<IFoo>>();
                    Assert.Equal(2, collection.Count());
                }

                using (var scope = container.BeginLifetimeScope(b => { }))
                {
                    collection = container.Resolve<IEnumerable<IFoo>>();
                    Assert.Equal(2, collection.Count());
                }
            }
        }

        public void CanCreateMixinWithClassInterceptors()
        {
            var options = new ProxyGenerationOptions();
            options.AddMixinInstance(new Dictionary<int, int>());

            var builder = new ContainerBuilder();
            builder.RegisterType<C>().EnableClassInterceptors(options);
            builder.RegisterType<AddOneInterceptor>();
            builder.RegisterType<AddTenInterceptor>();
            var container = builder.Build();
            var i = 10;
            var cpt = container.Resolve<C>(TypedParameter.From(i));

            var dict = cpt as IDictionary<int, int>;

            Assert.NotNull(dict);

            dict.Add(1, 2);

            Assert.Equal(2, dict[1]);

            dict.Clear();

            Assert.Empty(dict);
        }

 private void BuildSampleContainer()
 {
     ContainerBuilder containerBuilder = new ContainerBuilder();
     containerBuilder.RegisterModule<NLogModule>();
     containerBuilder.RegisterType<SampleClassWithConstructorDependency>().Named<ISampleClass>("constructor");
     containerBuilder.RegisterType<SampleClassWithPropertyDependency>().Named<ISampleClass>("property");
     _container = containerBuilder.Build();
 }

        public void FindsInterceptionAttributeOnReflectionComponent()
        {
            var builder = new ContainerBuilder();
            builder.RegisterType<C>().As<IHasI>().EnableInterfaceInterceptors();
            builder.RegisterType<AddOneInterceptor>();
            var cpt = builder.Build().Resolve<IHasI>();

            Assert.Equal(11, cpt.GetI()); // proxied
        }

        public void CtorPropDependencyFactoriesOrder1()
        {
            var cb = new ContainerBuilder();
            cb.RegisterType<DependsByCtor>();
            cb.RegisterType<DependsByProp>().PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies);

            var c = cb.Build();
            c.Resolve<DependsByProp>();
        }

 public void DetectsNonInterfaceServices()
 {
     var builder = new ContainerBuilder();
     builder.RegisterType<C>().EnableInterfaceInterceptors();
     builder.RegisterType<AddOneInterceptor>();
     var c = builder.Build();
     var dx = Assert.Throws<DependencyResolutionException>(() => c.Resolve<C>());
     Assert.IsType<InvalidOperationException>(dx.InnerException);
 }

 public DecoratingANamedService()
 {
     const string from = "from";
     var builder = new ContainerBuilder();
     builder.RegisterType<Implementer1>().Named<IService>(from);
     builder.RegisterType<Implementer2>().Named<IService>(from);
     builder.RegisterDecorator<IService>(s => new Decorator(s), from);
     _container = builder.Build();
 }

 protected override void Load(ContainerBuilder builder)
 {
     // InstancePerLifetimeScope implementation
     //builder.Register(c => new PlayInterface(Guid.NewGuid().ToString("N"))).As<IPlayInterface>().InstancePerLifetimeScope(); // InstancePerHttpRequest (httpRequest) lifetime scope default
     builder.RegisterType<PlayInterface>().As<IPlayInterface>().InstancePerLifetimeScope();
         // InstancePerHttpRequest (httpRequest) lifetime scope default
     builder.RegisterType<PlaygroundPresenter>().AsSelf().InstancePerDependency();
     builder.RegisterGeneratedFactory<PlaygroundPresenterFactory>();
 }

        static IContainer BuildContainer()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<Dependency>().AsSelf();
            builder.RegisterWebApiModelBinderProvider();
            builder.RegisterType<TestModelBinder>().AsModelBinderForTypes(typeof(TestModel1));

            return builder.Build();
        }

        protected override IServiceLocator CreateServiceLocator() {
            var container = new ContainerBuilder();
            Type simpleType = typeof (SimpleLogger);
            Type complexType = typeof (ComplexLogger);

            container.RegisterType(simpleType).As<ILogger>().Named(simpleType.FullName, typeof (ILogger));
            container.RegisterType(complexType).As<ILogger>().Named(complexType.FullName, typeof (ILogger)).As(typeof(ComplexLogger));

            return new AutofacServiceLocator(container);
        }

 public void RestrictsExportsBasedOnValueType()
 {
     var builder = new ContainerBuilder();
     const string n = "name";
     builder.RegisterType<MefDependency>().Exported(e => e.AsNamed<IDependency>(n));
     builder.RegisterType<MefDependency>().Exported(e => e.AsNamed<MefDependency>(n));
     var container = builder.Build();
     var exports = container.ResolveExports<IDependency>(n);
     Assert.AreEqual(1, exports.Count());
 }

        public static void Register(ContainerBuilder builder)
        {
            builder.RegisterType<MongoEventStoreRepository>()
              .As<IEventStoreRepository>()
              .InstancePerRequest();

              builder.Register(c => new AccountIdResolver(new MongoAccountRepository()))
              .As<IAccountIdResolver>()
              .InstancePerRequest();

              builder.RegisterType<MongoAccountRepository>()
              //.As<IAccountRepository>()
              .Named<IAccountRepository>("account")
              .InstancePerRequest();

              builder.RegisterDecorator<IAccountRepository>(
              (c, inner) => new MongoAccountRepositoryWithEventStore(inner,
            new MongoEventStoreRepository(c.Resolve<IAccountIdResolver>())),
              fromKey: "account")
              .InstancePerRequest();

            builder.RegisterType<MongoQueryRepository>()
                            //.As<IQueryRepository>()
              .Named<IQueryRepository>("query")
              .InstancePerRequest();

              builder.RegisterDecorator<IQueryRepository>(
              (c, inner) => new MongoQueryRepositoryWithEventStore(inner,
            new MongoEventStoreRepository(c.Resolve<IAccountIdResolver>())),
              fromKey: "query")
              .InstancePerRequest();

            builder.RegisterType<MongoQueryLogRepository>()
                            .As<IQueryLogRepository>()
                            .InstancePerRequest();

              BsonClassMap.RegisterClassMap<Account>();

              BsonClassMap.RegisterClassMap<EventStore>(classMap => {
            classMap.AutoMap();
            classMap.GetMemberMap(es => es.EventName).SetRepresentation(BsonType.String);
              });

              BsonClassMap.RegisterClassMap<AuthorizationSettings>(classMap => {
            classMap.AutoMap();
            classMap.GetMemberMap(aus => aus.Operation).SetRepresentation(BsonType.String);
            classMap.GetMemberMap(aus => aus.AccountId).SetRepresentation(BsonType.ObjectId);
              });

              BsonClassMap.RegisterClassMap<Note>(classMap =>
              {
            classMap.AutoMap();
            classMap.GetMemberMap(n => n.AccountId).SetRepresentation(BsonType.ObjectId);
              });
        }

        private static IContainer ConfigureMefThenAutofac()
        {
            var builder = new ContainerBuilder();
            builder.EnableCompositionIntegration();
            var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            builder.RegisterCatalog(catalog);
            builder.RegisterType<AutofacComponent>().As<IAutofacComponent>();
            builder.RegisterType<CountableAutofacComponent>().As<ICountableAutofacComponent>();

            return builder.Build();
        }