C# ContainerBuilder.RegisterSource方法代码示例

 public void AServiceProvideByAnotherRegistrationSourceWillNotBeProvided()
 {
     var cb = new ContainerBuilder();
     cb.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
     cb.RegisterSource(new ObjectRegistrationSource());
     var container = cb.Build();
     Assert.True(container.IsRegistered<object>());
     Assert.Equal(1, container.Resolve<IEnumerable<object>>().Count());
 }

        public static void RegisterAutofac()
        {
            var builder = new ContainerBuilder();

            // Register your MVC controllers.
            builder.RegisterControllers(typeof(MvcApplication).Assembly);

            // OPTIONAL: Register model binders that require DI.
            builder.RegisterModelBinders(Assembly.GetExecutingAssembly());
            builder.RegisterModelBinderProvider();

            // OPTIONAL: Register web abstractions like HttpContextBase.
            builder.RegisterModule<AutofacWebTypesModule>();

            // OPTIONAL: Enable property injection in view pages.
            builder.RegisterSource(new ViewRegistrationSource());

            // OPTIONAL: Enable property injection into action filters.
            builder.RegisterFilterProvider();

            // Register services
            RegisterServices(builder);

            // Set the dependency resolver to be Autofac.
            var container = builder.Build();
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
        }

 public void AServiceAlreadyRegisteredWillNotBeProvided()
 {
     var cb = new ContainerBuilder();
     cb.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
     cb.RegisterType<RegisteredType>();
     var container = cb.Build();
     Assert.IsTrue(container.IsRegistered<RegisteredType>());
     Assert.AreEqual(1, container.Resolve<IEnumerable<object>>().Count());
 }

 public ILifetimeScope BeginScope(Action<ContainerBuilder> additionalConfig = null)
 {
     var builder = new ContainerBuilder();
     builder.RegisterSource(new ContravariantRegistrationSource());
     builder.RegisterEventing();
     builder.RegisterInstance(this).AsSelf().AsImplementedInterfaces();
     builder.RegisterAssemblyTypes(typeof(IHandleEvent<>).Assembly, GetType().Assembly)
         .AsSelf()
         .AsImplementedInterfaces()
         .InstancePerLifetimeScope();
     if (additionalConfig != null)
         additionalConfig(builder);
     return builder.Build();
 }

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

        public void LifetimeCanBeInstancePerLifetimeScope()
        {
            var cb = new ContainerBuilder();
            cb.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource().WithRegistrationsAs(rb => rb.InstancePerLifetimeScope()));
            var container = cb.Build();

            var first = container.Resolve<NotRegisteredType>();
            var second = container.Resolve<NotRegisteredType>();
            Assert.Same(first, second);
            using (var scope = container.BeginLifetimeScope())
            {
                var third = scope.Resolve<NotRegisteredType>();
                Assert.NotSame(first, third);
                var fourth = scope.Resolve<NotRegisteredType>();
                Assert.Same(third, fourth);
            }
        }

        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>();
            builder.Register<SingleInstanceFactory>(ctx =>
            {
                var c = ctx.Resolve<IComponentContext>();
                return t => c.Resolve(t);
            });
            builder.Register<MultiInstanceFactory>(ctx =>
            {
                var c = ctx.Resolve<IComponentContext>();
                return t => (IEnumerable<object>) c.Resolve(typeof (IEnumerable<>).MakeGenericType(t));
            });

            var mediator = builder.Build().Resolve<IMediator>();

            return mediator;
        }

        ScopeRestrictedRegistry CreateScopeRestrictedRegistry(object tag, Action<ContainerBuilder> configurationAction)
        {
            var builder = new ContainerBuilder();

            foreach (var source in ComponentRegistry.Sources
                .Where(src => src.IsAdapterForIndividualComponents))
                builder.RegisterSource(source);

            var parents = Traverse.Across<ISharingLifetimeScope>(this, s => s.ParentLifetimeScope)
                .Where(s => s.ComponentRegistry.HasLocalComponents)
                .Select(s => new ExternalRegistrySource(s.ComponentRegistry))
                .Reverse();

            foreach (var external in parents)
                builder.RegisterSource(external);

            configurationAction(builder);

            var locals = new ScopeRestrictedRegistry(tag);
            builder.Update(locals);
            return locals;
        }

 private void ConfigureAutofac()
 {
     var registrationSource = new MefRegistrationSource(CompositionContainer);
     var builder = new ContainerBuilder();
     builder.RegisterSource(registrationSource);
     builder.Update(_context.ComponentRegistry);
 }

 public void TypesIgnoredUsingPredicateAreNotResolvedFromTheContainer()
 {
     var cb = new ContainerBuilder();
     var registrationSource = new AnyConcreteTypeNotAlreadyRegisteredSource(t => !t.IsAssignableTo<string>());
     cb.RegisterSource(registrationSource);
     var container = cb.Build();
     Assert.False(container.IsRegistered<string>());
 }

 static IContainer CreateResolveAnythingContainer()
 {
     var cb = new ContainerBuilder();
     cb.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
     return cb.Build();
 }

		ScopeRestrictedRegistry CreateScopeRestrictedRegistry(object tag, Action<ContainerBuilder> configurationAction)
		{
			var builder = new ContainerBuilder();

			foreach (var source in ComponentRegistry.Sources)
				if (source.IsAdapterForIndividualComponents)
					builder.RegisterSource(source);

			ISharingLifetimeScope current = this;
			var list = new LinkedList<ExternalRegistrySource>();
			while (current != null)
			{
				if (current.ComponentRegistry.HasLocalComponents)
					list.AddFirst(new ExternalRegistrySource(current.ComponentRegistry));
				current = current.ParentLifetimeScope;
			}

			foreach (var external in list)
				builder.RegisterSource(external);

			configurationAction(builder);

			var locals = new ScopeRestrictedRegistry(tag);
			builder.Update(locals);
			return locals;
		}