C# Container.Dispose方法代码示例

        public void T03_Dispose_Other()
        {
            var container = new Container(defaultLifestyle: DefaultLifestyle.Singleton, log: Write);
            container.RegisterTransient<ClassA>();
            var instance = container.Resolve<ClassA>();
            container.Dispose();
            Assert.False(instance.IsDisposed);

            container.RegisterFactory(() => instance);
            container.Dispose();
            Assert.False(instance.IsDisposed);
        }

        public void GCCollect_OnUnreferencedVerifiedContainersWithDecorators_CollectsThoseContainers()
        {
            // Arrange
            Func<Container> buildContainer = () =>
            {
                var container = new Container();
                container.Options.EnableDynamicAssemblyCompilation = false;
                container.Register<INonGenericService, RealNonGenericService>();

                container.RegisterDecorator<INonGenericService, NonGenericServiceDecorator>();

                container.GetInstance<INonGenericService>();

                container.Dispose();

                return container;
            };

            var containers =
                Enumerable.Range(0, 10).Select(_ => new WeakReference(buildContainer())).ToArray();

            // Act
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();

            // Assert
            Assert.AreEqual(0, containers.Count(c => c.IsAlive), "We've got a memory leak.");
        }

        public override TestResult DoTest(ITestCase testCase, int testCasesNumber, bool singleton)
        {
            var result = new TestResult { Singleton = singleton, TestCasesNumber = testCasesNumber };
            var sw = new Stopwatch();

            var c = new Container();
            if (singleton)
            {
                sw.Start();
                c = (Container)testCase.SingletonRegister(c);
                sw.Stop();
            }
            else
            {
                sw.Start();
                c = (Container)testCase.TransientRegister(c);
                sw.Stop();
            }
            result.RegisterTime = sw.ElapsedMilliseconds;

            sw.Reset();
            result.ResolveTime = DoResolve(sw, testCase, c, testCasesNumber, singleton);

            c.Dispose();

            return result;
        }

 public void T02_Dispose_Instance()
 {
     var container = new Container(defaultLifestyle: DefaultLifestyle.Singleton, log: Write);
     var instance = new ClassA();
     container.RegisterInstance(instance);
     container.Dispose();
     Assert.True(instance.IsDisposed);
 }

 public void T01_Dispose_Singleton()
 {
     var container = new Container(defaultLifestyle: DefaultLifestyle.Singleton, log: Write);
     container.RegisterSingleton<ClassA>();
     var instance = container.Resolve<ClassA>();
     container.Dispose();
     Assert.True(instance.IsDisposed);
 }

        public void disposing_a_main_container_will_dispose_an_object_injected_into_the_container()
        {
            var disposable = new C2Yes();
            var container = new Container(x => x.For<C2Yes>().Use(disposable));

            container.Dispose();

            disposable.WasDisposed.ShouldBeTrue();
        }

        public void main_container_should_dispose_singletons()
        {
            var container = new Container(x => { x.ForSingletonOf<C1Yes>().Use<C1Yes>(); });

            var single = container.GetInstance<C1Yes>();

            container.Dispose();

            single.WasDisposed.ShouldBeTrue();
        }

        public void container_scoping_with_root_child_and_nested_container()
        {
            var container = new Container(_ =>
            {
                _.ForConcreteType<Disposable>().Configure.ContainerScoped();
            });

            var child = container.CreateChildContainer();

            var nested = container.GetNestedContainer();

            // Always the same object when requested from the root container
            var mainDisposable = container.GetInstance<Disposable>();
            mainDisposable
                .ShouldBeTheSameAs(container.GetInstance<Disposable>());

            // Always the same object when requested from a child container
            var childDisposable = child.GetInstance<Disposable>();
            childDisposable
                .ShouldBeTheSameAs(child.GetInstance<Disposable>());

            // Always the same object when requested from a nested container
            var nestedDisposable = nested.GetInstance<Disposable>();
            nestedDisposable
                .ShouldBeTheSameAs(nested.GetInstance<Disposable>());

            // It should be a different object instance for
            // all three containers
            mainDisposable
                .ShouldNotBeTheSameAs(childDisposable);

            mainDisposable
                .ShouldNotBeTheSameAs(nestedDisposable);

            childDisposable
                .ShouldNotBeTheSameAs(nestedDisposable);

            // When the nested container is disposed,
            // it should dispose all the container scoped objects,
            // but not impact the other containers
            nested.Dispose();
            nestedDisposable.WasDisposed.ShouldBeTrue();
            childDisposable.WasDisposed.ShouldBeFalse();
            mainDisposable.WasDisposed.ShouldBeFalse();

            // Same for the child container
            child.Dispose();
            childDisposable.WasDisposed.ShouldBeTrue();
            mainDisposable.WasDisposed.ShouldBeFalse();

            // Same for the main container
            container.Dispose();
            mainDisposable.WasDisposed.ShouldBeTrue();
        }

            something_in_the_middle_of_container_that_tries_to_dispose_container_will_not_blow_everything_up_with_a_stack_overflow_exception
            ()
        {
            var container =
                new Container(x => { x.ForSingletonOf<ITryToDisposeContainer>().Use<ITryToDisposeContainer>(); });

            // just want it spun up
            container.GetInstance<ITryToDisposeContainer>();

            container.Dispose();
        }

        public void singletons_are_disposed_when_the_container_is_disposed()
        {
            var container = new Container(_ => { _.ForSingletonOf<DisposableSingleton>(); });

            var singleton = container.GetInstance<DisposableSingleton>();
            singleton.WasDisposed.ShouldBeFalse();

            // now, dispose the Container
            container.Dispose();

            // the singleton scoped object should be disposed
            singleton.WasDisposed.ShouldBeTrue();
        }

        public void ContainerOwnedAndContainerReusedInstacesAreDisposed()
        {
            var container = new Container();
            container.Register<IFoo>(c => new Disposable())
                .ReusedWithin(ReuseScope.Container)
                .OwnedBy(Owner.Container);

            var foo = container.Resolve<IFoo>() as Disposable;

            container.Dispose();

            Assert.IsTrue(foo.IsDisposed);
        }

        public void tracks_transients_built_as_dependencies_in_graph()
        {
            var container = new Container(_ => _.TransientTracking = TransientTracking.ExplicitReleaseMode);

            var root = container.GetInstance<Grandparent>();
            var parent = root.Parent;
            var guy = parent.Guy;

            container.TransientTracking.Tracked.ShouldHaveTheSameElementsAs(guy, parent);

            container.Dispose();

            parent.WasDisposed.ShouldBeTrue();
            guy.WasDisposed.ShouldBeTrue();
        }

        public void the_order()
        {
            var container = new Container();

            using (var runtime = FubuTransport.For<Defaults>().StructureMap(container).Bootstrap())
            {
                var handlers = container.GetInstance<IHandlerPipeline>().ShouldBeOfType<HandlerPipeline>().Handlers;

                container.Dispose();
                handlers[0].ShouldBeOfType<DelayedEnvelopeHandler>();
                handlers[1].ShouldBeOfType<ResponseEnvelopeHandler>();
                handlers[2].ShouldBeOfType<ChainExecutionEnvelopeHandler>();
                handlers[3].ShouldBeOfType<NoSubscriberHandler>();
            }
        }

        public void disposing_the_container_disposes_tracked_transients()
        {
            var container = new Container(_ => _.TransientTracking = TransientTracking.ExplicitReleaseMode);

            var transient1 = container.GetInstance<DisposableGuy>();
            var transient2 = container.GetInstance<DisposableGuy>();

            transient1.WasDisposed.ShouldBeFalse();
            transient2.WasDisposed.ShouldBeFalse();

            container.Dispose();

            transient1.WasDisposed.ShouldBeTrue();
            transient2.WasDisposed.ShouldBeTrue();
        }

        public void object_is_not_disposed_in_nested_container()
        {
            var guy = new DisposableGuy();

            var container = new Container(x => { x.For<DisposableGuy>().Use(guy); });

            using (var nested = container.GetNestedContainer())
            {
            }

            guy.WasDisposed.ShouldBeFalse();

            container.Dispose();

            guy.WasDisposed.ShouldBeTrue();
        }