C# MicroKernel.DefaultKernel类代码示例

		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.Register(Component.For(typeof(NoInterfaceStartableComponent)).Named("b"));

			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 ICollection<IHandler> SimulateRegistration(this IRegistration reg)
 {
     using (var kernel = new DefaultKernel()) {
         kernel.Register(reg);
         return kernel.GetAssignableHandlers(typeof (object));
     }
 }

		public void MissingManifestResourceConfiguration()
		{
			var store = new DefaultConfigurationStore();
			var source = new AssemblyResource("assembly://Castle.Windsor.Tests/missing_config.xml");
			IKernel kernel = new DefaultKernel();
			new XmlInterpreter(source).ProcessResource(source, store, kernel);
		}

		public void ProperDeserialization()
		{
			var store = new DefaultConfigurationStore();
			var interpreter = new XmlInterpreter(new ConfigResource());
			IKernel kernel = new DefaultKernel();
			interpreter.ProcessResource(interpreter.Source, store, kernel);

			Assert.AreEqual(2, store.GetFacilities().Length);
			Assert.AreEqual(4, store.GetComponents().Length);

			var config = store.GetFacilityConfiguration(typeof(NoopFacility).FullName);
			var childItem = config.Children["item"];
			Assert.IsNotNull(childItem);
			Assert.AreEqual("value", childItem.Value);

			config = store.GetFacilityConfiguration(typeof(Noop2Facility).FullName);
			Assert.IsNotNull(config);
			Assert.AreEqual("value within CDATA section", config.Value);

			config = store.GetComponentConfiguration("testidcomponent1");
			childItem = config.Children["item"];
			Assert.IsNotNull(childItem);
			Assert.AreEqual("value1", childItem.Value);

			config = store.GetComponentConfiguration("testidcomponent2");
			childItem = config.Children["item"];
			Assert.IsNotNull(childItem);
			Assert.AreEqual("value2", childItem.Value);
		}

		public void Starts_component_without_start_method()
		{
			ClassWithInstanceCount.InstancesCount = 0;
			IKernel kernel = new DefaultKernel();
			kernel.AddFacility<StartableFacility>(f => f.DeferredTryStart());
			kernel.Register(Component.For<ClassWithInstanceCount>().Start());
			Assert.AreEqual(1, ClassWithInstanceCount.InstancesCount);
		}

        public void current_property_exposes_the_correct_resolver()
        {
            var kernel = new DefaultKernel();
            var resolver = new CastleDependencyResolver(kernel);

            GlobalHost.DependencyResolver = resolver;

            Assert.That(CastleDependencyResolver.Current, Is.EqualTo(GlobalHost.DependencyResolver));
        }

        public void tt()
        {
            var kernel = new DefaultKernel();
            kernel.Register(AllTypes.Pick()
                                   .FromAssembly(Assembly.GetExecutingAssembly())
                                   .WithService.FirstInterface());

            kernel.Resolve<ISomeInterface>();
        }

        public void get_service_returns_null_for_unregistered_service()
        {
            var kernel = new DefaultKernel();
            var resolver = new CastleDependencyResolver(kernel);

            var service = resolver.GetService(typeof(object));

            Assert.That(service, Is.Null);
        }

        public void get_services_returns_empty_enumerable_for_unregistered_service()
        {
            var kernel = new DefaultKernel();
            var resolver = new CastleDependencyResolver(kernel);

            var services = resolver.GetServices(typeof(object));

            Assert.That(services.Count(), Is.EqualTo(0));
        }

 protected void Application_Start(object sender, EventArgs e) {
     var kernel = new DefaultKernel();
     kernel.Register(Component.For<HttpContextBase>()
                         .LifeStyle.Transient
                         .UsingFactoryMethod(() => new HttpContextWrapper(HttpContext.Current)));
     kernel.Register(Component.For<SomeService>()
         .LifeStyle.HybridPerWebRequestTransient());
     kernel.Resolve<SomeService>();
 }

		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 AddChildKernelToTwoParentsThrowsException()
		{
			IKernel kernel2 = new DefaultKernel();

			IKernel subkernel = new DefaultKernel();

			Kernel.AddChildKernel(subkernel);
			Assert.AreEqual(Kernel, subkernel.Parent);

			kernel2.AddChildKernel(subkernel);
		}

 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 virtual void Should_Dispose_From_Containers()
        {
            DefaultKernel disposableKernel = new DefaultKernel();
            using (var disposableLocater = new SiegeContainer(new WindsorAdapter.WindsorAdapter(disposableKernel)))
            {
                disposableLocater.Register(Given<ITestInterface>.Then<TestCase1>());
                Assert.IsTrue(disposableLocater.GetInstance<ITestInterface>() is TestCase1);
            }

            Assert.IsFalse(disposableKernel.HasComponent(typeof(ITestInterface)));
        }

        public void get_services_returns_registered_service()
        {
            var kernel = new DefaultKernel();
            kernel.Register(Component.For<object>().Instance(new object()));

            var resolver = new CastleDependencyResolver(kernel);

            var services = resolver.GetServices(typeof(object));

            Assert.That(services.Count(), Is.EqualTo(1));
        }