예제 #1
0
        /// <summary>
        /// Creates the child.
        /// </summary>
        /// <returns></returns>
        public IServiceLocator CreateChild(object tag)
        {
            var childContainer = CreateContainer();

            _container.AddChildContainer(childContainer);
            return(new CastleWindsorServiceLocator(childContainer));
        }
        public IDependencyScope BeginScope()
        {
            var scope = new WindsorContainer();

            container.AddChildContainer(scope);
            return(new WindsorDependencyScope(scope));
        }
예제 #3
0
        public IDependencyScope BeginScope()
        {
            IWindsorContainer childContainer = new WindsorContainer();

            _container.AddChildContainer(childContainer);
            return(new CastleDependencyResolver(childContainer));
        }
예제 #4
0
        static void Process(Type type, object item, IWindsorContainer container)
        {
            using (var childContainer = new WindsorContainer())
            {
                container.AddChildContainer(childContainer);
                container.Register(Component.For(type).Instance(item).OnlyNewServices());

                var genericProcessorType = typeof(BaseProcessor <>);
                var processorType        = genericProcessorType.MakeGenericType(type);

                try
                {
                    var processor = (IProcessor)childContainer.Resolve(processorType);
                    var result    = processor.Process();

                    var context = childContainer.Resolve <IContext>();
                    childContainer.Register(Component.For <IContext>().Instance(context.Extend(result.Type, result.Id)));
                }
                catch (ComponentNotFoundException)
                {
                    // some kind of logging here :)
                }

                Traverse(type, item, childContainer);
            }
        }
예제 #5
0
        public IModule LoadModule(Assembly assembly)
        {
            try
            {
                var moduleInstaller = FromAssembly.Instance(assembly);

                var windsorContainer = new WindsorContainer();

                _mainContainer.AddChildContainer(windsorContainer);

                windsorContainer.Install(moduleInstaller);

                var module = windsorContainer.Resolve <IModule>();

                if (!AssemblySource.Instance.Contains(assembly))
                {
                    AssemblySource.Instance.Add(assembly);
                }

                return(module);
            }
            catch (Exception)
            {
                //TODO: good exception handling
                return(null);
            }
        }
예제 #6
0
        /// <summary>
        /// 开始解析范围。
        /// </summary>
        /// <returns>
        /// 依赖范围。
        /// </returns>
        public IDependencyScope BeginScope()
        {
            var childContainer = new WindsorContainer();

            container.AddChildContainer(childContainer);

            return(new WindsorDependencyResolver(childContainer));
        }
예제 #7
0
        private ViewModelsContainer CreateViewModelsContainer()
        {
            var vmContainer = new WindsorContainer();

            _container.AddChildContainer(vmContainer);

            var instance = new ViewModelsContainer(vmContainer);

            vmContainer.Register(Component.For <IContainer>().Instance(instance));
            return(instance);
        }
예제 #8
0
        private IWindsorContainer CreateSubContainerConfiguredFor(Type bootstraperType)
        {
            IWindsorContainer subContainer = new WindsorContainer();

            _rootContainer.AddChildContainer(subContainer);

            subContainer.Register(
                Component.For <IModuleBootstraper>().ImplementedBy(bootstraperType)
                );
            return(subContainer);
        }
예제 #9
0
        public static IWindsorContainer CreateChildContainerFromResult(this IWindsorContainer container, StructuralType type, long id)
        {
            var childContext = container.Resolve <IContext>().Extend(type, id);

            var childContainer = new WindsorContainer();

            childContainer.Register(Component.For <IWindsorContainer>().Instance(childContainer));
            childContainer.Register(Component.For <IContext>().Instance(childContext));

            container.AddChildContainer(childContainer);
            return(childContainer);
        }
예제 #10
0
 private static IWindsorContainer CreateChildContainer(IWindsorContainer parent)
 {
     var sessionComponent =
         Component.For<IDocumentSession>()
                  .UsingFactoryMethod(
                      kernel => kernel.Resolve<IDocumentStore>().OpenSession())
                  .LifestyleTransient();
     var container = new WindsorContainer();
     container.Register(sessionComponent);
     parent.AddChildContainer(container);
     return container;
 }
