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>();
}
public void Build(IContainerBuilder containerBuilder, IBuilderContext context)
{
//TODO: Why is this done? --Aaron
var textManager = LocalizationConfig.SetupDefault();
containerBuilder.ForFactory(x => LocalizationConfig.TextManager)
.ScopedAs.Singleton();
}
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);
}
