C# Container.AddRegistration方法代码示例

        public override void Build(Container container)
        {
            var factoryType = container.GetFactoryForType(this.ServiceType.Type);
            var creator = new AbstractFactoryCreator(factoryType);
            var registration = new TransientRegistration(creator);

            container.AddRegistration(new TypeKey(this.ServiceType.Type.TypeHandle, this.ServiceType.Key), registration);
        }

        public override void Build(Container container)
        {
            var creator = new InstanceCreator(this.instance);
            var registration = this.CreateRegistration(container, creator);

            foreach (var serviceType in this.ServiceTypes)
            {
                container.AddRegistration(new TypeKey(serviceType.Type.TypeHandle, serviceType.Key), registration);
            }
        }

        public void AddRegistration_SuppliedWithOpenGenericServiceType_ThrowsExpectedException()
        {
            // Arrange
            Container container = new Container();

            var registration = Lifestyle.Transient.CreateRegistration<StructCommandHandler>(container);

            // Act
            Action action = () => container.AddRegistration(typeof(ICommandHandler<>), registration);

            // Assert
            AssertThat.ThrowsWithExceptionMessageContains<ArgumentException>(
                "The supplied type ICommandHandler<TCommand> is an open generic type.",
                action);
            AssertThat.ThrowsWithParamName("serviceType", action);
        }

        public void Analyze_MismatchWithSuppressDiagnosticWarning_NoWarning()
        {
            // Arrange
            var container = new Container();

            container.Register<IUserRepository, InMemoryUserRepository>();

            var registration = 
                Lifestyle.Singleton.CreateRegistration<UserServiceBase, RealUserService>(container);

            container.AddRegistration(typeof(UserServiceBase), registration);

            container.Options.SuppressLifestyleMismatchVerification = true;

            container.Verify(VerificationOption.VerifyOnly);

            registration.SuppressDiagnosticWarning(DiagnosticType.PotentialLifestyleMismatch);

            container.Options.SuppressLifestyleMismatchVerification = false;

            container.Verify(VerificationOption.VerifyOnly);

            // Act
            var results = Analyzer.Analyze(container).OfType<PotentialLifestyleMismatchDiagnosticResult>()
                .ToArray();

            // Assert
            Assert.AreEqual(0, results.Length, Actual(results));
        }

        public void Analyze_TwoRegistrationsForTheSameImplementationMadeWithTheSameRegistrationInstanceWrappedBySingletonDecorators_DoesNotReturnsAWarning()
        {
            // Arrange
            var container = new Container();

            var reg = Lifestyle.Singleton.CreateRegistration<FooBar>(container);

            container.AddRegistration(typeof(IFoo), reg);
            container.AddRegistration(typeof(IBar), reg);

            container.RegisterDecorator(typeof(IBar), typeof(BarDecorator), Lifestyle.Singleton);

            container.Verify();

            // Act
            var results = Analyzer.Analyze(container).OfType<TornLifestyleDiagnosticResult>().ToArray();

            // Assert
            Assert.AreEqual(0, results.Length, Actual(results));
        }

        public void Analyze_TwoSingletonRegistrationsMappedOnFourServiceTypes_ReturnsExpectedWarnings()
        {
            // Arrange
            string expectedMessage1 =
                "The registration for IFoo maps to the same implementation and lifestyle as the " +
                "registrations for IBar and IBarExt do.";

            string expectedMessage2 =
            "The registration for IBar maps to the same implementation and lifestyle as the " +
            "registrations for IFoo and IFooExt do.";

            var container = new Container();

            var fooReg = Lifestyle.Singleton.CreateRegistration<FooBar>(container);
            var barReg = Lifestyle.Singleton.CreateRegistration<FooBar>(container);

            container.AddRegistration(typeof(IFoo), fooReg);
            container.AddRegistration(typeof(IFooExt), fooReg);
            container.AddRegistration(typeof(IBar), barReg);
            container.AddRegistration(typeof(IBarExt), barReg);

            container.Verify(VerificationOption.VerifyOnly);

            // Act
            var results = Analyzer.Analyze(container).OfType<TornLifestyleDiagnosticResult>().ToArray();

            // Assert
            Assert.AreEqual(4, results.Length, Actual(results));

            Assert_ContainsDescription(results, expectedMessage1);
            Assert_ContainsDescription(results, expectedMessage2);
        }

        public void Analyze_TwoDistinctRegistrationsForSameLifestyle_ReturnsWarning()
        {
            // Arrange
            var container = new Container();

            var fooReg = Lifestyle.Singleton.CreateRegistration<IFoo, FooBar>(container);
            var barReg = Lifestyle.Singleton.CreateRegistration<IBar, FooBar>(container);

            container.AddRegistration(typeof(IFoo), fooReg);
            container.AddRegistration(typeof(IBar), barReg);

            container.Verify(VerificationOption.VerifyOnly);

            // Act
            var results = Analyzer.Analyze(container).OfType<TornLifestyleDiagnosticResult>().ToArray();

            // Assert
            Assert.AreEqual(2, results.Length, Actual(results));
        }

        protected void BindImplementationToServices(Container container, Type implementationType)
        {
            if (this.ServiceTypes.Count > 1)
            {
                var firstGenericType = this.ServiceTypes.FirstOrDefault(x => x.Type.IsGenericTypeDefinition);

                if (firstGenericType != null)
                    throw new StyletIoCRegistrationException(String.Format("Cannot create a multiple-service binding with an unbound generic type {0}", firstGenericType.Type.GetDescription()));

                var creator = new TypeCreator(implementationType, container);
                var registration = this.CreateRegistration(container, creator);

                foreach (var serviceType in this.ServiceTypes)
                {
                    container.AddRegistration(new TypeKey(serviceType.Type.TypeHandle, serviceType.Key ?? creator.AttributeKey), registration);
                }
            }
            else
            {
                this.BindImplementationToSpecificService(container, implementationType, this.ServiceTypes[0].Type, this.ServiceTypes[0].Key);
            }
        }

        // Convenience...
        protected void BindImplementationToSpecificService(Container container, Type implementationType, Type serviceType, string key)
        {
            if (serviceType.IsGenericTypeDefinition)
            {
                var unboundGeneric = new UnboundGeneric(serviceType, implementationType, container, this.RegistrationFactory);
                container.AddUnboundGeneric(new TypeKey(serviceType.TypeHandle, key), unboundGeneric);
            }
            else
            {
                var creator = new TypeCreator(implementationType, container);
                var registration = this.CreateRegistration(container, creator);

                container.AddRegistration(new TypeKey(serviceType.TypeHandle, key ?? creator.AttributeKey), registration);
            }
        }