예제 #11
0
 private static IWindsorContainer CreateChildContainer(IWindsorContainer container)
 {
     var childContainer = new WindsorContainer();
     childContainer.Register(
         Component.For<IDocumentSession>()
                  .UsingFactoryMethod(kernel =>
                  {
                      var documentSession = kernel.Resolve<IDocumentStore>().OpenSession();
                      documentSession.Advanced.UseOptimisticConcurrency = true;
                      return documentSession;
                  })
                  .LifestyleTransient());
     container.AddChildContainer(childContainer);
     return childContainer;
 }
예제 #12
0
        /// <summary>
        ///   Constructs a container assigning a parent container
        ///   before starting the dependency resolution.
        /// </summary>
        /// <param name = "parent">The instance of an <see cref = "IWindsorContainer" /></param>
        /// <param name = "interpreter">The instance of an <see cref = "IConfigurationInterpreter" /> implementation</param>
        public WindsorContainer(IWindsorContainer parent, IConfigurationInterpreter interpreter) : this()
        {
            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }
            if (interpreter == null)
            {
                throw new ArgumentNullException("interpreter");
            }

            parent.AddChildContainer(this);

            interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore, kernel);

            RunInstaller();
        }
예제 #13
0
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            var childContainer = new WindsorContainer();

            container.AddChildContainer(childContainer);

            var accessor = _scopeAccessor ?? typeof(WebRequestScopeAccessor);

            childContainer.Register(
                Component.For <ServiceBusController>()
                .LifestyleScoped(accessor)
                );

            foreach (var assembly in _fromAssemblies)
            {
                childContainer.Register(
                    assembly.BasedOn <IHttpController>().WithServiceSelf()
                    .LifestyleScoped(accessor)
                    );
            }

            if (_useFluentValidation)
            {
                FluentValidationModelValidatorProvider
                .Configure(_configuration, provider =>
                           provider.ValidatorFactory = container.Resolve <IValidatorFactory>());
            }

            _configuration.DependencyResolver =
                new WindsorDependencyResolver(childContainer.Kernel);

            ConfigureSwagger();

            if (_useGlobalExceptionLogging)
            {
                var logger = container.Resolve <ILogger>();
                _configuration.Services.Add(typeof(IExceptionLogger), new ServiceBusExceptionLogger(logger));
            }

            _configuration.EnsureInitialized();
        }
예제 #14
0
        private TenantManager BuildTenants(IWindsorContainer container, DocumentStoreConfiguration config)
        {
            _logger.Debug("Configuring tenants");
            var manager = new TenantManager(container.Kernel);

            container.Register(Component.For <ITenantAccessor, TenantManager>().Instance(manager));

            foreach (var settings in config.TenantSettings)
            {
                _logger.DebugFormat("Adding tenant {0}", settings.TenantId);

                var tenant = manager.AddTenant(settings);
                tenant.Container.Kernel.Resolver.AddSubResolver(new CollectionResolver(tenant.Container.Kernel, true));
                tenant.Container.Kernel.Resolver.AddSubResolver(new ArrayResolver(tenant.Container.Kernel, true));
                tenant.Container.AddFacility <StartableFacility>();
                tenant.Container.AddFacility <JarvisTypedFactoryFacility>();
                container.AddChildContainer(tenant.Container);
            }

            return(manager);
        }
예제 #15
0
        /// <summary>
        ///   Initializes a new instance of the <see cref = "WindsorContainer" /> class.
        /// </summary>
        /// <param name = "name">The container's name.</param>
        /// <param name = "parent">The parent.</param>
        /// <param name = "interpreter">The interpreter.</param>
        public WindsorContainer(string name, IWindsorContainer parent, IConfigurationInterpreter interpreter) : this()
        {
            if (name == null)
            {
                throw new ArgumentNullException(nameof(name));
            }
            if (parent == null)
            {
                throw new ArgumentNullException(nameof(parent));
            }
            if (interpreter == null)
            {
                throw new ArgumentNullException(nameof(interpreter));
            }

            this.name = name;

            parent.AddChildContainer(this);

            interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore, kernel);

            RunInstaller();
        }
