C# ContainerBuilder.Register方法代码示例

        public void WrapperResolvesAuthenticationFilterFromDependencyScope()
        {
            var builder = new ContainerBuilder();
            builder.Register<ILogger>(c => new Logger()).InstancePerDependency();
            var activationCount = 0;
            builder.Register<IAutofacAuthenticationFilter>(c => new TestAuthenticationFilter(c.Resolve<ILogger>()))
                .AsWebApiAuthenticationFilterFor<TestController>(c => c.Get())
                .InstancePerRequest()
                .OnActivated(e => activationCount++);
            var container = builder.Build();

            var resolver = new AutofacWebApiDependencyResolver(container);
            var configuration = new HttpConfiguration { DependencyResolver = resolver };
            var requestMessage = new HttpRequestMessage();
            requestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, configuration);
            var contollerContext = new HttpControllerContext { Request = requestMessage };
            var controllerDescriptor = new HttpControllerDescriptor { ControllerType = typeof(TestController) };
            var methodInfo = typeof(TestController).GetMethod("Get");
            var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
            var actionContext = new HttpActionContext(contollerContext, actionDescriptor);
            var context = new HttpAuthenticationContext(actionContext, Thread.CurrentPrincipal);
            var metadata = new FilterMetadata
            {
                ControllerType = typeof(TestController),
                FilterScope = FilterScope.Action,
                MethodInfo = methodInfo
            };
            var wrapper = new AuthenticationFilterWrapper(metadata);

            wrapper.OnAuthenticate(context);
            Assert.That(activationCount, Is.EqualTo(1));
        }

        /// <summary>
        /// Override to add registrations to the container.
        /// </summary>
        /// <param name="builder">
        /// The builder through which components can be registered. 
        /// </param>
        /// <remarks>
        /// </remarks>
        protected override void Load(ContainerBuilder builder)
        {
            builder.Register(
                c =>
                CloudStorage.ForAzureAccount(this.account ?? this.Patch(c.Resolve<CloudStorageAccount>())).
                    WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(c.ResolveOptional<IStorageObserver>())
                    .BuildStorageProviders()).OnRelease(p => p.QueueStorage.AbandonAll());

            builder.Register(
                c =>
                CloudStorage.ForAzureAccount(this.account ?? this.Patch(c.Resolve<CloudStorageAccount>())).
                    WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(c.ResolveOptional<IStorageObserver>())
                    .BuildBlobStorage());

            builder.Register(
                c =>
                CloudStorage.ForAzureAccount(this.account ?? this.Patch(c.Resolve<CloudStorageAccount>())).
                    WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(c.ResolveOptional<IStorageObserver>())
                    .BuildQueueStorage()).OnRelease(p => p.AbandonAll());

            builder.Register(
                c =>
                CloudStorage.ForAzureAccount(this.account ?? this.Patch(c.Resolve<CloudStorageAccount>())).
                    WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(c.ResolveOptional<IStorageObserver>())
                    .BuildTableStorage());

            builder.Register(
                c =>
                new NeutralLogStorage
                    {
                        BlobStorage =
                            CloudStorage.ForAzureAccount(this.account ?? this.Patch(c.Resolve<CloudStorageAccount>())).
                            WithDataSerializer(new CloudFormatter()).BuildBlobStorage()
                    });
        }

        public void Instance_is_not_reused_in_different_httprequests()
        {
            var builder = new ContainerBuilder();

            var currentItems = new Dictionary<string, object>();

            var currentContext = new Mock<HttpContextBase>();
            currentContext
                .Setup(c => c.Items)
                .Returns(currentItems);

            builder.DefaultControlledBy(() => new HttpRequestLifecycle
                                                  {
                                                      CurrentContext = currentContext.Object
                                                  });

            builder.Register<IBar, Bar>().ControlledBy<TransientLifecycle>();
            builder.Register<IFoo, Foo>();

            var container = builder.Build();

            var firstResolvedInstanceInContext = container.Resolve<IFoo>();

            currentItems = new Dictionary<string, object>();

            // Simulate new request scope.
            currentContext
                .Setup(c => c.Items)
                .Returns(currentItems);

            var secondResolvedInstanceInContext = container.Resolve<IFoo>();

            Assert.AreNotSame(firstResolvedInstanceInContext, secondResolvedInstanceInContext);
        }

 protected override void Load(ContainerBuilder builder)
 {
     builder.Register(c => new WorkingDirectory(c.Resolve<DirectoryInfo>())).As<IWorkingDirectory>().ContainerScoped();
     builder.Register(c => new Repository(c.Resolve<IWorkingDirectory>())).As<IRepository>().ContainerScoped();
     builder.Register(c => new Index(c.Resolve<IRepository>())).As<IIndex>();
     builder.Register(c => new GitLib()).As<IGit>();
 }

        public void Instance_is_reused_on_same_thread_when_controlled_by_threadsingleton_lifecycle()
        {
            var builder = new ContainerBuilder();

            builder.DefaultControlledBy<ThreadSingletonLifecycle>();
            builder.Register<IFoo, Foo>();
            builder.Register<IBar, Bar>();

            var container = builder.Build();

            var threadData = new ThreadData(container);
            var thread = new Thread(threadData.ResolveFoosWithContainer);

            var threadDataTwo = new ThreadData(container);
            var threadTwo = new Thread(threadDataTwo.ResolveFoosWithContainer);

            thread.Start();
            threadTwo.Start();

            thread.Join();
            threadTwo.Join();

            Assert.IsTrue(ReferenceEquals(threadData.FooOne, threadData.FooTwo));
            Assert.IsFalse(ReferenceEquals(threadData.FooOne, threadDataTwo.FooOne));
        }

        /// <summary>
        /// Main entry point for the program.
        /// </summary>
        /// <param name="args">The arguments.</param>
        static void Main(string[] args)
        {
            var builder = new ContainerBuilder();

            var module = new XamlRegistrationModule();

            builder.Register("Test");

            //builder.Register<IRepository<Foo>, FooRepository>();

            builder.RegisterModule(module);

            builder.Register<IBar, Bar>();

            var container = builder.Build();

            var fooRepository = container.Resolve<IRepository<Foo, Bar>>();

            var fsdfsdfd = fooRepository;

            var func = container.Resolve<Func<string>>();
            var test = func();

            var namedScreen = container.Resolve<WelcomeScreen>();
            namedScreen.WriteText();


            Console.Read();
        }

        /// <summary>
        /// Override to add registrations to the container.
        /// </summary>
        /// <param name="builder">
        /// The builder through which components can be registered. 
        /// </param>
        /// <remarks>
        /// </remarks>
        protected override void Load(ContainerBuilder builder)
        {
            builder.Register(
                c =>
                CloudStorage.ForInMemoryStorage().WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(
                    c.ResolveOptional<IStorageObserver>()).BuildStorageProviders()).OnRelease(
                        p => p.QueueStorage.AbandonAll());

            builder.Register(
                c =>
                CloudStorage.ForInMemoryStorage().WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(
                    c.ResolveOptional<IStorageObserver>()).BuildBlobStorage());

            builder.Register(
                c =>
                CloudStorage.ForInMemoryStorage().WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(
                    c.ResolveOptional<IStorageObserver>()).BuildQueueStorage()).OnRelease(p => p.AbandonAll());

            builder.Register(
                c =>
                CloudStorage.ForInMemoryStorage().WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(
                    c.ResolveOptional<IStorageObserver>()).BuildTableStorage());

            builder.Register(c => new NeutralLogStorage { BlobStorage = new MemoryBlobStorageProvider() });
        }

        private static void RegisterDependencies()
        {
            var builder = new ContainerBuilder();

            builder.Register<IFoo, Foo>().WithArguments("Test Argument", true);
            builder.Register<IBar, Bar>();

            _container = builder.Build();
        }

 void setupIoc()
 {
     Action<MappingConfiguration> mappingConfiguration =
         mappings => mappings.FluentMappings.AddFromAssemblyOf<AttendeeMap>();
     IContainerBuilder builder = new ContainerBuilder();
     builder.Register<INHibernateSessionProvider, SqlServerConnectionStringNHibernateSessionProvider>().WithArguments("nosplanner", mappingConfiguration).ControlledBy<SingletonLifecycle>();
     builder.Register<IAttendeeRepository, AttendeeRepository>().ControlledBy<SingletonLifecycle>();
     _container = builder.Build();
 }

 public static void ConfigureContainer(ContainerBuilder builder)
 {
     builder.Register(c => Mapper.Engine).As<IMappingEngine>();
     builder.Register<TypeMapFactory>().As<ITypeMapFactory>();
     builder.Register(c => AutoMapper.Mappers.MapperRegistry.AllMappers());
     builder.Register<Configuration>()
         .As<Configuration>()
         .As<IConfigurationProvider>()
         .As<IConfiguration>();
 }

        public override void Prepare()
        {
            var builder = new ContainerBuilder();

            builder.Register<ISingleton, Singleton>().ControlledBy<SingletonLifecycle>();
            builder.Register<ITransient, Transient>().ControlledBy<TransientLifecycle>();
            builder.Register<ICombined, Combined>().ControlledBy<TransientLifecycle>();

            this.container = builder.Build();
        }

        public void Container_throws_exception_on_singleresolve_with_multiple_registrations()
        {
            var builder = new ContainerBuilder();
            builder.Register<IFoo, Foo>();
            builder.Register<IFoo, FooTwo>();
            
            var container = builder.Build();

            var foo = container.Resolve<IFoo>();
        }

 public void CanDecorateAndResolveNormalDependencies()
 {
     var builder = new ContainerBuilder();
     builder.Register<AberFakeComponent>().SingletonScoped();
     builder.Register<IFakeComponent, FakeComponent>().With<FakeComponentDecoratorWithOtherDependency>();
     var container = builder.Build();
     var fakeComponent = container.Resolve<IFakeComponent>();
     var fakeComponentDecorator = fakeComponent as FakeComponentDecoratorWithOtherDependency;
     Assert.IsNotNull( fakeComponentDecorator );
     Assert.IsAssignableFrom( typeof( FakeComponent ), fakeComponentDecorator.DecoratedInstance );
 }

        public void ContainerBuilder_with_non_active_groups_throws_registrationNotFoundException()
        {
            var builder = new ContainerBuilder();

            builder.Register<IFoo, FooTwo>().WithGroup( "Test" );
            builder.Register<IFoo, Foo>().WithGroup( "Test2" );

            var container = builder.Build();

            Assert.That(() => container.Resolve<IFoo>(), Throws.InstanceOf<RegistrationNotFoundException>());
        }

        public void Container_resolves_registed_abstract_class()
        {
            var builder = new ContainerBuilder();
            builder.Register<IBar, Bar>();
            builder.Register<FooBase, Foo>();

            var container = builder.Build();
            var instance = container.Resolve<FooBase>();

            Assert.IsInstanceOf<FooBase>(instance);
        }