C# WindsorContainer.AddChildContainer方法代码示例

		public void AddingToTwoParentContainsThrowsKernelException()
		{
			IWindsorContainer container3 = new WindsorContainer();
			IWindsorContainer childcontainer = new WindsorContainer();
			Container.AddChildContainer(childcontainer);
			container3.AddChildContainer(childcontainer);
		}

 public void ShouldResolveComponentFromParent()
 {
     WindsorContainer parent = new WindsorContainer();
     WindsorContainer child = new WindsorContainer();
     parent.AddChildContainer(child);
     parent.AddComponent("DoNothingService", typeof(IDoNothingService), typeof(DoNothingService));
     child.AddComponent("DoSomethingService", typeof(IDoSomethingService), typeof(DoSomethingService));
     Assert.IsNotNull(child.Resolve<IDoNothingService>());
     Assert.IsNotNull(child.Resolve<IDoSomethingService>());
 }

 public void ShouldResolveComponentFromParent()
 {
     WindsorContainer parent = new WindsorContainer();
     WindsorContainer child = new WindsorContainer();
     parent.AddChildContainer(child);
     ((IWindsorContainer)parent).Register(Component.For(typeof(IDoNothingService)).ImplementedBy(typeof(DoNothingService)).Named("DoNothingService"));
     ((IWindsorContainer)child).Register(Component.For(typeof(IDoSomethingService)).ImplementedBy(typeof(DoSomethingService)).Named("DoSomethingService"));
     Assert.IsNotNull(child.Resolve<IDoNothingService>());
     Assert.IsNotNull(child.Resolve<IDoSomethingService>());
 }

		public void ShouldResolveComponentFromParent()
		{
			var parent = new WindsorContainer();
			var child = new WindsorContainer();
			parent.AddChildContainer(child);
			parent.Register(
				Component.For<IDoNothingService>().ImplementedBy<DoNothingService>().Named("DoNothingService"),
				Component.For<IDoSomethingService>().ImplementedBy<DoSomethingService>().Named("DoSomethingService"));

			Assert.IsNotNull(child.Resolve<IDoNothingService>());
			Assert.IsNotNull(child.Resolve<IDoSomethingService>());
		}

 public void ShouldResolveDecoratedComponentFromParent()
 {
     WindsorContainer parent = new WindsorContainer();
     WindsorContainer child = new WindsorContainer();
     parent.AddChildContainer(child);
     parent.AddComponent("DoNothingServiceDecorator", typeof(IDoNothingService), typeof(DoNothingServiceDecorator));
     parent.AddComponent("DoNothingService", typeof(IDoNothingService), typeof(DoNothingService));
     child.AddComponent("DoSometingService", typeof(IDoSomethingService), typeof(DoSomethingService));
     IDoNothingService service = child.Resolve<IDoNothingService>();
     Assert.IsNotNull(service);
     Assert.IsInstanceOf(typeof(DoNothingServiceDecorator), service);
 }

		public void Cannot_resolve_a_dependency_from_a_parent_container_under_certain_circumstances()
		{
			var parent = new WindsorContainer();
			var child = new WindsorContainer();

			parent.AddChildContainer(child);

			((IWindsorContainer)parent).Register(Component.For(typeof(IParentService)).ImplementedBy(typeof(ParentService)).Named("service"));
			((IWindsorContainer)child).Register(Component.For(typeof(IChildService1)).ImplementedBy(typeof(ChildService1)).Named("service1"));
			((IWindsorContainer)child).Register(Component.For(typeof(IChildService2)).ImplementedBy(typeof(ChildService2)).Named("service2"));

			child.Resolve<IChildService1>();
		}

 public void ShouldResolveDecoratedComponentFromGrandParent()
 {
     WindsorContainer grandParent = new WindsorContainer();
     WindsorContainer parent = new WindsorContainer();
     WindsorContainer child = new WindsorContainer();
     grandParent.AddChildContainer(parent);
     parent.AddChildContainer(child);
     ((IWindsorContainer)grandParent).Register(Component.For(typeof(IDoNothingService)).ImplementedBy(typeof(DoNothingServiceDecorator)).Named("DoNothingServiceDecorator"));
     ((IWindsorContainer)grandParent).Register(Component.For(typeof(IDoNothingService)).ImplementedBy(typeof(DoNothingService)).Named("DoNothingService"));
     IDoNothingService service = child.Resolve<IDoNothingService>();
     Assert.IsNotNull(service);
     Assert.IsInstanceOf(typeof(DoNothingServiceDecorator), service);
 }

		public void Shows_also_components_from_parent_container()
		{
			var parent = new WindsorContainer();
			parent.Register(Component.For<A>(),
			                Component.For<B>());
			Container.Register(Component.For(typeof(IGeneric<>)).ImplementedBy(typeof(GenericImpl1<>)),
			                   Component.For(typeof(IGeneric<>)).ImplementedBy(typeof(GenericImpl2<>)));

			parent.AddChildContainer(Container);

			var handlers = diagnostic.Inspect();

			Assert.AreEqual(4, handlers.Length);
		}

        public void Should_resolve_child_from_childs_container()
        {
            WindsorContainer parent = new WindsorContainer();
            WindsorContainer child = new WindsorContainer();

            parent.AddChildContainer(child);

            ((IWindsorContainer)parent).Register(Component.For(typeof(IParentService)).ImplementedBy(typeof(ParentService)).Named("service1"));
            ((IWindsorContainer)parent).Register(Component.For(typeof(IChildService2)).ImplementedBy(typeof(ChildService2)).Named("service3"));
            ((IWindsorContainer)child).Register(Component.For(typeof(IParentService)).ImplementedBy(typeof(AnotherParentService)).Named("service2"));

			IChildService2 resolve = child.Resolve<IChildService2>();
            Assert.IsInstanceOf(typeof(AnotherParentService),resolve.Parent);
        }

        public void Should_resolve_child_from_childs_container()
        {
            WindsorContainer parent = new WindsorContainer();
            WindsorContainer child = new WindsorContainer();

            parent.AddChildContainer(child);

            parent.AddComponent("service1", typeof(IParentService), typeof(ParentService));
            parent.AddComponent("service3", typeof(IChildService2), typeof(ChildService2));
            child.AddComponent("service2", typeof(IParentService), typeof(AnotherParentService));

			IChildService2 resolve = child.Resolve<IChildService2>();
            Assert.IsInstanceOf(typeof(AnotherParentService),resolve.Parent);
        }

        public void  Cannot_resolve_a_dependency_from_a_parent_container_under_certain_circumstances()
        {
            WindsorContainer parent = new WindsorContainer();
            WindsorContainer child = new WindsorContainer();

            parent.AddChildContainer(child);

            parent.AddComponent("service", typeof(IParentService), typeof(ParentService));
            child.AddComponent("service1", typeof(IChildService1), typeof(ChildService1));
            child.AddComponent("service2", typeof(IChildService2), typeof(ChildService2));


            child.Resolve<IChildService1>();
        }

		public void AddComponentInstanceAndChildContainers()
		{
			IWindsorContainer parent = new WindsorContainer();
			IWindsorContainer child = new WindsorContainer();
			parent.AddChildContainer(child);

			IEmptyService clock1 = new EmptyServiceA();
			IEmptyService clock2 = new EmptyServiceB();

			parent.Kernel.Register(Component.For(typeof(IEmptyService)).Instance(clock2));
			child.Kernel.Register(Component.For(typeof(IEmptyService)).Instance(clock1));

			Assert.AreSame(clock2, parent.Resolve<IEmptyService>());
			Assert.AreSame(clock1, child.Resolve<IEmptyService>());
		}

		public void TestForSerivces()
		{
			using (var container = new WindsorContainer())
			{
				container.Register(Component.For<IInterface>().ImplementedBy<InterfaceImpl>());
				IInterface childInterface;
				using (var childContainer = new WindsorContainer())
				{
					container.AddChildContainer(childContainer);
					childInterface = container.Resolve<IInterface>();
				} // childIhterface is NOT disposing here
				var @interface = container.Resolve<IInterface>();
				Assert.AreSame(@interface, childInterface);
				@interface.Do();
			} // but is disposing here and this is right behavior
		}

        public void AddComponentInstanceAndChildContainers()
        {
            IWindsorContainer parent = new WindsorContainer();
            IWindsorContainer child = new WindsorContainer();
            parent.AddChildContainer(child);

            IClock clock1 = new IsraelClock();
            IClock clock2 = new WorldClock();

            parent.Kernel.AddComponentInstance<IClock>(clock2);
            child.Kernel.AddComponentInstance<IClock>(clock1);

            Assert.AreSame(clock2,parent.Resolve<IClock>());
            Assert.AreSame(clock1, child.Resolve<IClock>());

        }

		public void TestForTypedFactories()
		{
			using (var container = new WindsorContainer())
			{
				container.AddFacility<TypedFactoryFacility>();
				container.Register(Component.For<IFactory>().AsFactory(),
				                   Component.For(typeof(IInterface)).ImplementedBy(typeof(InterfaceImpl)).LifeStyle.Transient);

				IFactory childFactory;
				using (var childContainer = new WindsorContainer())
				{
					container.AddChildContainer(childContainer);
					childFactory = childContainer.Resolve<IFactory>();
				} // childFactory is disposing here
				var factory = container.Resolve<IFactory>();
				Assert.AreSame(factory, childFactory);
				Assert.DoesNotThrow(() => factory.Create()); // throws an ObjectDisposedException exception
			} // but should be disposed here
		}