C# DefaultKernel.AddComponent方法代码示例

 public void Kernel_should_select_ctor_with_available_dependencies()
 {
     var kernel = new DefaultKernel();
     kernel.AddComponent<Service>();
     kernel.AddComponent<ComponentX>();
     kernel.AddComponent<ComponentY>();
     var service = kernel.Resolve<Service>();
     Assert.IsNull(service.A);
     Assert.IsNotNull(service.X);
     Assert.IsNotNull(service.Y);
 }

		public void TestComponentWithNoInterface()
		{
			IKernel kernel = new DefaultKernel();
			kernel.ComponentCreated += new ComponentInstanceDelegate(OnNoInterfaceStartableComponentStarted);

			MutableConfiguration compNode = new MutableConfiguration("component");
			compNode.Attributes["id"] = "b";
			compNode.Attributes["startable"] = "true";
			compNode.Attributes["startMethod"] = "Start";
			compNode.Attributes["stopMethod"] = "Stop";

			kernel.ConfigurationStore.AddComponentConfiguration("b", compNode);

			kernel.AddFacility("startable", new StartableFacility());
			kernel.AddComponent("b", typeof(NoInterfaceStartableComponent));

			Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");

			NoInterfaceStartableComponent component = kernel["b"] as NoInterfaceStartableComponent;

			Assert.IsNotNull(component);
			Assert.IsTrue(component.Started);
			Assert.IsFalse(component.Stopped);

			kernel.ReleaseComponent(component);
			Assert.IsTrue(component.Stopped);
		}

		public static void Main(string[] args)
		{
			IKernel kernel = new DefaultKernel();
			
			kernel.AddFacility("non.opt.props", new NonOptionalPropertiesFacility());
			
			kernel.AddComponent("sql.connmng", typeof(SqlConnectionManager));
			
			SqlConnectionManager connManager = (SqlConnectionManager) kernel["sql.connmng"];
		}

		public void LoadWindsorAssembly()
		{
			IKernel kernel = new DefaultKernel();
			kernel.AddComponent( "A", typeof(AssemblyResolverComponent) );
			
			AssemblyResolverComponent comp = (AssemblyResolverComponent) kernel["A"];
			comp.Start();

			Type windsor = Type.GetType( 
				"Castle.Windsor.WindsorContainer, Castle.Windsor", false, false );
			
			Assert.IsNotNull(windsor);
		}

		public void TestInterfaceBasedStartable()
		{
			IKernel kernel = new DefaultKernel();
			kernel.ComponentCreated += new ComponentInstanceDelegate(OnStartableComponentStarted);

			kernel.AddFacility("startable", new StartableFacility());

			kernel.AddComponent("a", typeof(StartableComponent));

			Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");

			StartableComponent component = kernel["a"] as StartableComponent;

			Assert.IsNotNull(component);
			Assert.IsTrue(component.Started);
			Assert.IsFalse(component.Stopped);

			kernel.ReleaseComponent(component);
			Assert.IsTrue(component.Stopped);
		}

        private static void SimpleRegistration()
        {
            IKernel kernel = new DefaultKernel();

            //kernel.Resolver.AddSubResolver(new ArrayResolver(kernel));
            //kernel.Resolver.AddSubResolver(new ListResolver(kernel));

            kernel.AddComponent("foo", typeof(IFoo), typeof(Foo));

            IFoo foo = kernel[typeof(IFoo)] as IFoo;

            if (foo != null)
            {
                foo.SayHello();
            }

            IFoo foo2 = kernel["foo"] as IFoo;
            if (foo2 != null)
            {
                foo2.SayHello();
            }
        }

		public void TestStartableWithRegisteredCustomDependencies()
		{
			IKernel kernel = new DefaultKernel();
			kernel.ComponentCreated += new ComponentInstanceDelegate(OnStartableComponentStarted);

			kernel.AddFacility("startable", new StartableFacility());

			Hashtable dependencies = new Hashtable();
			dependencies.Add("config", 1);
			kernel.AddComponent("a", typeof(StartableComponentCustomDependencies));
			kernel.RegisterCustomDependencies(typeof(StartableComponentCustomDependencies), dependencies);

			Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");

			StartableComponentCustomDependencies component = kernel["a"] as StartableComponentCustomDependencies;

			Assert.IsNotNull(component);
			Assert.IsTrue(component.Started);
			Assert.IsFalse(component.Stopped);

			kernel.ReleaseComponent(component);
			Assert.IsTrue(component.Stopped);
		}

		public void TestStartableChainWithGenerics()
		{
			IKernel kernel = new DefaultKernel();

			kernel.AddFacility("startable", new StartableFacility());

			// Add parent. This has a dependency so won't be started yet.
			kernel.AddComponent("chainparent", typeof(StartableChainParent));

			Assert.AreEqual(0, StartableChainDependency.startcount);
			Assert.AreEqual(0, StartableChainDependency.createcount);

			// Add generic dependency. This is not startable so won't get created. 
			kernel.AddComponent("chaingeneric", typeof(StartableChainGeneric<>));

			Assert.AreEqual(0, StartableChainDependency.startcount);
			Assert.AreEqual(0, StartableChainDependency.createcount);

			// Add dependency. This will satisfy the dependency so everything will start.
			kernel.AddComponent("chaindependency", typeof(StartableChainDependency));

			Assert.AreEqual(1, StartableChainParent.startcount);
			Assert.AreEqual(1, StartableChainParent.createcount);
			Assert.AreEqual(1, StartableChainDependency.startcount);
			Assert.AreEqual(1, StartableChainDependency.createcount);
			Assert.AreEqual(1, StartableChainGeneric<string>.createcount);
		}