C# WindsorContainer.Resolve方法代码示例

        public void it_should_add_custom_header_to_headers_collection_for_delayed_messages()
        {
            using (var container = new WindsorContainer(new XmlInterpreter()))
            {
                container.Register(Component.For<ICustomizeOutgoingMessages>().ImplementedBy<AppIdentityCustomizer>().LifeStyle.Is(LifestyleType.Transient));
                new RhinoServiceBusConfiguration()
                    .UseCastleWindsor(container)
                    .Configure();
                var transport = container.Resolve<ITransport>();
                MsmqCurrentMessageInformation currentMessageInformation = null;
                var waitHandle = new ManualResetEvent(false);
                transport.MessageArrived += messageInfo =>
                {
                    currentMessageInformation = (MsmqCurrentMessageInformation) messageInfo;
                    waitHandle.Set();
                    return true;
                };
                var builder = container.Resolve<IMessageBuilder<Message>>();
                Message afterBuild = null;
                builder.MessageBuilt += msg => afterBuild = msg;

                using (var bus = container.Resolve<IStartableServiceBus>())
                {
                    bus.Start();
                    DateTime beforeSend = DateTime.Now;
                    bus.DelaySend(bus.Endpoint, DateTime.Now.AddMilliseconds(250), "testmessage");
                    waitHandle.WaitOne(TimeSpan.FromSeconds(30));
                    Assert.True((DateTime.Now - beforeSend).TotalMilliseconds >= 250);
                }
                Assert.NotNull(afterBuild);
                var headers = afterBuild.Extension.DeserializeHeaders();
                Assert.Equal("corey", headers["user-id"]);
                Assert.Equal("corey", currentMessageInformation.Headers["user-id"]);
            }
        }

        // Models singleton over transient instance models
        static void Main(string[] args)
        {
            IWindsorContainer container =
                new WindsorContainer(new XmlInterpreter("windsor.config"));

            //IWindsorContainer container = CreateContainer();

            IBar bar = container.Resolve<IBar>();

            if (bar != null)
            {
                bar.DisplayTime();
            }
            container.Release(bar);

            // Mimic a time delay.
            System.Threading.Thread.Sleep(2000);

            IBar bar2 = container.Resolve<IBar>();

            if (bar2 != null)
            {
                bar2.DisplayTime();
            }

            container.Release(bar2);

            Console.Write("Press <ENTER> to exit...");
            Console.ReadLine();
        }

        public void CanCreateDuplexProxyWithCallbackType()
        {
            IWindsorContainer localContainer = new WindsorContainer();

            localContainer.AddFacility<WcfFacility>();

            DuplexClientModel model = new DuplexClientModel
            {
                Endpoint = WcfEndpoint.ForContract<IServiceWithCallback>()
                    .BoundTo(new NetTcpBinding())
                    .At("net.tcp://localhost/ServiceWithCallback")
            }.WithCallback<ICallbackService>();

            localContainer.Register(WcfClient.ForChannels(model));

            localContainer.Register(Component.For<ICallbackService>()
                                        .ImplementedBy<CallbackService>());

            var callbackService = localContainer.Resolve<ICallbackService>();

            Assert.AreEqual(0, ((CallbackService)callbackService).ValueFromTheOtherSide);

            IServiceWithCallback proxy = localContainer.Resolve<IServiceWithCallback>();
            proxy.DoSomething(21);

            Assert.IsAssignableFrom(typeof(CallbackService), callbackService);
            Assert.AreEqual(42, ((CallbackService)callbackService).ValueFromTheOtherSide);
        }

        public void ResolvingPerThreadComponents_NewInstanceIsCreatedForEachThread()
        {
            IWindsorContainer container = new WindsorContainer();

             container.Register(
                 Component.For<IRepository<Client>>().ImplementedBy<ClientRepository>().LifeStyle.PerThread);

             Task firstTask = Task.Factory.StartNew(() =>
             {
                 var repository = container.Resolve<IRepository<Client>>();
                 var secondRepository = container.Resolve<IRepository<Client>>();

                 Assert.AreSame(repository, secondRepository);
             });

             Task secondTask = Task.Factory.StartNew(() =>
             {
                 var repository = container.Resolve<IRepository<Client>>();
                 var secondRepository = container.Resolve<IRepository<Client>>();

                 Assert.AreSame(repository, secondRepository);
             });

             Task.WaitAll(firstTask, secondTask);

             container.Dispose();
        }

 private static void Main(string[] args)
 {
     using (var container = new WindsorContainer())
     {
         container.Install(new AppInstaller());
         do
         {
             IOutputGenerator myClass;
             switch (Console.ReadLine())
             {
                 case "1":
                     myClass = container.Resolve<ReverseEvenNumberGenerator>();
                     break;
                 case "2":
                     myClass = container.Resolve<Class1>();
                     break;
                 case "3":
                     myClass = container.Resolve<OddNumberGenerator>();
                     break;
                 default:
                     return;
             }
             Console.WriteLine(myClass.GenerateOutput());
         } while (true);
     }
 }

		public void TestBasicOperations()
		{
			WindsorContainer container = new WindsorContainer(new DefaultConfigurationStore());

			container.AddFacility("transactionmanagement", new TransactionFacility());

			container.Register(Component.For<ITransactionManager>().ImplementedBy<MockTransactionManager>().Named("transactionmanager"));

			container.Register(Component.For<CustomerService>().Named("services.customer"));

			CustomerService service = container.Resolve<CustomerService>("services.customer");

			service.Insert("TestCustomer", "Rua P Leite, 33");

			MockTransactionManager transactionManager = container.Resolve<MockTransactionManager>("transactionmanager");

			Assert.AreEqual(1, transactionManager.TransactionCount);
			Assert.AreEqual(1, transactionManager.CommittedCount);
			Assert.AreEqual(0, transactionManager.RolledBackCount);

			try
			{
				service.Delete(1);
			}
			catch (Exception)
			{
				// Expected
			}

			Assert.AreEqual(2, transactionManager.TransactionCount);
			Assert.AreEqual(1, transactionManager.CommittedCount);
			Assert.AreEqual(1, transactionManager.RolledBackCount);
		}

        public void CanInstallServicesInTheContainer()
        {
            IWindsorContainer container = new WindsorContainer()
                .AddFacility<TypedFactoryFacility>();

            container.Install(new ServiceInstaller());

            IMonitor monitor = container.Resolve<IMonitor>();
            IMonitor monitor2 = container.Resolve<IMonitor>();
            
            Assert.IsInstanceOf<MonitorService>(monitor);
            Assert.AreSame(monitor, monitor2);

            container.Release(monitor);
            container.Release(monitor2);

            //check dependencies also
            IEventDispatcher dispatcher1 = container.Resolve<IEventDispatcher>();
            IEventDispatcher dispatcher2 = container.Resolve<IEventDispatcher>();

            Assert.IsInstanceOf<EventDispatcher>(dispatcher1);
            Assert.AreSame(dispatcher1, dispatcher2);

            container.Release(dispatcher1);
            container.Release(dispatcher2);

            
        }

        private static void Main(string[] args)
        {
            var container = new WindsorContainer();

            container.Install(FromAssembly.This());

            var client = container.Resolve<IQuilt4NetClient>();
            client.WebApiClient.WebApiRequestEvent += WebApiClientWebApiRequestEvent;
            client.WebApiClient.WebApiResponseEvent += WebApiClient_WebApiResponseEvent;
            client.WebApiClient.AuthorizationChangedEvent += WebApiClient_AuthorizationChangedEvent;

            var business1 = container.Resolve<ISomeBusiness1>();
            var business2 = container.Resolve<ISomeBusiness2>();

            try
            {
                business1.Execute();
                business2.Execute();
            }
            catch (Exception exception)
            {
                Console.WriteLine("Exception: " + exception.Message);
            }

            //business1.Dispose();
            container.Dispose();

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }

 public ProcessTransactionService()
 {
     var container = new WindsorContainer(new XmlInterpreter(new ConfigResource("castle")));
     _accountRepository = container.Resolve<IAccountRepository>();
     _transactionsRepository = container.Resolve<ITransactionsRepository>();
     _paymentGateway = container.Resolve<IPaymentGateway>();
 }

        public static void Main(string[] args)
        {
            var container = new WindsorContainer();
            container.Register (
                Component.For<ManagerService>()
                    .LifeStyle.Singleton);

            container.Register (
                Component.For<UnmanagedService>()
                    .Interceptors<ManagerService>());

            var managerService = container.Resolve<ManagerService>();
            managerService.Start ();

            var unmanagedSvc = container.Resolve<UnmanagedService>();
            unmanagedSvc.Start ();

            Console.WriteLine ("Press enter to stop the service");
            Console.ReadLine ();

            managerService.Stop ();
            unmanagedSvc.Stop ();

            container.Dispose ();
        }

 public PizzaController()
 {
     CriarMapeamentosDto();
     _container = FabricaContainer.InicializarContainer();
     _ingredienteServico = _container.Resolve<IIngredienteServico>();
     _pizzaServico = _container.Resolve<IPizzaServico>();
 }

        public WorkerRole()
        {
            _pulsers = Pulsers.FromAssembly(Assembly.GetAssembly(typeof(ImportFileProcessed)))
                .ToList();


            var container = new WindsorContainer();

            _configurationValueProvider = new AzureConfigurationValueProvider();
            SetupDi(container, _configurationValueProvider, _pulsers.ToArray());
            _pulserPublisher = container.Resolve<PulserPublisher>();
            _orchestrator = container.Resolve<Orchestrator>();

            // insert the list here
            var keyValueStore = container.Resolve<IDynamoStore>();
            var blob = new SimpleBlob()
            {
                Body = Assembly.GetExecutingAssembly()
                    .GetManifestResourceStream("BeeHive.Sample.FileImport.Worker.Data.SampleData.txt"),
                Id = "FileDrop/ImportFiles/SampleData.txt",
                LastModofied = DateTimeOffset.Now
            };
            keyValueStore.UpsertAsync(blob);

            // add one topic that will not be created automagically by orchestrator
            // because no actor registered against it
            var q = container.Resolve<IEventQueueOperator>();

            q.CreateQueueAsync("NewIndexUpserted").Wait();



        }

        static void Main(string[] args)
        {
            var ticks = DateTime.Now.Ticks;

            Console.WriteLine("Start : {0}", GetTimeElapsedSince(ticks));

            var container = new WindsorContainer();
            Console.WriteLine("Container created : {0}", GetTimeElapsedSince(ticks));

            container.Install(
                new DummyInstaller(),
                new NestedInstaller());

            Console.WriteLine("Types registered [{1}] : {0}", GetTimeElapsedSince(ticks), 1);

            var dummy = container.Resolve<IDummy100Service>();
            Console.WriteLine(dummy);
            Console.WriteLine("Resolved IDummy100Service : {0}", GetTimeElapsedSince(ticks));

            var nested = container.Resolve<INested0Service>();
            Console.WriteLine(nested);
            Console.WriteLine("Resolved INested0Service : {0}", GetTimeElapsedSince(ticks));

            Console.ReadKey();
        }

        public void ResolveRepositories()
        {
            IWindsorContainer container = new WindsorContainer();
            container.Install(FromAssembly.This());

            var clientRepository = container.Resolve<IRepository<Client>>();
            var courseRepository = container.Resolve<IRepository<Course>>();
        }

        public void ResolveNamedNotifiers()
        {
            IWindsorContainer container = new WindsorContainer();
            container.Install(FromAssembly.This());

            var emailNotifier = container.Resolve<IRegistrationNotifier>("EmailNotifier");
            var smsNotifier = container.Resolve<IRegistrationNotifier>("SmsNotifier");
        }