C# Container.RegisterCollection方法代码示例

        public void Intercept_CollectionWithRegistrationInstances_InterceptsTheInstances()
        {
            var logger = new FakeLogger();

            var container = new Container();

            container.RegisterSingleton<ILogger>(logger);
            container.RegisterCollection<ICommand>(new[] 
            {
                Lifestyle.Transient.CreateRegistration(typeof(ICommand), typeof(ConcreteCommand), container),
                Lifestyle.Transient.CreateRegistration(typeof(ConcreteCommand), container),
            });

            container.InterceptWith<InterceptorThatLogsBeforeAndAfter>(IsACommandPredicate);

            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.BeforeText = "Log ");

            // Act
            var commands = container.GetAllInstances<ICommand>().ToList();

            commands.ForEach(Execute);

            // Assert
            Assert.AreEqual("Log Log ", logger.Message);
        }

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

            var plugins = new KeyedRegistrations<string, IPlugin>(container);

            container.Options.DependencyInjectionBehavior = new NamedDependencyInjectionBehavior(
                container.Options.DependencyInjectionBehavior,
                (serviceType, name) => plugins.GetRegistration(name));

            plugins.Register(typeof(Plugin1), "1");
            plugins.Register<Plugin2>("2");
            plugins.Register(typeof(Plugin3), "3", Lifestyle.Singleton);
            plugins.Register(() => new Plugin("4"), "4");
            plugins.Register(() => new Plugin("5"), "5", Lifestyle.Singleton);

            container.RegisterCollection<IPlugin>(plugins);

            container.RegisterDecorator(typeof(IPlugin), typeof(PluginDecorator), Lifestyle.Singleton,
                context => context.ImplementationType == typeof(Plugin3));

            container.RegisterSingleton<Func<string, IPlugin>>(key => plugins.GetInstance(key));

            container.Verify();

            // Act
            var actualPlugins1 = container.GetAllInstances<IPlugin>().ToArray();
            var actualPlugins2 = container.GetAllInstances<IPlugin>().ToArray();
            var factory = container.GetInstance<Func<string, IPlugin>>();
            var consumer = container.GetInstance<NamedPluginConsumer>();

            // Assert
            AssertThat.IsInstanceOfType(typeof(Plugin1), actualPlugins1[0]);
            AssertThat.IsInstanceOfType(typeof(Plugin2), actualPlugins1[1]);
            AssertThat.IsInstanceOfType(typeof(PluginDecorator), actualPlugins1[2]);
            AssertThat.IsInstanceOfType(typeof(Plugin), actualPlugins1[3]);
            AssertThat.IsInstanceOfType(typeof(Plugin), actualPlugins1[4]);

            AssertThat.IsInstanceOfType(typeof(Plugin1), factory("1"));
            AssertThat.IsInstanceOfType(typeof(Plugin2), factory("2"));
            AssertThat.IsInstanceOfType(typeof(PluginDecorator), factory("3"));
            AssertThat.IsInstanceOfType(typeof(Plugin), factory("4"));
            AssertThat.IsInstanceOfType(typeof(Plugin), factory("5"));

            Assert.AreNotSame(actualPlugins1[0], actualPlugins2[0]);
            Assert.AreNotSame(actualPlugins1[1], actualPlugins2[1]);
            Assert.AreSame(actualPlugins1[2], actualPlugins2[2]);
            Assert.AreNotSame(actualPlugins1[3], actualPlugins2[3]);
            Assert.AreSame(actualPlugins1[4], actualPlugins2[4]);

            AssertThat.IsInstanceOfType(typeof(Plugin1), consumer.Plugin1);
            AssertThat.IsInstanceOfType(typeof(Plugin2), consumer.Plugin2);
            AssertThat.IsInstanceOfType(typeof(PluginDecorator), consumer.Plugin3);
            AssertThat.IsInstanceOfType(typeof(Plugin), consumer.Plugin4);
        }

        private static IMediator BuildMediator()
        {
            var container = new Container();
            var assemblies = GetAssemblies().ToArray();
            container.RegisterSingleton<IMediator, Mediator>();
            container.Register(typeof(IRequestHandler<,>), assemblies);
            container.Register(typeof(IAsyncRequestHandler<,>), assemblies);
            container.RegisterCollection(typeof(INotificationHandler<>), assemblies);
            container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);
            container.RegisterSingleton(Console.Out);
            container.RegisterSingleton(new SingleInstanceFactory(container.GetInstance));
            container.RegisterSingleton(new MultiInstanceFactory(container.GetAllInstances));

            container.Verify();

            var mediator = container.GetInstance<IMediator>();

            return mediator;
        }

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

            container.RegisterCollection<IPlugin>(new[] { typeof(SomePluginImpl) });

            container.Verify();

            // Act
            var results = Analyzer.Analyze(container);

            // Assert
            Assert.AreEqual(0, results.Length,
                "Since the SomePluginImpl is registered explicitly using the RegisterAll method, this " +
                "registration should contain no warnings, but the following warnings are present: \"" +
                string.Join(" ", results.Select(result => result.Description)) + "\"");
        }

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

            container.Register<Consumer<IReadOnlyCollection<ILogger>>>();

            // Since this collection is registered, the previous registration should not yield a warning.
            container.RegisterCollection<ILogger>(new[] { typeof(NullLogger) });

            container.Verify();

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

            // Assert
            Assert.AreEqual(0, results.Length, "actual: " + string.Join(" - ", results.Select(r => r.Description)));
        }

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

            container.Register(typeof(IGeneric<>), typeof(GenericType<>));

            container.RegisterCollection<IPlugin>(new[] { typeof(PluginWith8Dependencies) });

            container.Verify();
            
            // Act
            var results = Analyzer.Analyze(container);

            // Assert
            Assert.AreEqual(1, results.Length, "An SRP violation is expected.");

            Assert.AreEqual(1, results.OfType<SingleResponsibilityViolationDiagnosticResult>().Count(),
                "An SRP violation is expected.");
        }

        public void GetInstance_CalledForDecoratedUncontrolledCollection_CallsEventForBothTheInstanceAndTheDecorator()
        {
            // Arrange
            var actualContexts = new List<InstanceInitializationData>();

            var container = new Container();

            // Container uncontrolled collection
            IEnumerable<ICommandHandler<RealCommand>> handlers = new ICommandHandler<RealCommand>[]
            {
                new StubCommandHandler(),
            };

            container.RegisterCollection<ICommandHandler<RealCommand>>(handlers);

            container.RegisterInitializer(actualContexts.Add, TruePredicate);

            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(RealCommandHandlerDecorator));

            // Act
            var producer = container.GetRegistration(typeof(IEnumerable<ICommandHandler<RealCommand>>));

            var decorator = container.GetAllInstances<ICommandHandler<RealCommand>>().Single()
                as RealCommandHandlerDecorator;

            // Assert
            Assert.AreEqual(2, actualContexts.Count, "Two event args were expected.");

            Assert.AreSame(producer, actualContexts.First().Context.Producer);
            Assert.AreSame(producer, actualContexts.Second().Context.Producer);

            Assert.AreEqual(
                typeof(IEnumerable<ICommandHandler<RealCommand>>), 
                actualContexts.First().Context.Registration.ImplementationType);

            Assert.AreEqual(
                typeof(RealCommandHandlerDecorator),
                actualContexts.Second().Context.Registration.ImplementationType);
        }

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

            var reg1 = Lifestyle.Singleton.CreateRegistration<FooBar>(() => new FooBar(), container);
            var reg2 = Lifestyle.Singleton.CreateRegistration<FooBar>(() => new FooBarSub(), container);

            container.RegisterCollection(typeof(IFoo), new[] { reg1, reg2 });

            container.Verify();

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

            // Assert
            Assert.AreEqual(0, results.Length,
                "Since the two registrations both use a delegate, there's no way of knowing what the actual " +
                "implementation type is, and we should therefore not see a warning in this case. " +
                Actual(results));
        }

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

            container.RegisterCollection<ICommandHandler<RealCommand>>(new[] { typeof(RealCommandHandler) });

            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(TransactionHandlerDecorator<>));
            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(ContextualHandlerDecorator<>));

            // Act
            var decorator = (ContextualHandlerDecorator<RealCommand>)
                container.GetAllInstances<ICommandHandler<RealCommand>>().Single();

            DecoratorContext context = decorator.Context;

            // Assert
            Assert.AreSame(typeof(ICommandHandler<RealCommand>), context.ServiceType);
            Assert.AreSame(typeof(RealCommandHandler), context.ImplementationType);
            Assert.AreSame(typeof(TransactionHandlerDecorator<RealCommand>), context.AppliedDecorators.Single());
            Assert.AreEqual("new TransactionHandlerDecorator`1(new RealCommandHandler())",
                context.Expression.ToString());
            Assert.AreEqual("ServiceType = ICommandHandler<RealCommand>, ImplementationType = RealCommandHandler",
                context.DebuggerDisplay);
        }

        public void GetAllInstances_UncontrolledRegisterDecoratorWithPredicateReturningFalse_DoesNotCallTheFactory()
        {
            // Arrange
            bool decoratorTypeFactoryCalled = false;

            var container = new Container();

            IEnumerable<ICommandHandler<RealCommand>> uncontrolledCollection = new[] { new RealCommandHandler() };

            container.RegisterCollection<ICommandHandler<RealCommand>>(uncontrolledCollection);

            var parameters = RegisterDecoratorFactoryParameters.CreateValid();

            parameters.Predicate = context => false;
            parameters.ServiceType = typeof(ICommandHandler<>);

            parameters.DecoratorTypeFactory = context =>
            {
                decoratorTypeFactoryCalled = true;
                return typeof(TransactionHandlerDecorator<>);
            };

            container.RegisterDecorator(parameters);

            // Act
            var handler = container.GetAllInstances<ICommandHandler<RealCommand>>().Single();

            // Assert
            Assert.IsFalse(decoratorTypeFactoryCalled, @"
                The factory should not be called if the predicate returns false. This prevents the user from 
                having to do specific handling when the decorator type can't be constructed because of generic 
                type constraints.");
        }

        public void RegisterAll_RegisteringAnInternalType_ThrowsExpectedException()
        {
            // Arrange
            string expectedMessage = ExpectedSandboxFailureExpectedMessage;

            var container = new Container();

            IEnumerable instances = new[] { new InternalServiceImpl(null) };

            try
            {
                // Act
                container.RegisterCollection(typeof(IInternalService), instances);

                Assert.Fail("The call is expected to fail inside a Silverlight sandbox.");
            }
            catch (ArgumentException ex)
            {
                // Assert
                AssertThat.StringContains(expectedMessage, ex.Message);
            }
        }

        public void VisualizeObjectGraph_DelayedCyclicReference_VisualizesTheExpectedObjectGraph()
        {
            // Arrange
            string expectedGraph = @"InstanceProducerTests.NodeFactory(
    IEnumerable<InstanceProducerTests.INode>(
        InstanceProducerTests.NodeFactory(
            IEnumerable<InstanceProducerTests.INode>(/* cyclic dependency graph detected */))))";

            var container = new Container();

            // class NodeOne(INodeFactory factory)
            container.RegisterCollection<INode>(new[] { typeof(NodeOne) });

            // class NodeFactory(IEnumerable<INode>)
            container.Register<INodeFactory, NodeFactory>();

            container.Verify();

            var registration = container.GetRegistration(typeof(INodeFactory));

            // Act
            // Since the dependency is delayed,
            string actualGraph = registration.VisualizeObjectGraph();

            // Assert
            Assert.AreEqual(expectedGraph, actualGraph);
        }

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

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

            container.RegisterCollection(typeof(IFoo), new[] { reg1, reg2 });

            container.Verify(VerificationOption.VerifyOnly);

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

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

        public void GetInstance_CalledForDecoratedCollection_CallsEventForBothTheInstanceAndTheDecorator()
        {
            // Arrange
            var actualContexts = new List<InstanceInitializationData>();

            var container = new Container();

            container.RegisterCollection<ICommandHandler<RealCommand>>(new[] { typeof(StubCommandHandler) });

            container.RegisterInitializer(actualContexts.Add, TruePredicate);

            container.RegisterDecorator(typeof(ICommandHandler<>), typeof(RealCommandHandlerDecorator));

            // Act
            var decorator = container.GetAllInstances<ICommandHandler<RealCommand>>().Single()
                as RealCommandHandlerDecorator;

            // Assert
            // TODO: The container should actually call InstanceCreated for the IEnumerable<T> as well.
            Assert.AreEqual(2, actualContexts.Count, "Two event args were expected.");

            Assert.AreEqual(typeof(StubCommandHandler), actualContexts.First().Context.Registration.ImplementationType);
            Assert.AreEqual(typeof(RealCommandHandlerDecorator), actualContexts.Second().Context.Registration.ImplementationType);
        }