public void RegisterPackage(IDependencyCollection dependencyCollection)
{
// NOTE: No need to load the IoC package. This is a responsibility of the IoC Provider.
dependencyCollection.RegisterSingleton <IEnvironmentConfigurationProvider, EnvironmentConfigurationProvider>();
dependencyCollection.RegisterSingleton <INullConfigurationProvider, NullConfigurationProvider>();
// NOTE: This is not valid, because MemoryConfigurationProvider's constructor expects a Dictionary<string, string>.
// dependencyCollection.RegisterSingleton<IMemoryConfigurationProvider, MemoryConfigurationProvider>();
// NOTE: But this is valid:
//dependencyCollection.RegisterSingleton<IMemoryConfigurationProvider>(provider => new MemoryConfigurationProvider(new Dictionary<string, string>
//{
// {"key", "value"}
//}));
if (_configuration != null)
{
dependencyCollection.RegisterSingleton <IMemoryConfigurationProvider>(new MemoryConfigurationProvider(_configuration));
dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IMemoryConfigurationProvider>(provider => provider.ResolveDependency <IMemoryConfigurationProvider>());
}
dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IEnvironmentConfigurationProvider>((provider) => {
return(provider.ResolveDependency <IEnvironmentConfigurationProvider>());
});
dependencyCollection.RegisterSingleton <IConfigurationService, ConfigurationService>();
dependencyCollection.RegisterSingleton(typeof(IConfigManager <>), typeof(DefaultConfigManager <>));
dependencyCollection.RegisterSingleton(typeof(IConfig <>), typeof(ConfigLoader <>));
}
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
dependencyCollection.RegisterSingleton <IFunnyQuoteProvider, FunnyQuoteProvider>();
dependencyCollection.RegisterSingleton <IScaryQuoteProvider, ScaryQuoteProvider>();
//dependencyCollection.RegisterSingleton<ISeriousQuoteProvider, SeriousQuoteProvider>();
dependencyCollection.AddSingletonToCollection <IQuoteProvider, IFunnyQuoteProvider>(provider =>
provider.ResolveDependency <IFunnyQuoteProvider>());
dependencyCollection.AddSingletonToCollection <IQuoteProvider, IScaryQuoteProvider>(provider =>
provider.ResolveDependency <IScaryQuoteProvider>());
//dependencyCollection.AddSingletonToCollection<IQuoteProvider, ISeriousQuoteProvider>(provider =>
// provider.ResolveDependency<ISeriousQuoteProvider>());
}
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
dependencyCollection.LoadPackage(new XPike.Configuration.Package());
dependencyCollection.RegisterSingleton <IAzureConfigurationProvider>(new AzureConfigurationProvider(_connectionString));
dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IAzureConfigurationProvider>(provider => provider.ResolveDependency <IAzureConfigurationProvider>());
}
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
dependencyCollection.AddSingletonToCollection <ITenantContextProvider, DefaultTenantContextProvider>();
dependencyCollection.RegisterSingleton <ITenantContextAccessor, TenantContextAccessor>();
dependencyCollection.RegisterScoped <ITenantContext>(services =>
services.ResolveDependency <ITenantContextAccessor>().TenantContext);
}
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
dependencyCollection.LoadPackage(new Configuration.Package());
dependencyCollection.RegisterSingleton <IAWSConfigurationProvider, AWSConfigurationProvider>();
dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IAWSConfigurationProvider>(services =>
services.ResolveDependency <IAWSConfigurationProvider>());
}
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
dependencyCollection.LoadPackage(new XPike.Metrics.Package());
dependencyCollection.RegisterSingleton <IApplicationInsightsMetricsProvider, ApplicationInsightsMetricsProvider>();
dependencyCollection.AddSingletonToCollection <IMetricsProvider, IApplicationInsightsMetricsProvider>(container =>
container.ResolveDependency <IApplicationInsightsMetricsProvider>());
}
public static IDependencyCollection AddSeriousQuotes(this IDependencyCollection collection)
{
collection.RegisterSingleton <ISeriousQuoteProvider, SeriousQuoteProvider>();
collection.AddSingletonToCollection <IQuoteProvider, ISeriousQuoteProvider>(provider =>
provider.ResolveDependency <ISeriousQuoteProvider>());
return(collection);
}
/// <summary>
/// Registers the XPike.DefaultRequestContext dependencies in the DI container.
/// </summary>
/// <param name="dependencyCollection">The IDependencyCollection to add registrations to.</param>
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
/* Add necessary registrations from XPike.DefaultRequestContext */
dependencyCollection.LoadPackage(new XPike.RequestContext.Package());
/* Add IHttpRequestContextProvider to the collection */
// NOTE: It is expected that an implementing library will also register as a singleton an implementation of IHttpRequestContextProvider.
dependencyCollection.AddSingletonToCollection <IRequestContextProvider, IHttpRequestContextProvider>(container =>
container.ResolveDependency <IHttpRequestContextProvider>());
}
public void RegisterPackage(IDependencyCollection container)
{
container.LoadPackage(new XPike.Configuration.Package());
container.RegisterSingleton <ISystemConfigurationProvider, SystemConfigurationProvider>();
container.AddSingletonToCollection <IConfigurationProvider, ISystemConfigurationProvider>((provider) =>
{
return(provider.ResolveDependency <ISystemConfigurationProvider>());
});
}
public static IDependencyCollection AddXPikeRequestContextTenantHeader(this IDependencyCollection collection, string headerName)
{
collection.LoadPackage(new XPike.MultiTenant.RequestContext.Package());
RequestContextHeaderTenantContextProvider.HeaderName = headerName;
collection.AddSingletonToCollection <ITenantContextProvider, IRequestContextHeaderTenantContextProvider>(container =>
container.ResolveDependency <IRequestContextHeaderTenantContextProvider>());
return(collection);
}
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
if (dependencyCollection == null)
{
throw new ArgumentNullException(nameof(dependencyCollection));
}
dependencyCollection.RegisterTransient <HttpMessageHandlerBuilder, XpikeHttpMessageHandlerBuilder>();
dependencyCollection.RegisterSingleton <IHttpClientFactory, XpikeHttpClientFactory>();
dependencyCollection.AddSingletonToCollection <IHttpMessageHandlerBuilderFilter, NullHttpMessageHandlerBuilderFilter>();
}
public void RegisterPackage(IDependencyCollection dependencies)
{
// Load other Packages we depend on...
dependencies.LoadPackage(new XPike.Configuration.Package());
// Register our implementations...
dependencies.RegisterSingleton <IConfigurationSettingsProvider, ConfigurationSettingsProvider>();
dependencies.RegisterSingleton <ISettingsService, SettingsService>();
dependencies.RegisterSingleton(typeof(ISettingsManager <>), typeof(DefaultSettingsManager <>));
dependencies.RegisterSingleton(typeof(ISettings <>), typeof(SettingsLoader <>));
// Delegate mappings...
// By default, use IConfigurationSettingsProvider, which loads Settings from the IConfigurationService.
dependencies.AddSingletonToCollection <ISettingsProvider, IConfigurationSettingsProvider>(provider => provider.ResolveDependency <IConfigurationSettingsProvider>());
}
/// <summary>
/// Registers the XPike.DefaultRequestContext dependencies in the DI container.
/// </summary>
/// <param name="dependencyCollection">The IDependencyCollection to add registrations to.</param>
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
/* Load the XPike.Logging package which we depend on. */
dependencyCollection.LoadPackage(new XPike.Logging.Package());
/* Register Singletons */
dependencyCollection.RegisterSingleton <IDefaultRequestContextProvider, DefaultRequestContextProvider>();
dependencyCollection.RegisterSingleton <IRequestContextAccessor, RequestContextAccessor>();
/* Add Default Request Context Provider */
dependencyCollection.AddSingletonToCollection <IRequestContextProvider, IDefaultRequestContextProvider>(container =>
container.ResolveDependency <IDefaultRequestContextProvider>());
/* Add accessor for scoped injection of IRequestContext */
dependencyCollection.RegisterScoped <IRequestContext>(services =>
services.ResolveDependency <IRequestContextAccessor>().RequestContext);
}
public void RegisterPackage(IDependencyCollection container)
{
// Load other Packages we depend on.
container.LoadPackage(new XPike.Configuration.Package(_staticConfig));
// Register the XPike Configuration Provider for Microsoft.Extensions.Configuration
if (_configuration == null)
{
container.RegisterSingleton <IMicrosoftConfigurationProvider, MicrosoftConfigurationProvider>();
}
else
{
container.RegisterSingleton <IMicrosoftConfigurationProvider>(new MicrosoftConfigurationProvider(_configuration));
}
// Set the provider to be the only one in the list of Providers used by the Configuration Service
container.ResetCollection <IConfigurationProvider>();
container.AddSingletonToCollection <IConfigurationProvider, IMicrosoftConfigurationProvider>(provider =>
provider.ResolveDependency <IMicrosoftConfigurationProvider>());
}
