C# Container.RegisterInitializer方法代码示例

        public void InterceptWithGenericArgAndPredicate_TwoInterceptors_InterceptsTheInstanceWithBothInterceptors()
        {
            // Arrange
            var logger = new FakeLogger();

            var container = new Container();

            container.RegisterSingleton<ILogger>(logger);
            container.Register<ICommand, CommandThatLogsOnExecute>();

            container.InterceptWith<InterceptorThatLogsBeforeAndAfter>(IsACommandPredicate);
            container.InterceptWith<InterceptorThatLogsBeforeAndAfter2>(IsACommandPredicate);

            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.BeforeText = "Start1 ");
            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter2>(i => i.BeforeText = "Start2 ");
            container.RegisterInitializer<CommandThatLogsOnExecute>(c => c.ExecuteLogMessage = "Executing");
            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.AfterText = " Done1");
            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter2>(i => i.AfterText = " Done2");
            
            // Act
            var command = container.GetInstance<ICommand>();

            command.Execute();

            // Assert
            Assert.AreEqual("Start2 Start1 Executing Done1 Done2", logger.Message);
        }

        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 GetInstance_CalledOnInitializerWithPredicateReturningFalse_CallsPredicateOnceAndDelegateNever()
        {
            // Registration
            int expectedCallCount = 0;
            int actualCallCount = 0;
            int expectedPredicateCallCount = 1;
            int actualPredicateCallCount = 0;

            var container = new Container();

            container.RegisterInitializer(context => actualCallCount++, context =>
            {
                actualPredicateCallCount++;
                return false;
            });

            // Act
            container.GetInstance<RealTimeProvider>();
            container.GetInstance<RealTimeProvider>();
            container.GetInstance<RealTimeProvider>();
            container.GetInstance<RealTimeProvider>();
            container.GetInstance<RealTimeProvider>();

            // Assert
            Assert.AreEqual(expectedCallCount, actualCallCount);
            Assert.AreEqual(expectedPredicateCallCount, actualPredicateCallCount);
        }

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

            container.RegisterWithContext<IContextualLogger>(context => new ContextualLogger(context));

            container.RegisterInitializer<RepositoryThatDependsOnLogger>(_ => { });

            // Act
            var handler = container.GetInstance<RepositoryThatDependsOnLogger>();

            // Assert
            Assert.AreEqual(typeof(RepositoryThatDependsOnLogger), handler.Logger.Context.ServiceType);
            Assert.AreEqual(typeof(RepositoryThatDependsOnLogger), handler.Logger.Context.ImplementationType);
        }

        public void GetInstance_OnUnregisteredConcreteTypeWithoutDependencies_CallsInstanceCreatedOnce()
        {
            // Registration
            int expectedCallCount = 1;
            int actualCallCount = 0;

            var container = new Container();

            container.RegisterInitializer(context => actualCallCount++, TruePredicate);

            // Act
            container.GetInstance<RealTimeProvider>();

            // Assert
            Assert.AreEqual(expectedCallCount, actualCallCount);
        }

        public void Verify_WhenCurrentRequestEndsCalledDuringVerificationOutsideAnHttpContext_Succeeds()
        {
            // Arrange
            bool initializerCalled = false;

            var container = new Container();

            container.Register<DisposableCommand>();

            container.RegisterInitializer<DisposableCommand>(command =>
            {
                WebRequestLifestyle.WhenCurrentRequestEnds(container, () => command.Dispose());
                initializerCalled = true;
            });

            // Act
            container.Verify(VerificationOption.VerifyOnly);

            // Arrange
            Assert.IsTrue(initializerCalled);
        }

        public void Verify_RegisterForDisposalCalledDuringVerification_EnsuresDisposalOfRegisteredDisposable()
        {
            // Arrange
            var disposable = new DisposableObject();

            var scopedLifestyle = new FakeScopedLifestyle(scope: null);

            var container = new Container();

            container.Register<IPlugin>(() => new DisposablePlugin());

            container.RegisterInitializer<IPlugin>(_ =>
            {
                scopedLifestyle.RegisterForDisposal(container, disposable);
            });

            // Act
            container.Verify();

            // Assert
            Assert.IsTrue(disposable.IsDisposedOnce);
        }

        public void Dispose_ExceptionThrownDuringDisposalAfterResolvingNewInstance_DoesNotCallAnyNewActions()
        {
            // Arrange
            bool scopeEndActionCalled = false;

            var scope = new Scope();

            var scopedLifestyle = new FakeScopedLifestyle(scope);

            var container = new Container();

            container.Register<IPlugin>(() => new DisposablePlugin());
            container.RegisterInitializer<IPlugin>(
                plugin => scope.WhenScopeEnds(() => scopeEndActionCalled = true));

            container.Register<DisposableObject>(() => new DisposableObject(_ =>
            {
                container.GetInstance<IPlugin>();
                throw new Exception("Bang!");
            }), scopedLifestyle);

            try
            {
                // Act
                scope.Dispose();

                // Assert
                Assert.Fail("Exception expected.");
            }
            catch
            {
                Assert.IsFalse(scopeEndActionCalled,
                    "In case of an exception, no actions will be further executed. This lowers the change " +
                    "the new exceptions are thrown from other actions that cover up the original exception.");
            }
        }

        public void GetCurrentScope_CalledDuringVerification_ReturnsAScope()
        {
            // Arrange
            Scope scopeDuringVerification = null;

            var scopedLifestyle = new FakeScopedLifestyle(scope: null);

            var container = new Container();

            container.Register<IDisposable>(() => new DisposableObject(), scopedLifestyle);

            container.RegisterInitializer<IDisposable>(_ =>
            {
                scopeDuringVerification = scopedLifestyle.GetCurrentScope(container);
            });

            // Act
            container.Verify();

            // Assert
            Assert.IsNotNull(scopeDuringVerification);
        }

        public void GetInstance_OnRegisteredConcreteTransientTypeWithoutDependencies_CallsInstanceCreatedWithExpectedType()
        {
            // Registration
            var actualContexts = new List<InstanceInitializationData>();

            var container = new Container();

            container.Register<RealTimeProvider>();

            container.RegisterInitializer(actualContexts.Add, TruePredicate);

            // Act
            object instance = container.GetInstance<RealTimeProvider>();

            // Assert
            var actualContext = actualContexts.First().Context;

            Assert.AreSame(container.GetRegistration(typeof(RealTimeProvider)), actualContext.Producer);
            Assert.AreSame(container.GetRegistration(typeof(RealTimeProvider)).Registration, actualContext.Registration);
            Assert.AreSame(instance, actualContexts.First().Instance);
        }

        public void Dispose_WhenDisposeEndsActionRegisteredDuringDisposal_CallsTheRegisteredDelegate()
        {
            // Arrange
            bool actionCalled = false;

            var disposable = new DisposableObject();

            var scope = new Scope();

            var container = new Container();

            container.Register<DisposableObject>(() => disposable, new FakeScopedLifestyle(scope));
            container.RegisterInitializer<DisposableObject>(instance =>
            {
                scope.WhenScopeEnds(() => actionCalled = true);
            });

            scope.WhenScopeEnds(() => container.GetInstance<DisposableObject>());

            // Act
            scope.Dispose();

            // Assert
            Assert.IsTrue(actionCalled);
        }

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

        public void GetInstance_CalledTwiceOnSingletonWithoutDependencies_CallsInstanceCreatedOnce()
        {
            // Registration
            int expectedCallCount = 1;
            int actualCallCount = 0;

            var container = new Container();

            container.Register<RealTimeProvider, RealTimeProvider>(Lifestyle.Singleton);

            container.RegisterInitializer(context => actualCallCount++, TruePredicate);

            // Act
            container.GetInstance<RealTimeProvider>();
            container.GetInstance<RealTimeProvider>();

            // Assert
            Assert.AreEqual(expectedCallCount, actualCallCount);
        }

        public void GetCurrentScope_CalledOnSameThreadDuringVerification_ReturnsTheVerificationScope()
        {
            // Arrange
            Scope verificationScope = null;

            var container = new Container();

            var scope = new Scope();
            var scopedLifestyle = new FakeScopedLifestyle(scope);

            container.Register<IPlugin, DisposablePlugin>(scopedLifestyle);
            container.RegisterInitializer<DisposablePlugin>(p =>
            {
                verificationScope = scopedLifestyle.GetCurrentScope(container);
            });

            // Act
            // When calling verify, we expect DisposablePlugin to be created again.
            container.Verify();

            // Assert
            Assert.AreNotSame(verificationScope, scope);
            Assert.IsTrue(verificationScope.ToString().Contains("VerificationScope"));
        }

        public void GetInstance_ResolvingScopedInstanceWhileDifferentThreadIsVerifying_DoesNotResolveInstanceFromVerificationScope()
        {
            // Arrange
            DisposablePlugin verifiedPlugin = null;
            DisposablePlugin backgroundResolvedPlugin = null;
            Task task = null;

            var container = new Container();

            var scope = new Scope();
            var lifestyle = new FakeScopedLifestyle(scope);

            container.Register<IPlugin, DisposablePlugin>(lifestyle);
            container.RegisterInitializer<DisposablePlugin>(p =>
            {
                verifiedPlugin = p;

                // Resolve on a different thread (so not during verification)
                task = Task.Run(() =>
                {
                    backgroundResolvedPlugin = (DisposablePlugin)container.GetInstance<IPlugin>();
                });

                Thread.Sleep(150);
            });

            // Act
            container.Verify();

            task.Wait();

            // Assert
            Assert.IsFalse(backgroundResolvedPlugin.IsDisposedOnce,
                "Since this instance isn't resolved during verification, but within an active scope, " +
                "The instance should not have been disposed here.");

            scope.Dispose();

            Assert.IsTrue(backgroundResolvedPlugin.IsDisposedOnce, "Now it should have been disposed.");
        }