예제 #16
0
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            var childContainer = new WindsorContainer();

            childContainer.Register(
                Component.For <IControllerFactory>()
                .ImplementedBy <WindsorControllerFactory>()
                );

            foreach (var assemebly in _fromAssemblies)
            {
                childContainer.Register(
                    assemebly.BasedOn <IController>()
                    .WithServiceSelf()
                    .LifestyleScoped(_scopeAccessor ?? typeof(WebRequestScopeAccessor))
                    );
            }

            container.AddChildContainer(childContainer);

            ControllerBuilder.Current.SetControllerFactory(childContainer.Resolve <IControllerFactory>());

            if (_useFluentValidation)
            {
                FluentValidationModelValidatorProvider.Configure(provider =>
                {
                    provider.ValidatorFactory = container.Resolve <IValidatorFactory>();
                });
            }

            if (_useFeaturePaths)
            {
                ViewEngines.Engines.Clear();
                ViewEngines.Engines.Add(new FeatureViewLocationRazorViewEngine());
            }
        }
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            var childContainer = new WindsorContainer();
            childContainer.Kernel.Resolver.AddSubResolver(new EnvironmentResolver());
            childContainer.Kernel.Resolver.AddSubResolver(
                new ArrayResolver(childContainer.Kernel, true));
            childContainer.Kernel.AddHandlersFilter(new RestHandlerFilter());
            childContainer.Kernel.AddHandlersFilter(new BatchHandlerFilter());
            childContainer.Kernel.AddHandlersFilter(new CacheHandlerFilter());
            childContainer.Kernel.AddHandlersFilter(new ContravariantFilter());
            childContainer.Kernel.AddHandlerSelector(new PipelineSelector());

            childContainer.Register(
                Component.For<IMediator>().ImplementedBy<ScopedMediator>(),
                Component.For<EnvironmentInterceptor>().LifestyleTransient()
            );

            foreach (var assembly in _fromAssemblies
                .Concat(new[] {Classes.FromThisAssembly()}))
            {
                childContainer.Register(assembly
                    .BasedOn(typeof (IRequestHandler<,>))
                    .OrBasedOn(typeof (IRequestMiddleware<,>))
                    .OrBasedOn(typeof (IAsyncRequestHandler<,>))
                    .OrBasedOn(typeof (INotificationHandler<>))
                    .OrBasedOn(typeof (IAsyncNotificationHandler<>))
                    .OrBasedOn(typeof (IValidator<>))
                    .WithServiceBase()
                    .LifestyleScoped()
                    .Configure(c =>
                    {
                        c.Proxy.Hook(new EnvironmentProxyGenerationHook())
                             .Interceptors<EnvironmentInterceptor>();
                        if (c.Implementation != null)
                        {
                            var requiresMatching = c.Implementation.GetInterface(
                                typeof (IRequireGenericMatching<>).FullName);
                            if (requiresMatching == null) return;
                            var matcher = requiresMatching.GetGenericArguments()[0];
                            c.ExtendedProperties(
                                Property.ForKey(Constants.GenericImplementationMatchingStrategy)
                                    .Eq(Activator.CreateInstance(matcher)));
                        }
                    }));
            }

            container.Register(Component.For<IValidatorFactory>()
                     .ImplementedBy<WindsorValidatorFactory>()
                     .OnlyNewServices());

            container.AddChildContainer(childContainer);
            container.Register(Component.For<IMediator>()
                     .Instance(childContainer.Resolve<IMediator>()));
        }
예제 #18
0
 public Factory(IWindsorContainer outerContainer)
 {
     container = new WindsorContainer();
     outerContainer.AddChildContainer(container);
 }
