C# Container.RegisterPerWebRequest方法代码示例

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

            // Act
            container.RegisterPerWebRequest<ConcreteCommand>();
            container.RegisterPerWebRequest<ICommand>(() => new ConcreteCommand());
        }

        public void GetInstance_WithNoHttpContext_FailsWithExpectedException()
        {
            // Arrange
            Assert.IsNull(HttpContext.Current, "Test setup failed.");

            var container = new Container();

            container.RegisterPerWebRequest<ICommand, ConcreteCommand>();

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

                // Assert
                Assert.Fail("Exception expected");
            }
            catch (ActivationException ex)
            {
                Assert.IsTrue(ex.Message.Contains(typeof(ICommand).Name), "Actual: " + ex.Message);
                Assert.IsTrue(
                    ex.Message.Contains("the instance is requested outside the context of a Web Request"),
                    "Actual: " + ex.Message);
            }
        }

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

            // Act
            container.RegisterPerWebRequest<ConcreteCommand>();
        }

        public void Verify_WithNoHttpContext_Succeeds()
        {
            // Arrange
            Assert.IsNull(HttpContext.Current, "Test setup failed.");

            var container = new Container();

            container.RegisterPerWebRequest<ConcreteCommand>();

            // Act
            container.Verify();
        }

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

            container.RegisterPerWebRequest<ICommand, ConcreteCommand>();

            using (new HttpContextScope())
            {
                // Act
                var actualInstance = container.GetInstance<ICommand>();

                // Assert
                AssertThat.IsInstanceOfType(typeof(ConcreteCommand), actualInstance);
            }
        }

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

            container.RegisterPerWebRequest<ICommand, ConcreteCommand>();

            using (new HttpContextScope())
            {
                // Act
                var firstInstance = container.GetInstance<ICommand>();
                var secondInstance = container.GetInstance<ICommand>();

                // Assert
                Assert.IsTrue(object.ReferenceEquals(firstInstance, secondInstance));
            }
        }

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

            // Same as previous test, but now with RegisterDecorator called first.
            container.RegisterDecorator(typeof(ICommand), typeof(CommandDecorator));

            container.RegisterPerWebRequest<ICommand, ConcreteCommand>();

            using (new HttpContextScope())
            {
                // Act
                var decorator1 = (CommandDecorator)container.GetInstance<ICommand>();
                var decorator2 = (CommandDecorator)container.GetInstance<ICommand>();

                // Assert
                Assert.IsFalse(object.ReferenceEquals(decorator1, decorator2),
                    "The decorator should be transient but seems to have a scoped lifetime.");

                Assert.IsTrue(object.ReferenceEquals(decorator1.DecoratedInstance, decorator2.DecoratedInstance),
                    "The decorated instance should be scoped per lifetime. It seems to be transient.");
            }
        }

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

            container.RegisterPerWebRequest<ICommand, ConcreteCommand>();

            container.RegisterDecorator(typeof(ICommand), typeof(CommandDecorator));

            using (new HttpContextScope())
            {
                // Act
                ICommand instance = container.GetInstance<ICommand>();

                // Assert
                AssertThat.IsInstanceOfType(typeof(CommandDecorator), instance);

                var decorator = (CommandDecorator)instance;

                AssertThat.IsInstanceOfType(typeof(ConcreteCommand), decorator.DecoratedInstance);
            }
        }

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

            container.RegisterPerWebRequest<DisposableCommand>();

            DisposableCommand command;

            // Act
            using (new HttpContextScope())
            {
                command = container.GetInstance<DisposableCommand>();
            }

            // Assert
            Assert.IsTrue(command.HasBeenDisposed, "The instance was expected to be disposed.");
        }

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

            // This locks the container.
            container.GetInstance<ConcreteCommand>();

            try
            {
                // Act
                container.RegisterPerWebRequest<ICommand, ConcreteCommand>();

                // Assert
                Assert.Fail("Exception expected.");
            }
            catch (InvalidOperationException ex)
            {
                Assert.IsTrue(ex.Message.Contains("The container can't be changed"),
                    "Actual: " + ex.Message);
            }
        }

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

            container.RegisterPerWebRequest<DisposableCommand>();

            DisposableCommand command;

            // Act
            using (new HttpContextScope())
            {
                command = container.GetInstance<DisposableCommand>();

                container.GetInstance<DisposableCommand>();
                container.GetInstance<DisposableCommand>();
            }

            // Assert
            Assert.AreEqual(1, command.DisposeCount, "Dispose should be called exactly once.");
        }

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

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

            container.RegisterPerWebRequest<IDisposable, DisposableCommand>();

            DisposableCommand singleton;

            // Act
            using (new HttpContextScope())
            {
                singleton = container.GetInstance<DisposableCommand>();
            }

            // Assert
            Assert.IsFalse(singleton.HasBeenDisposed, "Singletons should not be disposed.");
        }

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

            container.RegisterPerWebRequest<DisposableCommand>();

            // Act
            using (new HttpContextScope())
            {
                var command = container.GetInstance<DisposableCommand>();

                // Assert
                Assert.IsFalse(command.HasBeenDisposed, "The instance should not be disposed inside the scope.");
            }
        }

 private void RegisterChocolateySpecific(Container container)
 {
     container.RegisterPerWebRequest<IUserSiteProfilesService, UserSiteProfilesService>();
     container.RegisterPerWebRequest<IEntityRepository<UserSiteProfile>, EntityRepository<UserSiteProfile>>();
     container.Register<IImageFileService, ImageFileService>(Lifestyle.Singleton);
     container.RegisterPerWebRequest<IEntityRepository<ScanResult>, EntityRepository<ScanResult>>();
     container.RegisterPerWebRequest<IScanService, ScanService>();
 }

        public void GetInstance_PerWebRequestFuncInstanceWithInitializer_CallsInitializerOncePerWebRequest()
        {
            // Arrange
            int callCount = 0;

            var container = new Container();

            container.RegisterPerWebRequest<ICommand>(() => new ConcreteCommand());

            container.RegisterInitializer<ICommand>(command => { callCount++; });

            using (new HttpContextScope())
            {
                // Act
                container.GetInstance<ICommand>();
                container.GetInstance<ICommand>();
            }

            // Assert
            Assert.AreEqual(1, callCount, "The initializer for ICommand is expected to get fired once.");
        }