public void Register(IContainerBuilder containerBuilder) { containerBuilder.RegisterType<Transport>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<MessageBus>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<Router>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<StorageDrivenPublisher>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<Receiver>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<CallBackManager>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<LocalBus>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<SubscriptionManager>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<Dispatcher>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<TimeoutProcessor>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<TypeMapper>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<MessageErrorModule>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<AuditModule>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<ExtractMessagesModule>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<MessageMutatorModule>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<DispatchMessagesModule>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<CallBackHandlerModule>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<MessageSerializationModule>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<HeaderBuilderModule>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<SendMessageModule>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<UnitOfWorkModule>(DependencyLifecycle.InstancePerUnitOfWork); containerBuilder.RegisterType<OutgoingMessageContext>(DependencyLifecycle.InstancePerDependency); var outgoingPipeline = new ModulePipeFactory<OutgoingMessageContext>() .Add<MessageMutatorModule>() .Add<MessageSerializationModule>() .Add<HeaderBuilderModule>() .Add<SendMessageModule>(); containerBuilder.RegisterSingleton(outgoingPipeline); }
private static void RegisterNoopDependencyHelper(IContainerBuilder containerBuilder, string providerKey) { LogHelper.TraceIfEnabled<ProviderDemandRunner>("Registering a NullProviderDependencyHelper for {0}", () => providerKey); containerBuilder.ForFactory(x => new NullProviderDependencyHelper(x.Resolve<ProviderMetadata>(providerKey))) .Named<ProviderDependencyHelper>(providerKey) .ScopedAs.Singleton(); }
public TestRunnerManager(IObjectContainer globalContainer, IContainerBuilder containerBuilder, RuntimeConfiguration runtimeConfiguration, IRuntimeBindingRegistryBuilder bindingRegistryBuilder) { this.globalContainer = globalContainer; this.containerBuilder = containerBuilder; this.runtimeConfiguration = runtimeConfiguration; this.bindingRegistryBuilder = bindingRegistryBuilder; }
/// <summary>Builds the dependency demands required by this implementation. </summary> /// <param name="containerBuilder">The <see cref="IContainerBuilder"/> .</param> /// <param name="context">The context for this building session containing configuration etc.</param> public void Build(IContainerBuilder containerBuilder, IBuilderContext context) { containerBuilder .ForFactory(x => new IndexConfiguration(context.MapPath("~/App_Data/DiskCaches/Lucene/"))) .KnownAsSelf() .ScopedAs.Singleton(); //containerBuilder // .ForFactory(x => new IndexController(x.Resolve<IndexConfiguration>(), null)) // .KnownAsSelf() // .OnActivated((ctx, ctrlr) => // { // var frameworkContext = ctx.Resolve<IFrameworkContext>(); // ctrlr.SetFrameworkContext(frameworkContext); // }) // .ScopedAs.Singleton(); containerBuilder .ForFactory(x => new IndexController(x.Resolve<IndexConfiguration>(), x.Resolve<IFrameworkContext>)) .KnownAsSelf() //.OnActivated((ctx, ctrlr) => //{ // var frameworkContext = ctx.Resolve<IFrameworkContext>(); // ctrlr.SetFrameworkContext(frameworkContext); //}) .ScopedAs.Singleton(); }
public void Build(IContainerBuilder containerBuilder, IBuilderContext context) { containerBuilder.For<MapResolverContext>().KnownAsSelf().ScopedAs.Singleton(); // register the model mappers containerBuilder.For<RenderTypesModelMapper>() .KnownAs<AbstractMappingEngine>() .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true) .ScopedAs.Singleton(); containerBuilder .For<FrameworkModelMapper>() .KnownAs<AbstractMappingEngine>() .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true) .ScopedAs.Singleton(); //register model mapper for security model objects containerBuilder .For<SecurityModelMapper>() .KnownAs<AbstractMappingEngine>() .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true) .ScopedAs.Singleton(); //register model mapper for web model objects containerBuilder .For<CmsModelMapper>() .KnownAs<AbstractMappingEngine>() .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true) .ScopedAs.Singleton(); }
private static void RegisterNoopBootstrapper(IContainerBuilder containerBuilder, string providerKey) { LogHelper.TraceIfEnabled<ProviderDemandRunner>("Registering a no-op bootstrapper for {0}", () => providerKey); containerBuilder.ForFactory(x => new NoopProviderBootstrapper()) .Named<AbstractProviderBootstrapper>(providerKey) .ScopedAs.Singleton(); }
protected override void Configure(IContainerBuilder builder) { builder.Register <HelloWorldService>(Lifetime.Scoped); builder.RegisterEntryPoint <GamePresenter>(Lifetime.Singleton); // TODO : GameObjectとの紐付け( これ以外の方法があるかはまだわからない ). builder.RegisterComponent(testObject); }
protected virtual void FindAndRegisterViewModels(IContainerBuilder builder, IList <Assembly> assemblies) { var viewModelViewMap = ViewModelFinder.GetViewModelToViewMapping(assemblies); RegisterViewModels(builder, viewModelViewMap); builder.Singleton(_ => viewModelViewMap, IfRegistered.Keep); }
public static void UseComponents( this IContainerBuilder builder, Action <ComponentsBuilder> configuration) { var components = new ComponentsBuilder(builder); configuration(components); }
public void Build(IContainerBuilder containerBuilder, IBuilderContext context) { //TODO: Why is this done? --Aaron var textManager = LocalizationConfig.SetupDefault(); containerBuilder.ForFactory(x => LocalizationConfig.TextManager) .ScopedAs.Singleton(); }
public static void OnTestRunEnd(Assembly testAssembly = null, IContainerBuilder containerBuilder = null) { testAssembly = testAssembly ?? Assembly.GetCallingAssembly(); var testRunnerManager = GetTestRunnerManager(testAssembly, createIfMissing: false, containerBuilder: containerBuilder); testRunnerManager?.FireTestRunEnd(); testRunnerManager?.Dispose(); }
private void RegisterPresenter(IContainerBuilder builder) { builder.Register <MainMenuPresenter>(Lifetime.Scoped).AsImplementedInterfaces(); builder.Register <LevelPresenter>(Lifetime.Scoped).AsImplementedInterfaces(); builder.Register <LevelAudioPresenter>(Lifetime.Scoped).AsImplementedInterfaces().WithParameter("audioClipCollections", _levelIntroClipCollections); builder.Register <ResultPresenter>(Lifetime.Scoped).AsImplementedInterfaces(); builder.Register <ResultAudioPresenter>(Lifetime.Scoped).AsImplementedInterfaces().WithParameter("audioClipCollections", _resultClipCollections); }
protected override void Configure(IContainerBuilder builder) { RegisterDomain(builder); RegisterMessagePipe(builder); RegisterPresenter(builder); RegisterController(builder); RegisterView(builder); }
protected override void Configure(IContainerBuilder builder) { var options = builder.RegisterMessagePipe(); builder.RegisterMessageBroker <int>(options); builder.RegisterEntryPoint <MessagePipeDemo>(Lifetime.Singleton); }
private void FreezeContainer() { if (this.container != null) return; this.container = this.builder.Build(); this.builder = null; // simple way to prevent accidental reuse of adapter }
public void Configure(IContainerBuilder containerBuilder) { ParserPipeline.AddParser(new FreeformQuestionParser()); ParserPipeline.AddParser(new YesNoQuestionParser()); ParserPipeline.AddParser(new MultipleOptionQuestionParser()); containerBuilder.RegisterType <ParserPipeline>(); }
private static void RegisterDomainRepository(Section section, IContainerBuilder builder) { var assemblyInfo = section["DomainRepository"]; var type = LoadTypeFromSetting(assemblyInfo); builder.Register(typeof(IDomainRepository <>), type, Scope.PerExecutionScope); }
public void Register(IContainerBuilder containerBuilder, IConfigManager configManager) { containerBuilder.RegisterSingleton <IBlockProducer, BlockProducer>(); containerBuilder.RegisterSingleton <IConsensusManager, ConsensusManager>(); containerBuilder.RegisterSingleton <IValidatorManager, ValidatorManager>(); containerBuilder.RegisterSingleton <IKeyGenManager, KeyGenManager>(); containerBuilder.RegisterSingleton <IValidatorStatusManager, ValidatorStatusManager>(); }
private static void RegisterEventStorage(Section section, IContainerBuilder builder) { var assemblyInfo = section["EventStorage"]; var type = LoadTypeFromSetting(assemblyInfo); builder.Register(typeof(IEventStorage), type); }
public NewWorldBuilder(IContainerBuilder containerBuilder, string worldName, Lifetime worldLifetime) { this.containerBuilder = containerBuilder; this.worldName = worldName; this.worldLifetime = worldLifetime; containerBuilder.RegisterNewWorld(worldName, worldLifetime); }
private static void RegisterMessageDistributor(Section section, IContainerBuilder builder) { var assemblyInfo = section["MessageDistributor"]; var type = LoadTypeFromSetting(assemblyInfo); builder.Register(typeof(IMessageDistributor), type, Scope.Singleton); }
public ProviderBootstrapper(IContainerBuilder containerBuilder, ProviderConfiguration configuration) { _containerBuilder = containerBuilder; _autofacContainerBuilder = ((AutofacContainerBuilder)containerBuilder).Builder; _configuration = configuration; _assemblies = new List <Assembly>(); LoadAllReferencedAssemblies(configuration); }
public ContextManager(ITestTracer testTracer, IObjectContainer testThreadContainer, IContainerBuilder containerBuilder) { this.featureContextManager = new InternalContextManager <FeatureContext>(testTracer); this.scenarioContextManager = new InternalContextManager <ScenarioContext>(testTracer); this.stepContextManager = new StackedInternalContextManager <ScenarioStepContext>(testTracer); this.testThreadContainer = testThreadContainer; this.containerBuilder = containerBuilder; }
/// <summary> /// Adds a service prototype of type <typeparamref name="TService"/>. /// </summary> /// <typeparam name="TService">The type of the service prototype to add.</typeparam> /// <param name="builder">The <see cref="IContainerBuilder"/> to add the service to.</param> /// <param name="instance">The service prototype to add.</param> /// <returns>The <see cref="IContainerBuilder"/> instance itself.</returns> public static IContainerBuilder AddServicePrototype <TService>( this IContainerBuilder builder, TService instance) { Debug.Assert(builder != null, "builder != null"); return(builder.AddService(ServiceLifetime.Singleton, sp => new ServicePrototype <TService>(instance))); }
public virtual void Customize(IContainerBuilder container) { container.AddService <ODataUriResolver, DefaultODataUriResolver>(ServiceLifetime.Singleton); container.AddService <ODataPrimitiveSerializer, DefaultODataPrimitiveSerializer>(ServiceLifetime.Singleton); container.AddService <ODataDeserializerProvider, ExtendedODataDeserializerProvider>(ServiceLifetime.Singleton); container.AddService <ODataEnumSerializer, DefaultODataEnumSerializer>(ServiceLifetime.Singleton); container.AddService <DefaultODataActionParameterDeserializer>(ServiceLifetime.Singleton); }
protected override void Bootstrap(IContainerBuilder builder) { builder.RegisterSingleton <ITestIface, TestImpl>(); builder.RegisterSingleton <ITestIface>(c => new TestImpl(4, c.ToString())); builder.RegisterSingleton <ITestIface>(c => new TestImpl()); builder.RegisterSingleton <ITestIface>(c => new TestImpl(c.ToString())); builder.RegisterSingleton <ITestIface>(c => new TestImpl(4)); }
private static void RegisterObjectSerializer(Section section, IContainerBuilder builder) { var assemblyInfo = section["ObjectSerializer"]; var type = LoadTypeFromSetting(assemblyInfo); builder.Register(typeof(IObjectSerializer <string>), type); }
public void Register(IContainerBuilder containerBuilder) { containerBuilder.Register <IBootstrapper, Bootstrapper>(); containerBuilder.RegisterSingleton <IPrompt, Prompt>(); containerBuilder.RegisterSingleton <IConsoleReader, ConsoleReader>(); containerBuilder.RegisterSingleton <IConsoleWriter, ConsoleWriter>(); }
internal static void Run(IContainerBuilder containerBuilder, string providerKey, Type type, TypeLoaderElement element) { LogHelper.TraceIfEnabled<ProviderDemandRunner>("Calling setup module for {0} in {1}", () => providerKey, () => type.Assembly.GetName().Name); // Check to see if the type has ProviderDemandsDependenciesAttribute, and if so, invoke the builder var attribs = type.GetCustomAttributes(typeof(DemandsDependenciesAttribute), true).OfType<DemandsDependenciesAttribute>(); var demandBuilders = attribs.Select(attrib => Activator.CreateInstance(attrib.DemandBuilderType)).OfType<AbstractProviderDependencyBuilder>().ToList(); if (!demandBuilders.Any()) { // The provider does not implement a demand builder, in which case we need to at least scaffold a noop bootstrapper so the installer can cope // and also a noop dependency helper LogHelper.TraceIfEnabled<ProviderDemandRunner>("No demand builders found of type AbstractProviderDependencyBuilder for {0} in {1}", () => providerKey, () => type.Assembly.GetName().Name); RegisterNoopBootstrapper(containerBuilder, providerKey); RegisterNoopDependencyHelper(containerBuilder, providerKey); } else foreach (var demandBuilder in demandBuilders) { demandBuilder.ProviderKey = providerKey; demandBuilder.RegistryConfigElement = element; // First, run Initialise to give the demand builder a chance to set things up demandBuilder.Initialise(containerBuilder.Context); // If the builder can build, run the rest if (demandBuilder.CanBuild) { containerBuilder.AddDependencyDemandBuilder(demandBuilder); } // Now get the factory for the provider's bootstrapper and register that var factory = demandBuilder.GetProviderBootstrapperFactory(containerBuilder.Context); if (factory == null) RegisterNoopBootstrapper(containerBuilder, providerKey); else { LogHelper.TraceIfEnabled<ProviderDemandRunner>("Registering a bootstrapper for {0}", () => providerKey); containerBuilder.ForFactory(factory) .Named<AbstractProviderBootstrapper>(providerKey) .ScopedAs.Singleton(); } // Now get the factory for the provider's dependency helper and register that var helperFactory = demandBuilder.GetProviderDependencyHelperFactory(containerBuilder.Context); if (helperFactory == null) { RegisterNoopDependencyHelper(containerBuilder, providerKey); } else { LogHelper.TraceIfEnabled<ProviderDemandRunner>("Registering a ProviderDependencyHelper for {0}", () => providerKey); containerBuilder.ForFactory(helperFactory) .NamedForSelf(providerKey) .ScopedAs.Singleton(); } } }
public void RegisterServices(IContainerBuilder containerBuilder, IConfigurationService configurationService) { containerBuilder.For <IMessageFactory <SiteSpeedJobDetails> >() .Use <MessageFactory <SiteSpeedJobDetails> >() .AsSingleton(); containerBuilder.For <IMessageSerializer <SiteSpeedJobDetails> >() .Use <MessageSerializer <SiteSpeedJobDetails> >() .AsSingleton(); }
public static IContainerBuilder RegisterAsyncRequestHandlerFilter <T>(this IContainerBuilder builder) where T : class, IAsyncRequestHandlerFilter { if (!builder.Exists(typeof(T), true)) { builder.Register <T>(Lifetime.Transient); } return(builder); }
public static SystemRegistrationBuilder RegisterSystemIntoDefaultWorld <T>(this IContainerBuilder builder) where T : ComponentSystemBase { var registrationBuilder = new SystemRegistrationBuilder(typeof(T), null) .IntoGroup <SimulationSystemGroup>(); builder.Register(registrationBuilder); return(registrationBuilder); }
public void Register(IContainerBuilder containerBuilder) { containerBuilder.RegisterType<MsmqReceiver>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<MsmqMessageSender>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<MsmqQueueCreator>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<MsmqSettings>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<MsmqUnitOfWork>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<StubPersistence>(DependencyLifecycle.SingleInstance); }
public TestRunnerManager(IObjectContainer globalContainer, IContainerBuilder containerBuilder, Configuration.SpecFlowConfiguration specFlowConfiguration, IRuntimeBindingRegistryBuilder bindingRegistryBuilder, ITestTracer testTracer) { this.globalContainer = globalContainer; this.containerBuilder = containerBuilder; this.specFlowConfiguration = specFlowConfiguration; this.bindingRegistryBuilder = bindingRegistryBuilder; this.testTracer = testTracer; }
public static IContainerBuilder UseContainer <TObjectFactory, TExtensibilityProvider>( IContainerBuilder builder, IEnumerable <Assembly> pluginAssemblies, IEnumerable <string> pluginPaths) where TObjectFactory : IObjectFactory where TExtensibilityProvider : IExtensibilityProvider { return(new GenericContainerBuilder <TObjectFactory, TExtensibilityProvider>(builder, pluginAssemblies, pluginPaths)); }
public AuthenticationAPIMiddleware(RequestDelegate next, T autenticate, IApplicationBuilder app, IContainerBuilder container) { _next = next; _auth = autenticate; _container = container; _app = app; //_container.Services.AddJWTAuth(); }
/// <summary> /// Adds a service of <typeparamref name="TService"/>. /// </summary> /// <typeparam name="TService">The type of the service to add.</typeparam> /// <param name="builder">The <see cref="IContainerBuilder"/> to add the service to.</param> /// <param name="lifetime">The lifetime of the service to register.</param> /// <returns>The <see cref="IContainerBuilder"/> instance itself.</returns> public static IContainerBuilder AddService <TService>( this IContainerBuilder builder, ServiceLifetime lifetime) where TService : class { Debug.Assert(builder != null, "builder != null"); return(builder.AddService(lifetime, typeof(TService))); }
public void Register(IContainerBuilder containerBuilder) { var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", false, true); var configurationRoot = builder.Build(); containerBuilder.Register <IConfiguration>(configurationRoot); }
public GenericContainerBuilder( IContainerBuilder builder, IEnumerable <Assembly> pluginAssemblies, IEnumerable <string> pluginPaths) : base(builder, pluginAssemblies, pluginPaths) { this.RegisterType <TObjectFactory, IObjectFactory, IServiceProvider>(InstanceScope.Singleton); this.RegisterType <TExtensibilityProvider, IExtensibilityProvider>(InstanceScope.Singleton); }
public override void Build(IContainerBuilder containerBuilder, IBuilderContext context) { //register the type mapper containerBuilder .For<MembershipWrapperModelMapper>() .KnownAs<AbstractMappingEngine>() .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true) .ScopedAs.Singleton(); }
public void Register(IContainerBuilder containerBuilder) { containerBuilder.RegisterType<PollingReceiver>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<SqlMessageDequeStrategy>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<SqlMessageSender>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<SqlQueueCreator>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<SqlSubscriptionStorage>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<SqlTimeoutStorage>(DependencyLifecycle.SingleInstance); containerBuilder.RegisterType<SqlErrorQueueManager>(DependencyLifecycle.SingleInstance); }
public void Build(IContainerBuilder containerBuilder, IBuilderContext context) { containerBuilder.For<DefaultConfigurationResolver>() .KnownAs<IConfigurationResolver>() .ScopedAs.Singleton(); new LocalizationSetup().Build(containerBuilder, context); containerBuilder.For<DefaultFrameworkContext>().KnownAs<IFrameworkContext>() .ScopedAs.HttpRequest(); }
internal static void Run(IContainerBuilder containerBuilder, Type type) { // Check to see if the type has DemandsDependenciesAttribute, and if so, invoke the builder var attribs = type.GetCustomAttributes(typeof(DemandsDependenciesAttribute), true) .OfType<DemandsDependenciesAttribute>(); var demandBuilders = attribs.Select(attrib => Activator.CreateInstance(attrib.DemandBuilderType)) .OfType<IDependencyDemandBuilder>(); foreach(var d in demandBuilders) { d.Build(containerBuilder, containerBuilder.Context); } }
public void Build(IContainerBuilder containerBuilder, IBuilderContext context) { //register model binder provider containerBuilder.RegisterModelBinderProvider(); // Register model binders & controllers var allReferencedPluginAssemblies = PluginManager.ReferencedPlugins.Select(x => x.ReferencedAssembly).ToArray(); containerBuilder .RegisterModelBinders(allReferencedPluginAssemblies, _typeFinder) .RegisterModelBinders(TypeFinder.GetFilteredBinFolderAssemblies(allReferencedPluginAssemblies), _typeFinder) .RegisterControllers(allReferencedPluginAssemblies, _typeFinder) .RegisterControllers(TypeFinder.GetFilteredBinFolderAssemblies(allReferencedPluginAssemblies), _typeFinder); //register view engines containerBuilder.For<EmbeddedRazorViewEngine>().KnownAs<IViewEngine>(); containerBuilder.For<PluginViewEngine>().KnownAs<IViewEngine>(); containerBuilder.For<RenderViewEngine>().KnownAs<IViewEngine>(); containerBuilder.For<AlternateLocationViewEngine>().KnownAs<IViewEngine>(); //register the route handlers containerBuilder.For<RenderRouteHandler>() .Named<IRouteHandler>(RenderRouteHandler.SingletonServiceName) .ScopedAs.NewInstanceEachTime(); // register our master controller factory and other IFilteredControllerFactories containerBuilder.For<MasterControllerFactory>().KnownAs<IControllerFactory>().ScopedAs.Singleton(); containerBuilder.For<RenderControllerFactory>().KnownAs<IFilteredControllerFactory>().ScopedAs.Singleton(); containerBuilder.For<PluginControllerFactory>().KnownAs<IFilteredControllerFactory>().ScopedAs.Singleton(); //register our rebel area, ensure that the TreeRouteHandler named service is injected for //the constructor argument expecting a IRouteHandler containerBuilder.For<RebelAreaRegistration>().KnownAsSelf(); containerBuilder.For<InstallAreaRegistration>().KnownAsSelf(); //register master view page activator containerBuilder.For<MasterViewPageActivator>().KnownAs<IViewPageActivator>().ScopedAs.Singleton(); //register our IPostViewPageActivators containerBuilder.For<RebelContextViewPageActivator>().KnownAs<IPostViewPageActivator>().ScopedAs.Singleton(); containerBuilder.For<RebelHelperViewPageActivator>().KnownAs<IPostViewPageActivator>().ScopedAs.Singleton(); containerBuilder.For<RenderViewPageActivator>().KnownAs<IPostViewPageActivator>().ScopedAs.Singleton(); //register model meta data provider containerBuilder.For<RebelModelMetadataProvider>().KnownAs<ModelMetadataProvider>(); ////register the default controller factory ////(We can't put this in the container based on the DependencyResolver because that will cause ////an infinite loop. Also, trying to use the Singly registered 'old school' way to get the ////ControllerFactory will cause AutoFac to call the DependencyResolver anyways) //containerBuilder.For<DefaultControllerFactory>().KnownAs<IControllerFactory>(); }
public void Build(IContainerBuilder containerBuilder, IBuilderContext context) { containerBuilder.For<DefaultConfigurationResolver>() .KnownAs<IConfigurationResolver>().ScopedAs.Singleton(); new LocalizationSetup().Build(containerBuilder, context); containerBuilder.For<DefaultFrameworkContext>().KnownAs<IFrameworkContext>().ScopedAs.Singleton(); containerBuilder .For<MappingEngineCollection>() .KnownAsSelf() .OnActivated((ctx, x) => x.Configure()) //once it's created, then we call Configure .ScopedAs.Singleton(); }
/// <summary> /// Builds the dependency demands required by this implementation. /// </summary> /// <param name="containerBuilder">The <see cref="IContainerBuilder"/> .</param> /// <param name="builderContext">The builder context.</param> public override void Build(IContainerBuilder containerBuilder, IBuilderContext builderContext) { Mandate.ParameterNotNull(containerBuilder, "containerBuilder"); Mandate.ParameterNotNull(builderContext, "builderContext"); // Configure type injection for this provider's implementation of the main interfaces containerBuilder.ForFactory(context => new DataContextFactory(HostingEnvironment.MapPath("~/App_Data/umbraco.config"))) .Named<AbstractDataContextFactory>(ProviderKey) .ScopedAs.Singleton(); containerBuilder.For<ReadOnlyUnitOfWorkFactory>() .Named<IReadOnlyUnitOfWorkFactory>(ProviderKey); containerBuilder.For<ReadWriteUnitOfWorkFactory>() .Named<IReadWriteUnitOfWorkFactory>(ProviderKey); }
public void Build(IContainerBuilder containerBuilder, IBuilderContext context) { containerBuilder.For<DefaultConfigurationResolver>() .KnownAs<IConfigurationResolver>().ScopedAs.Singleton(); new LocalizationSetup().Build(containerBuilder, context); // Go into configuration and figure out the required providers for the caches var config = General.GetFromConfigManager(); if (config == null) { string warning = "Could not find the Umbraco Framework configuration. Ensure that a configSection element is declared in the application's configuration, of type '{0}' using the xml element path of '{1}'. Using defaults for now." .InvariantFormat(typeof (General).FullName, General.ConfigXmlKey); LogHelper.Warn<FrameworkSetup>(warning); config = new General(); } var extended = config.CacheProviders.ExtendedLifetime.IfNotNull(x => x.GetProviderType()); Type extendedType = extended ?? typeof(RuntimeCacheProvider); var limited = config.CacheProviders.LimitedLifetime.IfNotNull(x => x.GetProviderType()); ; Type limitedType = limited ?? typeof(PerHttpRequestCacheProvider); DemandsDependenciesDemandRunniner.Run(containerBuilder, extendedType); DemandsDependenciesDemandRunniner.Run(containerBuilder, limitedType); containerBuilder.For(extendedType).Named<AbstractCacheProvider>("extended").ScopedAs.Singleton(); containerBuilder.For(limitedType).Named<AbstractCacheProvider>("limited").ScopedAs.Singleton(); containerBuilder .ForFactory(x => new DefaultFrameworkCaches(x.Resolve<AbstractCacheProvider>("limited"), x.Resolve<AbstractCacheProvider>("extended"))) //.ForFactory(x => new DefaultFrameworkCaches(null, null)) .KnownAs<IFrameworkCaches>() .ScopedAs .Singleton(); containerBuilder.For<ServiceStackSerialiser>().KnownAs<ISerializer>().ScopedAs.Singleton(); containerBuilder.For<SerializationService>().KnownAs<AbstractSerializationService>().ScopedAs.Singleton(); containerBuilder.For<DefaultFrameworkContext>().KnownAs<IFrameworkContext>().ScopedAs.Singleton(); containerBuilder .For<MappingEngineCollection>() .KnownAsSelf() .OnActivated((ctx, x) => x.Configure()) //once it's created, then we call Configure .ScopedAs.Singleton(); }
public static void Scan(IContainerBuilder containerBuilder) { IEnumerable<Type> messageTypes = GetMesageTypes(); ICollection<Type> messageHandlerTypes = GetMessageHandlerTypes(); ICollection<Type> commandValidatorTypes = GetCommandValidatorTypes(); ICollection<Type> queryHandlerTypes = GetQueryHandlerTypes(); ICollection<Type> queryServiceTypes = GetQueryServiceTypes(); ICollection<Type> intializerTypes = GetInitializerTypes(); HandlerCache.InitializeCache(messageTypes, messageHandlerTypes); RegisterTypes(containerBuilder, messageHandlerTypes, DependencyLifecycle.InstancePerUnitOfWork); RegisterTypes(containerBuilder, queryHandlerTypes, DependencyLifecycle.InstancePerUnitOfWork); RegisterTypes(containerBuilder, queryServiceTypes, DependencyLifecycle.InstancePerUnitOfWork); RegisterTypes(containerBuilder, commandValidatorTypes, DependencyLifecycle.InstancePerUnitOfWork); RegisterTypes(containerBuilder, intializerTypes, DependencyLifecycle.SingleInstance); }
/// <summary>Builds the dependency demands required by this implementation. /// This method will only be executed if <see cref="AbstractProviderDependencyBuilder.CanBuild"/> is set to true. Providers have an opportunity to do this in <see cref="Initialise"/> dependent upon whatever checks are necessary.</summary> /// <param name="containerBuilder">The <see cref="Framework.DependencyManagement.IContainerBuilder"/> .</param> /// <param name="builderContext"></param> public override void Build(IContainerBuilder containerBuilder, IBuilderContext builderContext) { Mandate.ParameterNotNull(containerBuilder, "containerBuilder"); Mandate.ParameterNotNull(builderContext, "builderContext"); containerBuilder.AddDependencyDemandBuilder(new NHibernateConfigBuilder(ProviderKey, _localConfig)); containerBuilder .ForFactory(x => new ManualMapperv2(new NhLookupHelper(x.Resolve<EntityRepositoryFactory>(ProviderKey)), x.Resolve<ProviderMetadata>(ProviderKey))) .KnownAs<AbstractMappingEngine>() .KnownAsSelf() .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true) .ScopedAs.Singleton(); containerBuilder.ForFactory(x => new NhFactoryHelper(x.Resolve<global::NHibernate.Cfg.Configuration>(ProviderKey), null, false, false, x.Resolve<IFrameworkContext>())) .NamedForSelf(ProviderKey) .ScopedAs.Singleton(); }
/// <summary> /// Registers all candidates. /// </summary> /// <param name="containerBuilder">The containerbuilder.</param> /// <param name="configuration">The configuration</param> public void Register(IContainerBuilder containerBuilder, LightCoreConfiguration configuration) { this._configuration = configuration; this._containerBuilder = containerBuilder; IEnumerable<RegistrationGroup> registrationGroups = configuration.RegistrationGroups; IEnumerable<Registration> registrationsToRegister = configuration.Registrations; if (configuration.ActiveRegistrationGroups == null) { registrationsToRegister = registrationsToRegister.Union(registrationGroups.SelectMany(g => g.Registrations)); } else { var activeGroups = configuration.ActiveRegistrationGroups.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); foreach (string group in activeGroups) { if (!registrationGroups.Any(g => g.Name != null && g.Name.Trim() == group.Trim())) { throw new ActiveGroupNotFoundException( Resources.ActiveRegistrationGroupNotFoundFormat.FormatWith(group)); } } Func<RegistrationGroup, bool> groupNameIsEmpty = group => string.IsNullOrEmpty(group.Name); Func<RegistrationGroup, bool> groupNameIsNotEmpty = group => !groupNameIsEmpty(group); Func<RegistrationGroup, bool> groupIsActive = group => activeGroups.Any(activeGroup => activeGroup.Trim() == group.Name.Trim()); var validGroupRegistrations = registrationGroups .Where(group => groupNameIsEmpty(group) || groupNameIsNotEmpty(group) && groupIsActive(group)) .SelectMany(group => group.Registrations); registrationsToRegister = registrationsToRegister.Union(validGroupRegistrations); } foreach (Registration registration in registrationsToRegister) { ProcessRegistration(registration); } }
public static void Scan(IContainerBuilder containerBuilder) { using (var scanner = new AssemblyScanner()) { IEnumerable<Type> messageTypes = GetMesageTypes(scanner); ICollection<Type> messageHandlerTypes = GetMessageHandlerTypes(scanner); foreach (var messageHandlerType in messageHandlerTypes) { containerBuilder.RegisterType(messageHandlerType, DependencyLifecycle.InstancePerUnitOfWork); } foreach (var messageType in messageTypes) { CacheHandlersForMessageContract(messageType, messageHandlerTypes); } foreach (var intitializer in scanner.Types.Where(t => typeof(INeedToInitializeSomething).IsAssignableFrom(t) && !t.IsAbstract)) { containerBuilder.RegisterType(intitializer, DependencyLifecycle.SingleInstance); } } }
public void Build(IContainerBuilder containerBuilder, IBuilderContext context) { containerBuilder.For(typeof(PugpigRepository)).KnownAs<IPugpigRepository>(); containerBuilder.For(typeof(AbstractRequest)).KnownAs<IAbstractRequest>(); // containerBuilder.Build(); }
/// <summary> /// Registers all controllers by its name. /// </summary> /// <param name="containerBuilder">The container builder.</param> public override void Register(IContainerBuilder containerBuilder) { this._controllerAssemblies.ForEach(a => this.RegisterControllers(a, containerBuilder)); }
/// <summary> /// Registers all controllers within one assembly. /// </summary> /// <param name="controllerAssembly">The controller assembly.</param> /// <param name="containerBuilder">The container builder.</param> private void RegisterControllers(Assembly controllerAssembly, IContainerBuilder containerBuilder) { Type typeOfController = typeof(IController); Type[] allPublicTypes = controllerAssembly.GetExportedTypes(); var controllerTypes = allPublicTypes.Where(t => typeOfController.IsAssignableFrom(t) && !t.IsAbstract); controllerTypes.ForEach(t => containerBuilder.Register(t, t)); }
public void TestInitialize() { //TODO: Switch over to using NUnit to avoid repeating test code for different providers (e.g. AutoFac and Ninject) _containerBuilder = new AutofacContainerBuilder(); _factorySettings = new UmbracoFactorySettings(); }
public override void Build(IContainerBuilder containerBuilder, IBuilderContext context) { Mandate.ParameterNotNull(containerBuilder, "containerBuilder"); Mandate.ParameterNotNull(context, "context"); var configMgr = DeepConfigManager.Default; var configMain = context.ConfigurationResolver .GetConfigSection(HiveConfigurationSection.ConfigXmlKey) as HiveConfigurationSection; if (configMain == null) throw new ConfigurationErrorsException( string.Format("Configuration section '{0}' not found when building packaging provider '{1}'", HiveConfigurationSection.ConfigXmlKey, ProviderKey)); var readWriteConfig = configMain.AvailableProviders.ReadWriters[ProviderKey] ?? configMain.AvailableProviders.Readers[ProviderKey]; if (readWriteConfig == null) throw new ConfigurationErrorsException( string.Format("No configuration found for persistence provider '{0}'", ProviderKey)); var localConfig = DeepConfigManager .Default .GetWebSettings<ProviderConfigurationSection, ProviderConfigurationSection>(readWriteConfig.ConfigSectionKey, x => x, "~/App_Plugins") .First(); if (localConfig == null) throw new ConfigurationErrorsException( "Unable to resolve the configuration for the FileSystem repository"); //TODO: Fix hard-coded plugin folder path --Aaron var supportedExtensions = configMgr.GetWebSetting<ProviderConfigurationSection, string>(readWriteConfig.ConfigSectionKey, x => x.SupportedExtensions, "~/App_Plugins"); var rootPath = configMgr.GetWebSetting<ProviderConfigurationSection, string>(readWriteConfig.ConfigSectionKey, x => x.RootPath, "~/App_Plugins"); var excludeExtensions = configMgr.GetWebSetting<ProviderConfigurationSection, string>(readWriteConfig.ConfigSectionKey, x => x.ExcludeExetensions, "~/App_Plugins"); if (!rootPath.EndsWith("/")) rootPath = rootPath + "/"; containerBuilder .ForFactory(x => new ProviderBootstrapper(localConfig)) .Named<AbstractProviderBootstrapper>(ProviderKey) .ScopedAs.Singleton(); containerBuilder .ForFactory(c => new DataContextFactory( supportedExtensions, c.Resolve<HttpContextBase>().Server.MapPath(rootPath), rootPath, excludeExtensions) ) .Named<AbstractDataContextFactory>(ProviderKey) .ScopedAs.NewInstanceEachTime(); containerBuilder .For<ReadWriteUnitOfWorkFactory>() .Named<IReadOnlyUnitOfWorkFactory>(ProviderKey) .ScopedAs.Singleton(); containerBuilder .For<ReadWriteUnitOfWorkFactory>() .Named<IReadWriteUnitOfWorkFactory>(ProviderKey) .ScopedAs.Singleton(); }
private static void RegisterTypes(IContainerBuilder containerBuilder, IEnumerable<Type> types, DependencyLifecycle dependencyLifecycle) { foreach (var type in types) { containerBuilder.RegisterType(type, dependencyLifecycle); } }
public void Build(IContainerBuilder containerBuilder, IBuilderContext builderContext) { //TODO: Move code from the Autofac module "ProviderAutoSetup" throw new NotImplementedException(); }
private static void Registration(IContainerBuilder builder) { ContainerSetup.Setup(builder); }