예제 #19
0
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            var childContainer = new WindsorContainer(
                "Improving.MediatR", new DefaultKernel(), new DefaultComponentInstaller());

            childContainer.Kernel.Resolver.AddSubResolver(new EnvironmentResolver());
            childContainer.Kernel.Resolver.AddSubResolver(
                new ArrayResolver(childContainer.Kernel, true));
            childContainer.Kernel.AddHandlersFilter(new RestHandlerFilter());
            childContainer.Kernel.AddHandlersFilter(
                new OpenGenericHandlersFilter(typeof(BatchOf <,>), typeof(BatchHandler <,>)));
            childContainer.Kernel.AddHandlersFilter(
                new OpenGenericHandlersFilter(typeof(Cached <>), typeof(CacheHandler <>)));
            childContainer.Kernel.AddHandlersFilter(
                new OpenGenericHandlersFilter(typeof(Routed <>), typeof(RouteHandler <>)));
            childContainer.Kernel.AddHandlersFilter(new ContravariantFilter());
            childContainer.Kernel.AddHandlerSelector(new PipelineSelector());

            childContainer.Register(
                Component.For <IMediator>().ImplementedBy <ScopedMediator>(),
                Component.For <EnvironmentInterceptor>().LifestyleTransient()
                );

            childContainer.Kernel.ComponentModelCreated += Kernel_ComponentModelCreated;

            foreach (var assembly in _fromAssemblies
                     .Concat(new[] { Classes.FromThisAssembly() }))
            {
                childContainer.Register(assembly
                                        .BasedOn(typeof(IRequestHandler <,>))
                                        .OrBasedOn(typeof(IRequestMiddleware <,>))
                                        .OrBasedOn(typeof(IAsyncRequestHandler <,>))
                                        .OrBasedOn(typeof(INotificationHandler <>))
                                        .OrBasedOn(typeof(IAsyncNotificationHandler <>))
                                        .OrBasedOn(typeof(IValidator <>))
                                        .OrBasedOn(typeof(IRouter))
                                        .WithServiceBase()
                                        .Configure(c =>
                {
                    if (c.Implementation != null &&
                        typeof(IRouter).IsAssignableFrom(c.Implementation))
                    {
                        return;
                    }
                    c.LifestyleScoped();
                    c.Proxy.Hook(new EnvironmentProxyGenerationHook())
                    .Interceptors <EnvironmentInterceptor>();
                    if (c.Implementation != null)
                    {
                        var requiresMatching = c.Implementation.GetInterface(
                            typeof(IRequireGenericMatching <>).FullName);
                        if (requiresMatching == null)
                        {
                            return;
                        }
                        var matcher = requiresMatching.GetGenericArguments()[0];
                        c.ExtendedProperties(
                            Property.ForKey(Constants.GenericImplementationMatchingStrategy)
                            .Eq(Activator.CreateInstance(matcher)));
                    }
                }));
            }

            container.Register(Component.For <IValidatorFactory>()
                               .ImplementedBy <WindsorValidatorFactory>()
                               .OnlyNewServices());

            container.AddChildContainer(childContainer);
            container.Register(Component.For <IMediator>()
                               .Instance(childContainer.Resolve <IMediator>()));
        }
        TenantManager BuildTenants(IWindsorContainer container, DocumentStoreConfiguration config)
        {
            _logger.Debug("Configuring tenants");
            var manager = new TenantManager(container.Kernel);
            container.Register(Component.For<ITenantAccessor, TenantManager>().Instance(manager));

            foreach (var settings in config.TenantSettings)
            {
                _logger.DebugFormat("Adding tenant {0}", settings.TenantId);

                var tenant = manager.AddTenant(settings);
                tenant.Container.Kernel.Resolver.AddSubResolver(new CollectionResolver(tenant.Container.Kernel, true));
                tenant.Container.Kernel.Resolver.AddSubResolver(new ArrayResolver(tenant.Container.Kernel, true));
                tenant.Container.AddFacility<StartableFacility>();

                container.AddChildContainer(tenant.Container);
            }

            return manager;
        }