public void Register(IDependencyBuilder builder)
{
// Register queues
builder.Autofac.RegisterAzureQueue(_options.AzureConnectionString, QueueNames.SendEmail);
builder.Autofac.RegisterAzureQueue(_options.AzureConnectionString, QueueNames.SendNotifyEmail);
builder.Autofac.RegisterAzureQueue(_options.AzureConnectionString, QueueNames.ExecuteWebJob);
}
public void Register(IDependencyBuilder builder)
{
//Add registrations here
builder.Autofac.RegisterType <SharedBusinessLogic>().As <ISharedBusinessLogic>().SingleInstance();
builder.Autofac.RegisterType <UpdateFromCompaniesHouseService>()
.As <UpdateFromCompaniesHouseService>().InstancePerLifetimeScope();
}
public static IInputPlugin Load(IDependencyBuilder builder, InputConfiguration configuration, AssemblyLoadContext assemblyLoader)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (string.IsNullOrWhiteSpace(configuration.InputType))
{
throw new Exception("Can not instantiate a translation plugin without a plugin name.");
}
var assemblyName = $"{typeof(InputPluginLoader).Namespace}.{configuration.InputType}";
var assembly = assemblyLoader.LoadFromAssemblyName(new AssemblyName(assemblyName));
var type = assembly.GetExportedTypes().FirstOrDefault(x => typeof(IInputPlugin).GetTypeInfo().IsAssignableFrom(x));
if (type == null)
{
throw new Exception($"Can not find a class implementing '{nameof(IInputPlugin)}' in assembly '{assembly.FullName}'.");
}
var plugin = Activator.CreateInstance(type) as IInputPlugin;
if (plugin == null)
{
throw new Exception($"Couldn't instantiate '{type.Name}' plugin.");
}
plugin.RegisterPlugin(configuration, builder);
return(plugin);
}
public void Register(IDependencyBuilder builder)
{
//Register references dependency modules
builder.RegisterModule <ModernSlavery.BusinessDomain.Shared.DependencyModule>();
builder.RegisterModule <ModernSlavery.WebUI.GDSDesignSystem.DependencyModule>();
//Register HttpCache and HttpSession
builder.Autofac.RegisterType <HttpSession>().As <IHttpSession>().InstancePerLifetimeScope();
builder.Autofac.RegisterType <HttpCache>().As <IHttpCache>().SingleInstance();
//Register the web service container
builder.Autofac.RegisterType <WebService>().As <IWebService>().InstancePerLifetimeScope();
//Register factories
builder.Autofac.RegisterType <ErrorViewModelFactory>().As <IErrorViewModelFactory>()
.SingleInstance();
//Register Email queuers
builder.Autofac.RegisterType <SendEmailService>().As <ISendEmailService>().SingleInstance().WithAttributeFiltering();
builder.Autofac.RegisterType <NotificationService>().As <INotificationService>().SingleInstance().WithAttributeFiltering();
////Register all controllers - this is required to ensure KeyFilter is resolved in constructors
//builder.Autofac.RegisterAssemblyTypes(typeof(DependencyModule).Assembly)
// .Where(t => t.IsAssignableTo<Controller>())
// .InstancePerLifetimeScope()
// .WithAttributeFiltering();
//Register StaticAssetsVersioningHelper
builder.Services.AddSingleton <StaticAssetsVersioningHelper>();
//Add the custom url helper
builder.Services.AddSingleton <IUrlHelperFactory, CustomUrlHelperFactory>();
}
public void Register(IDependencyBuilder builder)
{
//Add registrations here
builder.Autofac.RegisterType <DownloadableFileBusinessLogic>().As <IDownloadableFileBusinessLogic>()
.InstancePerLifetimeScope();
builder.Autofac.RegisterType <AdminService>().As <IAdminService>().InstancePerLifetimeScope().WithAttributeFiltering();
}
public void Register(IDependencyBuilder builder)
{
builder.Autofac.RegisterType <DatabaseContext>().As <IDbContext>().InstancePerLifetimeScope();
builder.Autofac.RegisterType <SqlRepository>().As <IDataRepository>().InstancePerLifetimeScope();
builder.Autofac.RegisterType <ShortCodesRepository>().As <IShortCodesRepository>().InstancePerLifetimeScope();
}
public void Register(IDependencyBuilder builder)
{
//Add registrations here
builder.Autofac.RegisterType <SearchBusinessLogic>().As <ISearchBusinessLogic>().SingleInstance()
.WithAttributeFiltering();
builder.Autofac.RegisterType <ViewingService>().As <IViewingService>().SingleInstance();
builder.Autofac.RegisterType <CompareBusinessLogic>().As <ICompareBusinessLogic>()
.InstancePerLifetimeScope();
}
public void Register(IDependencyBuilder builder)
{
builder.Autofac.RegisterType <SnapshotDateHelper>().As <ISnapshotDateHelper>().SingleInstance();
//Register some singletons
builder.Autofac.RegisterType <InternalObfuscator>().As <IObfuscator>().SingleInstance()
.WithParameter("seed", _sharedOptions.ObfuscationSeed);
builder.Autofac.RegisterType <SourceComparer>().As <ISourceComparer>().SingleInstance();
}
public static void ConfigurePerformanceTest(this IDependencyBuilder builder)
{
builder.Bind <PerformanceMethodTest>().Resolve <IPerformanceMethodTest>();
builder.BindFunction((ctx) => PerformanceMethodTest.Method()).Resolve <IPerformanceMethodResultTest>();
builder.Bind <PerformanceConstructParamTest>().Resolve <IPerformanceConstructParam1Test>();
builder.Bind <PerformanceConstructParamTest>().Resolve <IPerformanceConstructParam2Test>();
builder.Bind <PerformanceConstructParamTest>().Resolve <IPerformanceConstructParam3Test>();
builder.Bind <PerformanceConstructTest>().Resolve <IPerformanceConstructTest>();
builder.Bind <PerformanceSingletonTest>().Resolve <IPerformanceSingletonTest>().InSingletonScope();
builder.BindInstance(new PerformanceInstanceTest()).Resolve <IPerformanceInstanceTest>();
}
public void Register(IDependencyBuilder builder)
{
//Add registrations here
builder.Autofac.RegisterType <ScopeBusinessLogic>().As <IScopeBusinessLogic>()
.InstancePerLifetimeScope();
builder.Autofac.RegisterType <SubmissionService>().As <ISubmissionService>()
.InstancePerLifetimeScope().WithAttributeFiltering();
builder.Autofac.RegisterType <SubmissionBusinessLogic>().As <ISubmissionBusinessLogic>()
.InstancePerLifetimeScope().WithAttributeFiltering();
builder.Autofac.RegisterType <DraftFileBusinessLogic>().As <IDraftFileBusinessLogic>()
.SingleInstance();
}
public PackageProcessorController(ISourceSchema schema, ILog log, ISqlBuilder sqlBuilder, IDependencyBuilder dependencyBuilder)
{
Affirm.ArgumentNotNull(schema, "schema");
Affirm.ArgumentNotNull(log, "log");
Affirm.ArgumentNotNull(sqlBuilder, "sqlBuilder");
Affirm.ArgumentNotNull(dependencyBuilder, "dependencyBuilder");
_schema = schema;
_sqlBuilder = sqlBuilder;
_log = log;
_dependencyBuilder = dependencyBuilder;
}
public void RegisterPlugin(InputConfiguration configuration, IDependencyBuilder builder)
{
builder.Register <IAttributeProvider, AttributeProvider>();
builder.Register <IAttributeParameterProvider, AttributeParameterProvider>();
builder.Register <IClassProvider, ClassProvider>();
builder.Register <IEnumProvider, EnumProvider>();
builder.Register <IEnumValueProvider, EnumValueProvider>();
builder.Register <IMethodProvider, MethodProvider>();
builder.Register <IParameterProvider, ParameterProvider>();
builder.Register <IPropertyProvider, PropertyProvider>();
builder.Register <IStructProvider, StructProvider>();
builder.RegisterScoped <IInputService, InputService>();
}
private void SceneDependenciesRegistration(IDependencyBuilder builder, ISceneHost scene)
{
string kind;
if (scene.Metadata.TryGetValue(METADATA_KEY, out kind))
{
GameFinderConfig config;
if (Configs.TryGetValue(kind, out config))
{
config.RegisterDependencies(builder);
}
}
}
public void Register(IDependencyBuilder builder)
{
//Register references dependency modules
builder.RegisterModule <ModernSlavery.BusinessDomain.Shared.DependencyModule>();
builder.RegisterModule <ModernSlavery.WebUI.Shared.DependencyModule>();
//TODO: Register dependencies here
//Register all controllers - this is required to ensure KeyFilter is resolved in constructors
builder.Autofac.RegisterAssemblyTypes(typeof(DependencyModule).Assembly)
.Where(t => t.IsAssignableTo <Controller>())
.InstancePerLifetimeScope()
.WithAttributeFiltering();
}
public void Register(IDependencyBuilder builder)
{
//Add registrations here
builder.Autofac.RegisterType <OrganisationBusinessLogic>().As <IOrganisationBusinessLogic>()
.InstancePerLifetimeScope();
builder.Autofac.RegisterType <SecurityCodeBusinessLogic>().As <ISecurityCodeBusinessLogic>()
.SingleInstance();
builder.Autofac.RegisterType <RegistrationService>().As <IRegistrationService>()
.InstancePerLifetimeScope().WithAttributeFiltering();
builder.Autofac.RegisterType <RegistrationBusinessLogic>().As <IRegistrationBusinessLogic>()
.InstancePerLifetimeScope();
builder.Autofac.RegisterType <PinInThePostService>().As <IPinInThePostService>().SingleInstance();
}
/// <summary>
/// Configure the API HTTP factory for the solution.
/// </summary>
/// <param name="builder">The dependency builder.</param>
/// <param name="handlerFactory">Specify the handler factory.</param>
/// <returns></returns>
public static IDependencyBuilder ConfigureHttp(this IDependencyBuilder builder, IApiHttpHandlerFactory handlerFactory)
{
if (handlerFactory is null)
{
throw new ArgumentNullException(nameof(handlerFactory));
}
ApiHttpFactory.Instance = new ApiHttpFactory(new System.Net.Http.HttpClient(), handlerFactory, new ApiHttpRequestHandlerBindingMap());
builder.BindInstance(ApiHttpFactory.Instance).Resolve <IApiHttpFactory>();
builder.BindFunction((ctx) => ApiHttpFactory.Instance.NewClient(ctx.Info.Key)).Resolve <IApiHttpClient>().InTransientScope();
return(builder);
}
public void RegisterPlugin(InputConfiguration configuration, IDependencyBuilder builder)
{
builder.Register <IAttributeDefinitionProvider <Attribute, Type>, AttributeDefinitionProvider>();
builder.Register <IAttributeParameterDefinitionProvider <Tuple <PropertyInfo, object>, Type>, AttributeParameterDefinitionProvider>();
builder.Register <IClassDefinitionProvider <Type, Type>, ClassDefinitionProvider>();
builder.Register <IEnumDefinitionProvider <Type, Type>, EnumDefinitionProvider>();
builder.Register <IEnumValueDefinitionProvider <object, Type>, EnumValueDefinitionProvider>();
builder.Register <IMethodDefinitionProvider <MethodInfo, Type>, MethodDefinitionProvider>();
builder.Register <IParameterDefinitionProvider <ParameterInfo, Type>, ParameterDefinitionProvider>();
builder.Register <IPropertyDefinitionProvider <PropertyInfo, Type>, PropertyDefinitionProvider>();
builder.Register <IStructDefinitionProvider <Type, Type>, StructDefinitionProvider>();
builder.Register <IObjectDefinitions <Type>, ObjectDefinitions>();
builder.RegisterScoped <IInputService, InputService>();
}
private void SceneDependenciesRegistration(IDependencyBuilder builder, ISceneHost scene)
{
string kind;
if (scene.Metadata.TryGetValue(METADATA_KEY, out kind))
{
MatchmakingConfig config;
if (Configs.TryGetValue(kind, out config))
{
config.RegisterDependencies(builder);
}
}
builder.Register <MatchmakingService>().As <IMatchmakingService>().InstancePerScene();
}
private void RegisterDependencies(IDependencyBuilder b)
{
//Indices
b.Register <UserPeerIndex>().As <IUserPeerIndex>().SingleInstance();
b.Register <PeerUserIndex>().As <IPeerUserIndex>().SingleInstance();
b.Register <UserToGroupIndex>().SingleInstance();
b.Register <GroupsIndex>().SingleInstance();
b.Register <SingleNodeActionStore>().As <IActionStore>().SingleInstance();
b.Register <SceneAuthorizationController>();
b.Register <UserManagementConfig>(_config);
b.Register <UserService>().As <IUserService>();
b.Register <UserSessions>().As <IUserSessions>();
}
/// <summary>
/// Configure the <see cref="IApiCommandContentSerializer"/> serializers and <see cref="IApiCommandContentDeserializer"/> deserializers.
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IDependencyBuilder ConfigureApi(this IDependencyBuilder builder)
{
builder.Bind <DefaultFormUrlEncodedContentParser>().Resolve <IDefaultFormUrlEncodedContentParser>().WithKey(ApiSerializer.FormUrlEncoded);
builder.Bind <ApiCommandContentSerializerFormUrlEncoded>().Resolve <IApiCommandContentSerializer>().WithKey(ApiSerializer.FormUrlEncoded);
builder.Bind <ApiCommandContentSerializerJson>().Resolve <IApiCommandContentSerializer>().WithKey(ApiSerializer.Json);
builder.Bind <ApiCommandContentSerializerString>().Resolve <IApiCommandContentSerializer>().WithKey(ApiSerializer.String);
builder.Bind <ApiCommandContentSerializerXml>().Resolve <IApiCommandContentSerializer>().WithKey(ApiSerializer.Xml);
builder.Bind <ApiCommandContentSerializerFormUrlEncoded>().Resolve <IApiCommandContentDeserializer>().WithKey(ApiSerializer.FormUrlEncoded);
builder.Bind <ApiCommandContentSerializerJson>().Resolve <IApiCommandContentDeserializer>().WithKey(ApiSerializer.Json);
builder.Bind <ApiCommandContentSerializerString>().Resolve <IApiCommandContentDeserializer>().WithKey(ApiSerializer.String);
builder.Bind <ApiCommandContentSerializerXml>().Resolve <IApiCommandContentDeserializer>().WithKey(ApiSerializer.Xml);
return(builder);
}
/// <summary>
/// Configure the <see cref="IHttpResponseFactory"/> and <see cref="IApiCommandFactory"/> and bind the <see cref="IApiCommandAsync"/> for all commands under <see cref="HttpRequestType"/>
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IDependencyBuilder ConfigureApi(this IDependencyBuilder builder)
{
builder.Bind <HttpResponseFactory>().Resolve <IHttpResponseFactory>().InSingletonScope();
builder.Bind <ApiCommandFactory>().Resolve <IApiCommandFactory>().InSingletonScope();
builder.Bind(typeof(ApiCommandContentTypeMap <>)).Resolve(typeof(IApiCommandContentTypeMap <>));
builder.BindFactory <IApiCommandFactory>(nameof(IApiCommandFactory.CreateGetCommand)).Resolve <IApiCommandAsync>().WithKey(HttpRequestType.Get);
builder.BindFactory <IApiCommandFactory>(nameof(IApiCommandFactory.CreateDeleteCommand)).Resolve <IApiCommandAsync>().WithKey(HttpRequestType.Delete);
builder.BindFactory <IApiCommandFactory>(nameof(IApiCommandFactory.CreatePutCommand)).Resolve <IApiCommandAsync>().WithKey(HttpRequestType.Put);
builder.BindFactory <IApiCommandFactory>(nameof(IApiCommandFactory.CreatePostCommand)).Resolve <IApiCommandAsync>().WithKey(HttpRequestType.Post);
builder.BindFactory <IApiCommandFactory>(nameof(IApiCommandFactory.CreatePatchCommand)).Resolve <IApiCommandAsync>().WithKey(HttpRequestType.Patch);
builder.BindFactory <IApiCommandFactory>(nameof(IApiCommandFactory.CreateSendCommand)).Resolve <IApiCommandAsync>().WithKey(HttpRequestType.Custom);
return(builder);
}
public void Register(IDependencyBuilder builder)
{
// use the 'localStorageRoot' when hosting the storage in a local folder
if (string.IsNullOrWhiteSpace(_options.LocalStorageRoot))
{
builder.Autofac.Register(
c => new AzureFileRepository(_options,
new ExponentialRetry(TimeSpan.FromMilliseconds(500), 10)))
.As <IFileRepository>()
.SingleInstance();
}
else
{
builder.Autofac.Register(c => new SystemFileRepository(_options)).As <IFileRepository>()
.SingleInstance();
}
}
public void Register(IDependencyBuilder builder)
{
//Add a dedicated httpclient for Companies house API with exponential retry policy
builder.Services.AddHttpClient <ICompaniesHouseAPI, CompaniesHouseAPI>(nameof(ICompaniesHouseAPI),
httpClient =>
{
CompaniesHouseAPI.SetupHttpClient(httpClient, _companiesHouseOptions.ApiServer, _companiesHouseOptions.ApiKey);
})
.SetHandlerLifetime(TimeSpan.FromMinutes(10))
.AddPolicyHandler(CompaniesHouseAPI.GetRetryPolicy());
builder.Autofac.RegisterType <CompaniesHouseAPI>()
.As <ICompaniesHouseAPI>()
.SingleInstance()
.WithParameter(
(p, ctx) => p.ParameterType == typeof(HttpClient),
(p, ctx) => ctx.Resolve <IHttpClientFactory>().CreateClient(nameof(ICompaniesHouseAPI)));
builder.Autofac.RegisterType <PostcodeChecker>().As <IPostcodeChecker>().SingleInstance();
}
private void RegisterDependencies(IDependencyBuilder b)
{
//Indices
//b.Register<UserToGroupIndex>().SingleInstance();
//b.Register<GroupsIndex>().SingleInstance();
//b.Register<SingleNodeActionStore>().As<IActionStore>().SingleInstance();
b.Register <SceneAuthorizationController>();
b.Register <UserSessionController>();
b.Register <AuthenticationController>().InstancePerRequest();
b.Register <AuthenticationService>().As <IAuthenticationService>().InstancePerRequest();
b.Register <UserService>().As <IUserService>();
b.Register <UserManagementConfig>().SingleInstance();
b.Register <UsersAdminController>();
b.Register <AdminWebApiConfig>().As <IAdminWebApiConfig>();
b.Register <UserSessionCache>().AsSelf().InstancePerScene();
b.Register <PlatformSpecificServices>().As <IPlatformSpecificServices>();
}
public void Register(IDependencyBuilder builder)
{
if (string.IsNullOrWhiteSpace(_sharedOptions.GoogleAnalyticsAccountId))
{
if (_sharedOptions.IsProduction())
{
throw new ArgumentNullException(nameof(_sharedOptions.GoogleAnalyticsAccountId));
}
builder.Autofac.RegisterType <FakeWebTracker>().As <IWebTracker>().SingleInstance();
return;
}
//Add a dedicated httpclient for Google Analytics tracking with exponential retry policy
builder.Services.AddHttpClient <IWebTracker, GoogleAnalyticsTracker>(nameof(IWebTracker), client =>
{
client.BaseAddress = GoogleAnalyticsTracker.BaseUri;
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.ConnectionClose = false;
ServicePointManager.FindServicePoint(client.BaseAddress).ConnectionLeaseTimeout = 60 * 1000;
})
.SetHandlerLifetime(TimeSpan.FromMinutes(10))
.AddPolicyHandler(
//see https://developers.google.com/analytics/devguides/config/mgmt/v3/errors
HttpPolicyExtensions
.HandleTransientHttpError()
.WaitAndRetryAsync(6,
retryAttempt => TimeSpan.FromMilliseconds(new Random().Next(1, 1000)) +
TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))));
//Register WebTracker
builder.Autofac.RegisterType <GoogleAnalyticsTracker>()
.As <IWebTracker>()
.SingleInstance()
.WithParameter(
(p, ctx) => p.ParameterType == typeof(HttpClient),
(p, ctx) => ctx.Resolve <IHttpClientFactory>().CreateClient(nameof(IWebTracker)))
.WithParameter("trackingId", _sharedOptions.GoogleAnalyticsAccountId);
}
public static void ConfigureTest(this IDependencyBuilder builder)
{
builder.Bind <NormalClass>().Resolve <INormalClass>().InTransientScope();
builder.Bind <CallingClass>().Resolve <ICallingClass>();
builder.Bind <ChildClass>().Resolve <IChildClass>();
builder.Bind <SingletonClassTest>().Resolve <ISingletonClass>().InSingletonScope();
builder.Bind <SingletonClassTest>().Resolve <ISingletonNamedClass>().InSingletonScope().WithKey(nameof(ISingletonNamedClass));
builder.Bind <SingletonClassTest>().Resolve <ISingletonEnumClass>().InSingletonScope().WithKey(EnumAsKey.Key);
builder.Bind <SingletonClassTest>().Resolve <ISingletonKeyClass>().InSingletonScope().WithKey(typeof(ISingletonKeyClass));
builder.Bind <SingletonSameInstanceClassTest>().Resolve(typeof(ISingletonSameInstanceClassTest), typeof(ISingletonSameInstanceClassTest2), typeof(ISingletonSameInstanceClassTest3), typeof(ISingletonSameInstanceClassTest4)).InSingletonScope();
builder.Bind <MultipleConstructorClass>().Resolve <IMultipleConstructorClass>();
builder.Bind <FactoryClass>().Resolve <IFactoryClass>().InSingletonScope();
builder.BindFunction((ctx) => ctx.Ioc.Resolve <IFactoryClass>().ResolveFactoryResolutionClass(ctx.GetArguments())).Resolve <IFactoryResolutionClass>().WithKey(MethodWithArgs);
builder.BindFunction((ctx) => ctx.Ioc.Resolve <IFactoryClass>().ResolveFactoryResolutionClass()).Resolve <IFactoryResolutionClass>().WithKey(MethodWithNoArgs);
builder.Bind <FactoryResolutionClass>().Resolve <IFactoryResolutionClass>().WithKey(NotMethod);
builder.Bind <NotBindedClass>().Resolve <INotBindedKeyed>().WithKey(NotResolvedName);
builder.Bind <NotBindedClass>().Resolve <INotBindedKeyed>().WithKey(EnumAsKey.Key);
builder.Bind <NotBindedClass>().Resolve <INotBindedKeyed>().WithKey(typeof(INormalClass));
builder.Bind(typeof(GenericTypeTest <>)).Resolve(typeof(IGenericTypeTests <>));
builder.Bind(typeof(GenericTypeTest <>)).Resolve(typeof(IGenericSingletonTests <>)).InSingletonScope();
builder.Bind <MultipleBindingClassTest1>().Resolve <IMultipleBindingClassTest>().WithKey(nameof(MultipleBindingClassTest1));
builder.Bind <MultipleBindingClassTest2>().Resolve <IMultipleBindingClassTest>().WithKey(nameof(MultipleBindingClassTest2));
builder.Bind <MultipleBindingClassTest3>().Resolve <IMultipleBindingClassTest>().WithKey(nameof(MultipleBindingClassTest3));
builder.Bind <MultipleBindingConstructorClassTest>().Resolve <IMultipleBindingConstructorClassTest>();
builder.Bind(typeof(MultipleBindingConstructorClassTest <>)).Resolve(typeof(IMultipleBindingConstructorClassTest <>));
builder.Bind(typeof(MultipleBindingClassTest1 <>)).Resolve(typeof(IMultipleBindingClassTest <>)).WithKey(typeof(MultipleBindingClassTest1 <>).Name);
builder.Bind(typeof(MultipleBindingClassTest2 <>)).Resolve(typeof(IMultipleBindingClassTest <>)).WithKey(typeof(MultipleBindingClassTest2 <>).Name);
builder.Bind(typeof(MultipleBindingClassTest3 <>)).Resolve(typeof(IMultipleBindingClassTest <>)).WithKey(typeof(MultipleBindingClassTest3 <>).Name);
builder.Bind <FactoryMethodClass>().Resolve <IFactoryMethodClass>().InSingletonScope();
builder.BindFactory <IFactoryMethodClass>(nameof(IFactoryMethodClass.Method)).Resolve <IFactoryMethodResolutionClass>();
builder.BindFactory <IFactoryMethodClass>(nameof(IFactoryMethodClass.Method)).Resolve <IFactoryMethodResolutionNamedClass>().WithKey(Named1);
builder.BindFactory <IFactoryMethodClass>(nameof(IFactoryMethodClass.Method)).Resolve <IFactoryMethodResolutionNamedClass>().WithKey(Named2);
builder.BindFactory <IFactoryMethodClass>(nameof(IFactoryMethodClass.Singleton)).Resolve <IFactoryMethodResolutionSingletonClass>().InSingletonScope();
builder.Bind(typeof(FactoryMethodClass <>)).Resolve(typeof(IFactoryMethodClass <>)).InSingletonScope();
builder.BindFactory(typeof(IFactoryMethodClass <>), "Method").Resolve(typeof(IFactoryMethodResolutionClass <>));
builder.BindFactory(typeof(IFactoryMethodClass <>), "Singleton").Resolve(typeof(IFactoryMethodResolutionSingletonClass <>)).InSingletonScope();
builder.Bind <ResolveAllTest>().ResolveAll().WithKey(nameof(ResolveAllTest));
builder.Bind <ResolveAllTest2>().ResolveAll().WithKey(nameof(ResolveAllTest2));
}
private void RegisterSceneDependencies(IDependencyBuilder b, ISceneHost scene)
{
if (scene.Template == SCENE_TEMPLATE)
{
b.Register <UserSessions>().As <IUserSessions>();
b.Register <UserPeerIndex>().As <IUserPeerIndex>().SingleInstance();
b.Register <PeerUserIndex>().As <IPeerUserIndex>().SingleInstance();
b.Register <DeviceIdentifierAuthenticationProvider>().As <IAuthenticationProvider>();
b.Register <AdminImpersonationAuthenticationProvider>().As <IAuthenticationProvider>();
b.Register <CredentialsRenewer>().AsSelf().As <IAuthenticationEventHandler>().SingleInstance();
}
else
{
b.Register <UserSessionsProxy>(dr => new UserSessionsProxy(
dr.Resolve <ISceneHost>(),
dr.Resolve <ISerializer>(),
dr.Resolve <IEnvironment>(),
dr.Resolve <IServiceLocator>(),
dr.Resolve <UserSessionCache>()))
.As <IUserSessions>().InstancePerRequest();
}
}
public void Register(IDependencyBuilder builder)
{
// Setup azure search
builder.Autofac.Register(c =>
new SearchServiceClient(_options.AzureServiceName,
new SearchCredentials(_options.AzureApiAdminKey)))
.As <ISearchServiceClient>()
.SingleInstance();
builder.Autofac.RegisterType <AzureEmployerSearchRepository>()
.As <ISearchRepository <EmployerSearchModel> >()
.SingleInstance()
.WithParameter("serviceName", _options.AzureServiceName)
.WithParameter("indexName", _options.EmployerIndexName)
.WithParameter("adminApiKey", _options.AzureApiAdminKey)
.WithParameter("disabled", _options.Disabled).WithAttributeFiltering();
builder.Autofac.RegisterType <AzureSicCodeSearchRepository>()
.As <ISearchRepository <SicCodeSearchModel> >()
.SingleInstance()
.WithParameter("indexName", _options.SicCodeIndexName)
.WithParameter("disabled", _options.Disabled).WithAttributeFiltering();
}
public void Register(IDependencyBuilder builder)
{
// Register queues (without key filtering)
builder.Autofac
.Register(c => new LogEventQueue(_storageOptions.AzureConnectionString, c.Resolve <IFileRepository>()))
.SingleInstance();
builder.Autofac
.Register(c => new LogRecordQueue(_storageOptions.AzureConnectionString, c.Resolve <IFileRepository>()))
.SingleInstance();
// Register record loggers
builder.Autofac.RegisterLogRecord(Filenames.BadSicLog);
builder.Autofac.RegisterLogRecord(Filenames.ManualChangeLog);
builder.Autofac.RegisterLogRecord(Filenames.RegistrationLog);
builder.Autofac.RegisterLogRecord(Filenames.SubmissionLog);
builder.Autofac.RegisterLogRecord(Filenames.SearchLog);
// Register log records (without key filtering)
builder.Autofac.RegisterType <UserAuditLogger>().As <IUserLogger>().SingleInstance();
builder.Autofac.RegisterType <RegistrationAuditLogger>().As <IRegistrationLogger>().SingleInstance();
builder.Autofac.RegisterType <SeriEventLogger>().As <IEventLogger>().SingleInstance();
}
public void Register(IDependencyBuilder builder)
{
builder.Services.AddHttpClient <GovNotifyEmailProvider>(nameof(GovNotifyEmailProvider));
builder.Services.AddApplicationInsightsTelemetry(_sharedOptions.AppInsights_InstrumentationKey);
builder.Services.AddSingleton <IJobActivator, AutofacJobActivator>();
//Register the file storage dependencies
builder.RegisterModule <FileStorageDependencyModule>();
//Register the log storage dependencies
builder.RegisterModule <Infrastructure.Logging.DependencyModule>();
//Register the messaging dependencies
builder.Autofac.RegisterType <Messenger>().As <IMessenger>().SingleInstance();
builder.Autofac.RegisterType <GovNotifyAPI>().As <IGovNotifyAPI>().SingleInstance();
// Register the email template dependencies
builder.Autofac
.RegisterInstance(new EmailTemplateRepository(FileSystem.ExpandLocalPath("~/App_Data/EmailTemplates")))
.As <IEmailTemplateRepository>().SingleInstance();
//Register some singletons
builder.Autofac.RegisterType <InternalObfuscator>().As <IObfuscator>().SingleInstance()
.WithParameter("seed", _sharedOptions.ObfuscationSeed);
// Register email provider dependencies
builder.Autofac.RegisterType <GovNotifyEmailProvider>().SingleInstance().WithAttributeFiltering();
builder.Autofac.RegisterType <SmtpEmailProvider>().SingleInstance().WithAttributeFiltering();
builder.Autofac.RegisterType <EmailProvider>().SingleInstance().WithAttributeFiltering();
// Need to register webJob class in Autofac as well
builder.Autofac.RegisterType <Functions>().InstancePerDependency();
builder.Autofac.RegisterType <DisableWebjobProvider>().SingleInstance();
}
/// <summary>
/// Initializes a new instance of the <see cref="CompositionControllerActivator"/> class.
/// </summary>
/// <param name="builder">The builder.</param>
public CompositionControllerActivator(IDependencyBuilder builder)
{
this.builder = builder;
}
/// <summary>
/// Initializes a new instance of the <see cref="CompositionDataAnnotationsModelValidatorProvider"/> class.
/// </summary>
/// <param name="builder">The builder.</param>
public CompositionDataAnnotationsModelValidatorProvider(IDependencyBuilder builder)
{
this.builder = builder;
this.getAttributeMethodInfo =
typeof(DataAnnotationsModelValidator).GetMethod("get_Attribute", BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance);
}
/// <summary>
/// Initializes a new instance of the <see cref="CompositionFilterAttributeFilterProvider"/> class.
/// </summary>
/// <param name="builder">The builder.</param>
public CompositionFilterAttributeFilterProvider(IDependencyBuilder builder)
{
this.builder = builder;
}
