C# IWindsorContainer.ResolveAll方法代码示例

        static void Main(string[] args)
        {
            container = BotRunnerBootstrapper.Init();

            var fineBot = new Bot();
            var fineBotResponders = container.ResolveAll<IFineBotResponder>();
            foreach (IFineBotResponder responder in fineBotResponders)
            {
                fineBot.Responders.Add(responder);
            }

            fineBot.RespondsTo("hi").IfBotIsMentioned().With("Stop resisting citizen!");
            fineBot.CreateResponder(x => !x.BotHasResponded, rc => "My responses are limited, you must ask the right question...");

            var task = fineBot.Connect(ConfigurationManager.AppSettings["BotKey"]);
            Console.WriteLine(string.Format("{0}: Bot is runnning, type 'die' to make it die", DateTime.Now));

            var secondCousinBot = new Bot();
            var secondCousinResponders = container.ResolveAll<ISecondCousinResponder>();
            foreach (ISecondCousinResponder responder in secondCousinResponders)
            {
                secondCousinBot.Responders.Add(responder);
            }
            var seconderTask = secondCousinBot.Connect(ConfigurationManager.AppSettings["SeconderBotKey"]);
            Console.WriteLine(string.Format("{0}: Finebot's second cousin is also also running. Some say he can't die.", DateTime.Now));

            while(Console.ReadLine() != "die")
            {

            }

            container.Dispose();
        }

 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Classes.FromAssemblyContaining<ICreateAutoMapperMaps>().BasedOn<ICreateAutoMapperMaps>().WithServiceAllInterfaces().LifestyleTransient());
     Mapper.Configuration.ConstructServicesUsing(container.Resolve);
     foreach (var map in container.ResolveAll<ICreateAutoMapperMaps>())
         map.CreateMaps();
 }

        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            // register value resolvers
            container.Register(Types.FromAssembly(Assembly.GetExecutingAssembly()).BasedOn(typeof(IValueResolver<,,>)));

            // register profiles
            container.Register(Types.FromThisAssembly().BasedOn<Profile>().WithServiceBase().Configure(c => c.Named(c.Implementation.FullName)).LifestyleTransient());

            var profiles = container.ResolveAll<Profile>();

            var config = new MapperConfiguration(cfg =>
            {
                foreach (var profile in profiles)
                {
                    cfg.AddProfile(profile);
                }
            });

            container.Register(Component.For<MapperConfiguration>()
                .UsingFactoryMethod(() => config));

            container.Register(
                Component.For<IMapper>().UsingFactoryMethod(ctx => ctx.Resolve<MapperConfiguration>().CreateMapper(ctx.Resolve)));

            var mapper = container.Resolve<IMapper>();
            mapper.ConfigurationProvider.AssertConfigurationIsValid();
        }

        private void RegisterProfiles(IWindsorContainer container)
        {
            container.Register(AllTypes.FromThisAssembly().BasedOn<Profile>());
            var profiles = container.ResolveAll<Profile>();

            profiles.Each(Mapper.AddProfile);
        }

        public void Start()
        {
            container = new WindsorContainer()
                .Install(FromAssembly.InDirectory(new AssemblyFilter(sagaDirectory)));

            var sagas = container.ResolveAll<ISaga>();
            sagas.LogWith(log).InitializeWith(bus);
        }

 public static void Configure(IWindsorContainer container)
 {
     var handlers = container.ResolveAll<global::AutoMapper.Profile>();
     foreach (var handler in handlers)
     {
         global::AutoMapper.Mapper.AddProfile(handler);
     }
 }

        public QuartzServer(IWindsorContainer container)
        {
            this.logger = LogManager.GetLogger(GetType());
            this.container = container;

            foreach (var registration in container.ResolveAll<IRegisterQuartzJob>())
            {
                Scheduler.ScheduleJob(registration.GetJobDetailToRun(), registration.GetJobTrigger());
            }
        }

 private static void RegisterContainer()
 {
     _container = new WindsorContainer();
     _container.Register(
         Classes.FromThisAssembly()
             .Where(x => typeof (IComponentConfiguration).IsAssignableFrom(x))
             .WithServices(typeof (IComponentConfiguration)));
     foreach (var component in _container.ResolveAll<IComponentConfiguration>())
         component.Configure(_container);
 }

        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container
                .Install(new ConfigurationInstaller());

            foreach (var i in container.ResolveAll<IRequiresInitialization>())
            {
                i.Initialize();
            }

            _httpconfiguration.Services.Replace(typeof(IHttpControllerActivator), new WindsorCompositionRoot(container));
        }

        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            DependencyResolver.SetResolver(container.Resolve, type => container.ResolveAll(type).Cast<object>());

            container.Singleton<IDbContextProvider, DbContextProvider>();

            container.Register(
                Types.FromThisAssembly()
                    .Where(type => !type.IsAbstract && type.Name.EndsWith("Manager"))
                    .WithServiceFirstInterface()
                    .LifestyleSingleton());
        }

 public static void AddConfigurationFromContainer(IWindsorContainer container)
 {
     var genericMappers = container.ResolveAll<IGenericMapperMarker>();
     foreach (var mapperImplementation in genericMappers)
     {
         if (Mapper.FindTypeMapFor(mapperImplementation.GetSourceType(), mapperImplementation.GetDestinationType()) == null)
         {
             Mapper.CreateMap(mapperImplementation.GetSourceType(), mapperImplementation.GetDestinationType());
         }
     }
     container.Release(genericMappers);
 }

        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(
                AllTypes
                    .FromThisAssembly()
                    .BasedOn<IModelMetadataFilter>()
                    .WithService.Base()
                    .LifestyleTransient());

            IModelMetadataFilter[] filters = container.ResolveAll<IModelMetadataFilter>();
            ModelMetadataProviders.Current = new CustomModelMetadataProvider(filters);
        }

        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            this.Info(() => "Attempting to install AutoMapperInstaller");

            container.Register(Classes.FromAssemblyContaining<ICreateAutoMapperMaps>().BasedOn(typeof(ITypeConverter<,>)).WithServiceAllInterfaces().LifestyleTransient());
            container.Register(Classes.FromAssemblyContaining<ICreateAutoMapperMaps>().BasedOn<ICreateAutoMapperMaps>().WithServiceAllInterfaces().LifestyleTransient());
            Mapper.Configuration.ConstructServicesUsing(container.Resolve);
            foreach (var map in container.ResolveAll<ICreateAutoMapperMaps>())
                map.CreateMaps();

            this.Info(() => "Successfully installed AutoMapperInstaller");
        }

		public void Install(IWindsorContainer container, IConfigurationStore store)
		{
			container.Register(Classes
				.FromThisAssembly()
				.InNamespace("ImageProcessor.Filters")
				.WithServiceAllInterfaces()
				.LifestyleSingleton());

			container.Register(Component
				.For<IFilterBase[]>()
				.Instance(container.ResolveAll<IFilterBase>())
				.LifestyleSingleton());
		}

 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     // Not available in current stable release of AutoMapper
     //Mapper.Initialize(cfg =>
     //{
     //    cfg.BindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
     //});
     container.Register(Classes.FromAssemblyContaining<ICreateAutoMapperMaps>().BasedOn(typeof(ITypeConverter<,>)).WithServiceAllInterfaces().LifestyleTransient());
     container.Register(Classes.FromAssemblyContaining<ICreateAutoMapperMaps>().BasedOn<ICreateAutoMapperMaps>().WithServiceAllInterfaces().LifestyleTransient());
     Mapper.Configuration.ConstructServicesUsing(container.Resolve);
     foreach (var map in container.ResolveAll<ICreateAutoMapperMaps>())
         map.CreateMaps();
 }