C# ContainerBuilder.Update方法代码示例

        public void CanResolveReturnsTrueWhenMatchingTypeIsRegistered()
        {
            var builder = new ContainerBuilder();
            builder.Register(c => new object());
            builder.Update(_container);

            Assert.True(_provider.CanResolve<object>());
        }

        public void GetSingletonThrowsDependencyResolutionExceptionIfTypeRegisteredButNotAsSingleton()
        {
            var builder = new ContainerBuilder();
            builder.Register(c => new object());
            builder.Update(_container);

            Assert.Throws<DependencyResolutionException>(() => _provider.GetSingleton<object>());
        }

        public void GetSingletonReturnsSingletonIfTypeRegisteredAsSingleton()
        {
            var builder = new ContainerBuilder();
            builder.Register(c => new object()).SingleInstance();
            builder.Update(container);

            Assert.That(provider.GetSingleton<object>(), Is.TypeOf<object>());
            Assert.That(provider.GetSingleton<object>(), Is.SameAs(provider.GetSingleton<object>()));
        }

        public void GetSingletonReturnsSingletonIfTypeRegisteredAsSingleton()
        {
            var builder = new ContainerBuilder();
            builder.Register(c => new object()).SingleInstance();
            builder.Update(_container);

            Assert.IsType<object>(_provider.GetSingleton<object>());
            Assert.Same(_provider.GetSingleton<object>(), _provider.GetSingleton<object>());
        }

        public void ResolveCreateAndIoCConstructReturnsRegisteredType()
        {
            var builder = new ContainerBuilder();
            builder.Register(c => new object());
            builder.Update(_container);

            Assert.IsType<object>(_provider.Resolve<object>());
            Assert.IsType<object>(_provider.Create<object>());
            Assert.IsType<object>(_provider.IoCConstruct<object>());
        }

 public void RegistrationsMadeByUpdatingAChildScopeDoNotAppearInTheParentScope()
 {
     var container = new ContainerBuilder().Build();
     var childScope = container.BeginLifetimeScope();
     var updater = new ContainerBuilder();
     updater.RegisterType<object>();
     updater.Update(childScope.ComponentRegistry);
     Assert.True(childScope.IsRegistered<object>());
     Assert.False(container.IsRegistered<object>());
 }

        /// <summary>
        /// Updates the current dependency scope with current HTTP request message.
        /// </summary>
        /// <param name="request">The HTTP request message.</param>
        internal static void UpdateScopeWithHttpRequestMessage(HttpRequestMessage request)
        {
            var scope = request.GetDependencyScope();
            var requestScope = scope.GetRequestLifetimeScope();
            if (requestScope == null) return;

            var registry = requestScope.ComponentRegistry;
            var builder = new ContainerBuilder();
            builder.Register(c => request).InstancePerApiRequest();
            builder.Update(registry);
        }

        public static void Register(global::Autofac.IContainer container, MultipleBinding binding)
        {
            var builder = new ContainerBuilder();

            var registration = builder.RegisterTypes(binding.Services.ToArray());

            if (binding.BindTo.Count > 0)
                registration = registration.As(binding.BindTo.ToArray());

            ApplyLifestyleMultiple(registration, binding.Lifestyle);

            builder.Update(container);
        }

        /// <summary>
        ///   Enables Managed Extensibility Framework two-way integration.
        /// </summary>
        /// <param name = "container">Target container.</param>
        /// <returns>
        ///   <see cref = "CompositionIntegration" /> instance.
        /// </returns>
        public static CompositionIntegration EnableCompositionIntegration(this IComponentContext container)
        {
            lock (container)
            {
                if (!container.IsRegistered<CompositionIntegration>())
                {
                    var builder = new ContainerBuilder();
                    builder.EnableCompositionIntegration();
                    builder.Update(container.ComponentRegistry);
                }

                return container.Resolve<CompositionIntegration>();
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AutofacDependencyResolver"/> class.
        /// </summary>
        /// <param name="container">The container that nested lifetime scopes will be create from.</param>
        public AutofacDependencyResolver(ILifetimeScope container)
        {
            if (container == null) throw new ArgumentNullException("container");
            _container = container;

            // Issue 351: Register the AutofacDependencyResolver with
            // the request lifetime scope so the current resolver can
            // be retrieved without having to cast it directly to
            // this specific type.
            // Issue 554: Register the AutofacDependencyResolver here
            // because when using the OWIN pipeline there is no other
            // chance to do so before a per-request lifetime scope is
            // created.
            var updateBuilder = new ContainerBuilder();
            updateBuilder.RegisterInstance(this).As<AutofacDependencyResolver>();
            updateBuilder.Update(container.ComponentRegistry);
        }

        private CompositionContainer PrepareCompositionContainer()
        {
            // Create the MEF container based on the catalog
            var container = new CompositionContainer(_aggregateCatalog, _providers);

            // If desired, register an instance of CompositionContainer and Autofac container in MEF,
            // this will also make CompositionContainer available to the Autofac
            if (Register)
            {
                // Create composition batch and add the MEF container and the Autofac
                // container to the MEF
                var batch = new CompositionBatch();
                batch.AddExportedValue(AutofacCompositionContainerName, container);
                batch.AddExportedValue(_context);
                container.Compose(batch);

                // Create a container builder and register the composition container in Autofac.
                var builder = new ContainerBuilder();
                builder.RegisterInstance(container).OwnedByLifetimeScope();
                builder.Update(_context.ComponentRegistry);
            }

            return container;
        }

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

        /// <summary>
        /// Registers the service and its implementation with the lifetime behavior.
        /// </summary>
        /// <param name="serviceType">Type of the service.</param>
        /// <param name="implementationType">Type of the implementation.</param>
        /// <param name="lifetime">The lifetime of the service.</param>
        /// <returns></returns>
        public override IServiceRegistrar RegisterType(Type serviceType, Type implementationType, LifetimeType lifetime)
        {
            Invariant.IsNotNull(serviceType, "serviceType");
            Invariant.IsNotNull(implementationType, "implementationType");

            var builder = new ContainerBuilder();

            var registration = builder.RegisterType(implementationType).As(serviceType);

            switch (lifetime)
            {
                case LifetimeType.PerRequest:
                    registration.InstancePerHttpRequest();
                    break;
                case LifetimeType.Singleton:
                    registration.SingleInstance();
                    break;
                default:
                    registration.InstancePerDependency();
                    break;
            }

            builder.Update(Container.ComponentRegistry);

            return this;
        }

        /// <summary>
        /// Registers the instance as singleton.
        /// </summary>
        /// <param name="serviceType">Type of the service.</param>
        /// <param name="instance">The instance.</param>
        /// <returns></returns>
        public override IServiceRegistrar RegisterInstance(Type serviceType, object instance)
        {
            Invariant.IsNotNull(serviceType, "serviceType");
            Invariant.IsNotNull(instance, "instance");

            var builder = new ContainerBuilder();

            builder.RegisterInstance(instance).As(serviceType).ExternallyOwned();

            builder.Update(Container.ComponentRegistry);

            return this;
        }

        public void AutoActivate_ContainerUpdateDoesNotAutoActivateExistingComponents()
        {
            int firstCount = 0;
            var builder = new ContainerBuilder();
            builder.RegisterType<MyComponent2>().AutoActivate().OnActivated(e => firstCount++);
            var container = builder.Build();
            Assert.AreEqual(1, firstCount, "The instance component wasn't properly auto activated.");

            int secondCount = 0;
            var builder2 = new ContainerBuilder();
            builder2.RegisterType<MyComponent>().AutoActivate().OnActivated(e => secondCount++);
            builder2.Update(container);
            Assert.AreEqual(1, firstCount, "The first instance component was incorrectly re-activated.");
            Assert.AreEqual(1, secondCount, "The second instance component wasn't properly auto activated.");
        }