C# Container.InterceptWith方法代码示例

        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 InterceptWithGenericArgAndPredicate_InterceptingATransientWithSingletonInterceptor_ResultsInATransientProxy()
        {
            // Arrange
            var container = new Container();

            container.Register<ICommand, FakeCommand>();

            container.Register<FakeInterceptor>(Lifestyle.Singleton);

            container.InterceptWith<FakeInterceptor>(IsACommandPredicate);

            // Act
            var command1 = container.GetInstance<ICommand>();
            var command2 = container.GetInstance<ICommand>();

            // Assert
            Assert.IsFalse(object.ReferenceEquals(command1, command2), "The proxy is expected to " +
                "be transient, since the interceptee is transient.");
        }

        public void CallingAnInterceptedMethod_InterceptorThatChangesTheInputParameters_GetsForwardedToTheInterceptee()
        {
            // Arrange  
            string expectedValue = "XYZ";

            var container = new Container();

            var interceptee = new WithOutAndRef();

            var interceptor = new DelegateInterceptor();

            interceptor.Intercepting += invocation =>
            {
                invocation.Arguments[0] = expectedValue;
            };

            container.RegisterSingleton<IWithOutAndRef>(interceptee);
            container.InterceptWith(interceptor, IsInterface);

            var intercepted = container.GetInstance<IWithOutAndRef>();

            // Act
            string refValue = "Something different";
            string unused;
            intercepted.Operate(ref refValue, out unused);

            // Assert
            Assert.AreEqual(expectedValue, interceptee.SuppliedRefValue);
        }

        public void CallingInterceptedMethodWithReturnValue_InterceptedWithPassThroughInterceptor_ReturnsTheExpectedValue()
        {
            // Arrange
            int expectedReturnValue = 3;

            var container = new Container();

            var interceptee = new WithOutAndRef { ReturnValue = expectedReturnValue };

            container.RegisterSingleton<IWithOutAndRef>(interceptee);

            container.InterceptWith<FakeInterceptor>(IsInterface);

            var intercepted = container.GetInstance<IWithOutAndRef>();

            // Act
            string unused1 = null;
            string unused2;
            int actualReturnValue = intercepted.Operate(ref unused1, out unused2);

            // Assert
            Assert.AreEqual(expectedReturnValue, actualReturnValue);
        }

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

            var container = new Container();

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

            container.Register(typeof(IValidator<>), typeof(LoggingValidator<>));

            container.RegisterDecorator(typeof(IValidator<>), typeof(LoggingValidatorDecorator<>));

            container.InterceptWith<InterceptorThatLogsBeforeAndAfter>(
                t => t.IsInterface && t.Name.StartsWith("IValidator"));

            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.BeforeText = "Inercepting ");
            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.AfterText = "Intercepted ");

            // Act
            container.GetInstance<IValidator<RealCommand>>().Validate(new RealCommand());

            // Assert
            Assert.AreEqual("Inercepting Decorating Validating Decorated Intercepted ", logger.Message);
        }

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

            container.Register<ICommand, FakeCommand>();

            try
            {
                // Act
                container.InterceptWith<InterceptorWithInternalConstructor>(IsACommandPredicate);

                // Assert
                Assert.Fail("Exception expected.");
            }
            catch (ActivationException ex)
            {
                Assert.IsTrue(ex.Message.Contains("For the container to be able to create " + 
                    "InterceptorExtensionsTests.InterceptorWithInternalConstructor, it should contain " +
                    "exactly one public constructor"),
                    "Actual: " + ex.Message);
            }
        }

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

            container.Register<ICommand, FakeCommand>(Lifestyle.Singleton);
            container.Register<ILogger, FakeLogger>(Lifestyle.Singleton);

            container.InterceptWith(e => new BuiltInfoInterceptor(e), type => type.IsInterface);

            // Act
            var command = container.GetInstance<ICommand>();
            var logger = container.GetInstance<ILogger>();

            command.Execute();
            logger.Log("foo");
        }

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

            var interceptor = new FakeInterceptor();

            container.Register<ICommand, FakeCommand>(Lifestyle.Singleton);

            container.InterceptWith(() => interceptor, IsACommandPredicate);

            // Act
            var command1 = container.GetInstance<ICommand>();
            var command2 = container.GetInstance<ICommand>();

            // Assert
            Assert.IsFalse(object.ReferenceEquals(command1, command2), "The proxy is expected to " +
                "be transient, since the interceptor is created using a Func<T>, and there is no way to " +
                "determine whether the delegate always returns the same or a new instance.");
        }

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

            Func<IInterceptor> interceptorCreator1 = () => new InterceptorThatLogsBeforeAndAfter(logger)
            {
                BeforeText = "Start1 ",
                AfterText = " Done1"
            };

            Func<IInterceptor> interceptorCreator2 = () => new InterceptorThatLogsBeforeAndAfter(logger)
            {
                BeforeText = "Start2 ",
                AfterText = " Done2"
            };

            var container = new Container();

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

            container.InterceptWith(interceptorCreator1, IsACommandPredicate);
            container.InterceptWith(interceptorCreator2, IsACommandPredicate);

            container.RegisterInitializer<CommandThatLogsOnExecute>(c => c.ExecuteLogMessage = "Executing");

            // Act
            var command = container.GetInstance<ICommand>();

            command.Execute();

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

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

            var interceptor = new FakeInterceptor();

            container.Register<ICommand, FakeCommand>();

            container.InterceptWith(interceptor, IsACommandPredicate);

            // Act
            var command1 = container.GetInstance<ICommand>();
            var command2 = container.GetInstance<ICommand>();

            // Assert
            Assert.IsFalse(object.ReferenceEquals(command1, command2), "The proxy is expected to " +
                "be transient, since the interceptee is transient.");
        }

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

            container.Register<ICommand, FakeCommand>();

            // Act
            Action action = () => container.InterceptWith<InterceptorWithInternalConstructor>(IsACommandPredicate);

            // Assert
            AssertThat.ThrowsWithExceptionMessageContains<ActivationException>(
                "For the container to be able to create " +
                "InterceptorExtensionsTests.InterceptorWithInternalConstructor it should have only " +
                "one public constructor",
                action);
        }

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

            container.Register<ICommand, FakeCommand>();

            // The interceptor depends on ILogger, but it is not registered.
            container.InterceptWith<InterceptorWithDependencyOnLogger>(IsACommandPredicate);

            try
            {
                // Act
                container.GetInstance<ICommand>();

                // Assert
                Assert.Fail("Exception expected.");
            }
            catch (ActivationException ex)
            {
                Assert.IsTrue(ex.Message.Contains("The constructor of type " +
                    "InterceptorExtensionsTests.InterceptorWithDependencyOnLogger contains the parameter " +
                    "with name 'logger' and type ILogger that is not registered."),
                    "Actual: " + ex.Message);
            }
        }