C# IocContainer.Compile方法代码示例

        public void CompileCanInlineRegistrationsWithContainerLifetime()
        {
            // Doesnt check that Compile actually works - just that it doesnt break anything

            using (var container = new IocContainer())
            {
                container.Register<IFoo>(x => new Foo1()).ContainerLifetime();
                container.Register<IBar>(x => new Bar1());

                var reg = container.Register<IFooBar>(x => new FooBar(x.Resolve<IFoo>(), x.Resolve<IBar>()));

                container.Compile();

                var result1 = container.Resolve<IFoo>();
                var result2 = (IFooBar)container.Resolve(reg);

                Assert.AreEqual(result1, result2.Foo);
            }
        }

        public void CompileCanInlineInstanceRegistrations()
        {
            // Doesnt check that Compile actually works - just that it doesnt break anything

            using (var container = new IocContainer())
            {
                var i1 = new Foo1();
                var i2 = new Bar1();

                container.RegisterInstance(i1);
                container.RegisterInstance(i2);

                var reg1 = container.Register<IFooBar>(x => new FooBar(x.Resolve<Foo1>(), x.Resolve<Bar1>()));

                container.Compile();

                var result = (IFooBar)container.Resolve(reg1);

                Assert.AreEqual(i1, result.Foo);
            }
        }

		public void CompileUsingKeyDoesntBreakUsingCompileModeDynamicWhenUsingInstanceRegistrationOrContainerLifetime()
		{
			// Test that InstanceRegistration and ContainerLifetime works using CompileMode Dynamic (should not be inlined)

			using (var container = new IocContainer(defaultCompileMode: CompileMode.Dynamic))
			{
				var barInstance = new Bar1();

				var reg1 = container.Register<IFoo, Foo1>("FirstKey").WithContainerLifetime();
				var reg2 = container.RegisterInstance<IBar>(barInstance, "SecondKey");

				var reg3 = container.Register<IFooBar>(x => new FooBar(x.Resolve<IFoo>("FirstKey"), x.Resolve<IBar>("SecondKey")));

				container.Compile();

				var res1 = container.Resolve<IFooBar>();
				var res2 = container.Resolve<IFooBar>();

				// Assert
				Assert.AreNotSame(res1, res2);
				Assert.AreSame(barInstance, res1.Bar);
				Assert.AreSame(res1.Foo, res2.Foo);
			}
		}

		public void RegisterAutoWorksWithCompileModeDynamicAndInternalProtectedCtor()
		{
			using (var container = new IocContainer())
			{
				var reg1 = container.Register(typeof(IFoo), typeof(InternalProtectedFoo), compileMode: CompileMode.Dynamic, includeInternalCtor: true);
				var reg2 = container.Register(typeof(IFoo), typeof(InternalProtectedFoo), "TheKey", compileMode: CompileMode.Dynamic, includeInternalCtor: true);

				// Register as InternalProtectedFoo because default for IFoo is registered above
				var reg3 = container.Register<InternalProtectedFoo, InternalProtectedFoo>(compileMode: CompileMode.Dynamic, includeInternalCtor: true);
				var reg4 = container.Register<InternalProtectedFoo, InternalProtectedFoo>("TheKey", compileMode: CompileMode.Dynamic, includeInternalCtor: true);

				container.Compile();

				var instance1 = reg1.GetInstance();
				var instance2 = reg2.GetInstance();
				var instance3 = reg3.GetInstance();
				var instance4 = reg4.GetInstance();

				Assert.IsInstanceOfType(instance1, typeof(InternalProtectedFoo));
				Assert.IsInstanceOfType(instance2, typeof(InternalProtectedFoo));
				Assert.IsInstanceOfType(instance3, typeof(InternalProtectedFoo));
				Assert.IsInstanceOfType(instance4, typeof(InternalProtectedFoo));
			}
		}

		public void RegisterAutoWorksWithInternalCtor()
		{
			using (var container = new IocContainer())
			{
				var reg1 = container.Register(typeof(IFoo), typeof(InternalFoo), compileMode: CompileMode.Delegate, includeInternalCtor: true);
				var reg2 = container.Register(typeof(IFoo), typeof(InternalFoo), "TheKey", compileMode: CompileMode.Delegate, includeInternalCtor: true);

				var reg3 = container.Register<InternalFoo, InternalFoo>(compileMode: CompileMode.Delegate, includeInternalCtor: true);
				var reg4 = container.Register<InternalFoo, InternalFoo>("TheKey", compileMode: CompileMode.Delegate, includeInternalCtor: true);

				container.Compile();

				var instance1 = reg1.GetInstance();
				var instance2 = reg2.GetInstance();
				var instance3 = reg3.GetInstance();
				var instance4 = reg4.GetInstance();

				Assert.IsInstanceOfType(instance1, typeof(InternalFoo));
				Assert.IsInstanceOfType(instance2, typeof(InternalFoo));
				Assert.IsInstanceOfType(instance3, typeof(InternalFoo));
				Assert.IsInstanceOfType(instance4, typeof(InternalFoo));
			}
		}

        public void CompileWorksWithPropertyInjection()
        {
            using (var container = new IocContainer())
            {
                // Arrange
                container.Register<IFoo>(c => new Foo1());
                container.Register<IBar>(c => new Bar1());
                container.Register<IFooBar>(c => new FooBar() { Foo = c.Resolve<IFoo>(), Bar = c.Resolve<IBar>() });

                // Act
                container.Compile();

                var foo = container.Resolve<IFoo>();
                var bar = container.Resolve<IBar>();
                var foobar = container.Resolve<IFooBar>();

                // Assert
                Assert.IsNotNull(foo);
                Assert.IsNotNull(bar);
                Assert.IsNotNull(foobar);

                Assert.IsNotNull(foobar.Foo);
                Assert.IsNotNull(foobar.Bar);
            }
        }

        public void CompileThrowsExceptionIfRegistrationsAreNotValid()
        {
            using (var container = new IocContainer())
            {
                // Arrange
                container.Register<IFoo>(c => new Foo1());
                container.Register<IBar>(x => new Bar1(), "Bar");
                container.Register<IFooBar>(x => new FooBar((IFoo)x.Resolve(typeof(IFoo)), (IBar)x.Resolve(typeof(IBar), "Bar")));
                container.Register<IFooBar>(x => new FooBar(x.Resolve<IFoo>(), x.Resolve<IBar>()), "FooBar");

                // Act
                container.Compile();
            }
        }

        public void CompileProtectsAgainstInfiniteLoop()
        {
            using (var container = new IocContainer())
            {
                // Arrange
                container.Register<IFoo>(c => new Foo1());
                container.Register<IBar>(x => new Bar2(x.Resolve<IFooBar>()));
                container.Register<IFooBar>(x => new FooBar(x.Resolve<IFoo>(), x.Resolve<IBar>()));

                // Act
                container.Compile();
            }
        }

        public void CompileDoesntBreakAnything()
        {
            using (var container = new IocContainer())
            {
                // Arrange
                container.Register<IFoo>(c => new Foo1());
                container.Register<IBar>(x => new Bar1(), "BarKey");
                container.Register<IFooBar>(y => new FooBar((IFoo)y.Resolve(typeof(IFoo)), (IBar)y.Resolve(typeof(IBar), "BarKey")));
                container.Register<IFooBar>(xyz => new FooBar(xyz.Resolve<IFoo>(), xyz.Resolve<IBar>("BarKey")), "FooBarKey");

                // Act
                container.Compile();

                var foo = container.Resolve<IFoo>();
                var bar = container.Resolve<IBar>("BarKey");
                var foobar1 = container.Resolve<IFooBar>();
                var foobar2 = container.Resolve<IFooBar>("FooBarKey");

                // Assert
                Assert.IsNotNull(foo);
                Assert.IsNotNull(bar);
                Assert.IsNotNull(foobar1);
                Assert.IsNotNull(foobar2);

                Assert.IsNotNull(foobar1.Foo, null);
                Assert.IsNotNull(foobar1.Bar, null);
                Assert.IsNotNull(foobar2.Foo, null);
                Assert.IsNotNull(foobar2.Bar, null);
            }
        }

		public void RequestLifetimeWorksWithCompile()
		{
			using (var container = new IocContainer())
			{
				// Arrange
				var context = new FakeHttpContext("Http://fakeUrl1.com");
				var requestLifetime = new RequestLifetime(() => context, disposeOnEnd: false);	// Do not test disposeOnEnd here

				container.Register<IFoo, Foo1>();
				container.Register<IBar, Bar1>().SetLifetime(requestLifetime);
				container.Register<IFooBar, FooBar>();

				// Act
				container.Compile();

				var fooBar = container.Resolve<IFooBar>();

				// Assert
				Assert.IsNotNull(fooBar);
				Assert.IsNotNull(fooBar.Foo);
				Assert.IsNotNull(fooBar.Bar);
			}
		}

		public void RequestLifetimeNestedWorksWithCompile()
		{
			// This doesnt work - will affect other Lifetimes that just nests the expression 
			// Need to fix the scope of the input parameter IResolver

			using (var container = new IocContainer())
			{
				// Arrange
				var context = new FakeHttpContext("Http://fakeUrl1.com");
				var requestLifetime = new RequestLifetime(() => context, disposeOnEnd: false);	// Do not test disposeOnEnd here

				container.Register<IFoo, Foo1>();
				container.Register<IBar, Bar1>().SetLifetime(requestLifetime);
				container.Register<IFooBar, FooBar>();
				container.Register<IFooBarContainer, FooBarContainer>();

				// Act
				container.Compile();

				var fooBarContainer = container.Resolve<IFooBarContainer>();

				// Assert
				Assert.IsNotNull(fooBarContainer);
				Assert.IsNotNull(fooBarContainer.FooBar);
				Assert.IsNotNull(fooBarContainer.FooBar.Foo);
				Assert.IsNotNull(fooBarContainer.FooBar.Bar);
			}
		}

		public void CompileWorksWhenCompiledMultipleTimes()
		{
			using (var container = new IocContainer())
			{
				// Arrange
				var foo = new Foo1();
				var bar = new Bar1();
				container.RegisterInstance<IFoo>(foo);
				container.RegisterInstance<IBar>(bar);
				container.Register<IFooBar, FooBar>().WithContainerLifetime();
				container.Register<IFooBarContainer, FooBarContainer>().WithContainerLifetime();

				// Act
				container.Compile();
				container.Compile();

				var fooBarContainer = container.Resolve<IFooBarContainer>();

				// Assert
				Assert.IsNotNull(fooBarContainer);
				Assert.IsNotNull(fooBarContainer.FooBar);
				Assert.IsNotNull(fooBarContainer.FooBar.Foo);
				Assert.IsNotNull(fooBarContainer.FooBar.Bar);

				Assert.AreEqual(foo, fooBarContainer.FooBar.Foo);
				Assert.AreEqual(bar, fooBarContainer.FooBar.Bar);
			}
		}

		public void CompileWorksWithNesting2()
		{
			using (var container = new IocContainer())
			{
				// Arrange
				container.Register<IFoo, Foo1>().SetLifetime(new TransientLifetime());
				container.Register<IBar, Bar1>().SetLifetime(new ContainerLifetime());
				container.Register<IFooBar, FooBar>().WithContainerLifetime();
				container.Register<IFooBarContainer, FooBarContainer>().WithContainerLifetime();

				// Act
				container.Compile();

				var fooBarContainer = container.Resolve<IFooBarContainer>();

				// Assert
				Assert.IsNotNull(fooBarContainer);
				Assert.IsNotNull(fooBarContainer.FooBar);
				Assert.IsNotNull(fooBarContainer.FooBar.Foo);
				Assert.IsNotNull(fooBarContainer.FooBar.Bar);
			}
		}

		public void CompileCanInlineRegistrationsWithTransientLifetime()
		{
			// Doesnt check that Compile actually works - just that it doesnt break anything

			using (var container = new IocContainer())
			{
				container.Register<IFoo>(x => new Foo1()).WithTransientLifetime();
				container.Register<IBar>(x => new Bar1());

				var reg1 = container.Register<IFooBar>(x => new FooBar(x.Resolve<IFoo>(), x.Resolve<IBar>()));
				var reg2 = container.Register<IFooBar>(x => new FooBar(x.Resolve<IFoo>(), x.Resolve<IBar>()), "Key");

				container.Compile();

				var result1 = container.Resolve<IFoo>();
				var result2 = (IFooBar)reg1.GetInstance();
				var result3 = (IFooBar)reg2.GetInstance();
				
				Assert.AreNotEqual(result1, result2.Foo);
				Assert.AreNotEqual(result1, result3.Foo);
				Assert.AreNotEqual(result2.Foo, result3.Foo);
			}
		}