/// <summary> /// Protects the web API with Microsoft identity platform (formerly Azure AD v2.0). /// This method expects the configuration file will have a section, named "AzureAd" as default, with the necessary settings to initialize authentication options. /// </summary> /// <param name="builder">The <see cref="AuthenticationBuilder"/> to which to add this configuration.</param> /// <param name="configurationSection">The configuration second from which to fill-in the options.</param> /// <param name="jwtBearerScheme">The JWT bearer scheme name to be used. By default it uses "Bearer".</param> /// <param name="subscribeToJwtBearerMiddlewareDiagnosticsEvents"> /// Set to true if you want to debug, or just understand the JWT bearer events. /// </param> /// <returns>The authentication builder to chain.</returns> public static MicrosoftIdentityWebApiAuthenticationBuilderWithConfiguration AddMicrosoftIdentityWebApi( this AuthenticationBuilder builder, IConfigurationSection configurationSection, string jwtBearerScheme = JwtBearerDefaults.AuthenticationScheme, bool subscribeToJwtBearerMiddlewareDiagnosticsEvents = false) { if (configurationSection == null) { throw new ArgumentNullException(nameof(configurationSection)); } if (builder == null) { throw new ArgumentNullException(nameof(builder)); } AddMicrosoftIdentityWebApiImplementation( builder, options => configurationSection.Bind(options), options => configurationSection.Bind(options), jwtBearerScheme, subscribeToJwtBearerMiddlewareDiagnosticsEvents); return(new MicrosoftIdentityWebApiAuthenticationBuilderWithConfiguration( builder.Services, jwtBearerScheme, options => configurationSection.Bind(options), options => configurationSection.Bind(options), configurationSection)); }
/// <summary> /// /// </summary> /// <param name="services"></param> /// <param name="configuration"></param> /// <returns></returns> public static IServiceCollection AddStorage(this IServiceCollection services, IConfiguration configuration) { StorageOptions options = new StorageOptions(); IConfigurationSection section = configuration.GetSection("Storage"); section.Bind(options); services.Configure <StorageOptions>(settings => section.Bind(settings)); switch (options.Adapter) { case "filesystem": services.AddScoped <IStorageService, FileSystemStorageService>(); break; case "azure": services.AddScoped <IStorageService, BlobStorageService>(); break; case "aws": services.AddScoped <IStorageService, AwsStorageService>(); break; case "minio": services.AddScoped <IStorageService, MinioStorageService>(); break; default: services.AddScoped <IStorageService, MinioStorageService>(); break; } return(services); }
public static void Configure <TConfig>(this IServiceCollection services, string name, IConfigurationSection section) where TConfig : class { var config = (TConfig)Activator.CreateInstance(typeof(TConfig)); section.Bind(config); services.Configure <TConfig>(name, options => { section.Bind(options); }); }
private IOutputPlugin CreateOutputPlugin(string pluginType, string systemName, IConfigurationSection configurationSection) { _logger.SLT00013_Debug_Create_Output_pluginType_plugin_SystemName_systemName(pluginType, systemName); _logger.SLT00019_Trace_Main_buffer_settings_config_bufferSettingsConfig(_bufferSettingsConfig); if (pluginType == "Clickhouse") { var clickHousePluginConfig = new ClickhouseOutputConfig(); configurationSection.Bind(clickHousePluginConfig); _logger.SLT00022_Trace_Plugin_output_config_clickHousePluginConfig(clickHousePluginConfig); if (clickHousePluginConfig.BufferSettings == null) { clickHousePluginConfig.BufferSettings = _bufferSettingsConfig; _logger.SLT00020_Debug_Child_settings_empty_Parent_config_is_applied(); } else { clickHousePluginConfig.BufferSettings.JoinWithParentBufferConfig(_bufferSettingsConfig); _logger.SLT00021_Debug_Child_and_parent_settings_merged(); } return(new ClickhouseOutputPlugin(clickHousePluginConfig, _metrics, _loggerFactory)); } if (pluginType == "Forward") { var forwardOutputConfig = new ForwardOutputConfig(); configurationSection.Bind(forwardOutputConfig); _logger.SLT00023_Trace_Plugin_output_config_forwardOutputConfig(forwardOutputConfig); if (forwardOutputConfig.BufferSettings == null) { forwardOutputConfig.BufferSettings = _bufferSettingsConfig; _logger.SLT00024_Debug_Child_settings_empty_Parent_config_is_applied(); } else { forwardOutputConfig.BufferSettings.JoinWithParentBufferConfig(_bufferSettingsConfig); _logger.SLT00025_Debug_Child_and_parent_settings_merged(); } return(new ForwardOutputPlugin(forwardOutputConfig, _loggerFactory)); } return(null); }
public static void AddSyslog(this ILoggerFactory loggerFactory, IConfigurationSection configuration, string hostName = "localhost", LogLevel logLevel = LogLevel.Debug) { var settings = new SyslogLoggerSettings(); configuration.Bind(settings); loggerFactory.AddProvider(new SyslogLoggerProvider(settings, hostName, logLevel)); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Add framework services. services.AddMvc(); IConfigurationSection lFileSettingsSection = this.Configuration.GetSection("FileSettings"); var lFileSettings = new FileSettings(); lFileSettingsSection.Bind(lFileSettings); services.Configure <FileSettings>(lFileSettingsSection); services.AddScoped <IAccreditationRepository, AccreditationRepository>(); services.AddScoped <IAwardLevelRepository, AwardLevelRepository>(); services.AddScoped <ICompetitionEntryRepository, CompetitionEntryRepository>(); services.AddScoped <ICountryRepository, CountryRepository>(); services.AddScoped <IPersonRepository, PersonRepository>(); services.AddScoped <IPhotoOrganisationRepository, PhotoOrganisationRepository>(); services.AddScoped <ISalonRepository, SalonRepository>(); services.AddScoped <ISalonYearRepository, SalonYearRepository>(); services.AddScoped <ISectionRepository, SectionRepository>(); services.AddScoped <ISectionTypeRepository, SectionTypeRepository>(); services.AddScoped <ISubmissionRepository, SubmissionRepository>(); services.AddScoped <ICircuitRepository, CircuitRepository>(); services.AddScoped <ISalonYearService, SalonYearService>(); services.AddScoped <ISubmissionService, SubmissionService>(); services.AddScoped <IReferenceServices, ReferenceServices>(); services.AddScoped <IPersonAwardService, PersonAwardService>(); services.AddScoped <IImageService, ImageService>(); services.AddScoped <IDbTransaction, SalonDbContext>(); services.AddScoped <ISalonDbContext, SalonDbContext>(); }
public ServiceBusConsumer(ILogger logger, IConfigurationSection config, MessageHandler handler) { if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _logger = logger; logger.LogInformation("Starting consumer"); var sboptions = new ServiceBusConsumerConfig(); config.Bind(sboptions); var connectionString = new ServiceBusConnectionStringBuilder(sboptions.EndpointAddress, sboptions.Topic, sboptions.AuthKeyName, sboptions.AuthKey); topicClient = new TopicClient(connectionString); var messageProcessorHostName = Guid.NewGuid().ToString(); var processor = new ServiceBusMessageProcessor(topicClient, logger, handler); var handlerOptpions = new MessageHandlerOptions(processor.LogException); handlerOptpions.AutoComplete = true; subscriptionClient = new SubscriptionClient(connectionString, sboptions.Subscription); subscriptionClient.RegisterMessageHandler(processor.Process, handlerOptpions); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { StartupConfig.Setup(); ISecretsManager secretsManager; IServiceInjector serviceInjector; IKeyedServiceManager keyedServiceManager; services.AddDefaultSecretsManager(_env, Configuration, ConfigConsts.CommandLine.WindowsCmd, out secretsManager) .AddKeyedServiceManager(out keyedServiceManager) .AddAppDbContext(secretsManager) .AddServiceInjector(StartupConfig.TempAssemblyList, out serviceInjector) .AddHttpContextAccessor() .AddHttpBusinessContextProvider() .AddDefaultDbMigrator() .AddRequestFeatureMiddleware() .AddAppCaching() .AddDefaultValidationResultProvider() .AddSmtpService(opt => { _smtpOptionSection.Bind(opt); opt.Password = secretsManager.Get(ConfigConsts.Mail.PasswordKey); }) .AddJsonConfigurationManager(Program.DefaultJsonFile, Program.EnvJsonFile) .AddAppAuthentication() .AddAppAuthorization() .AddWebFrameworks() .AddAppSwagger() .ScanServices(StartupConfig.TempAssemblyList, serviceInjector) .ConfigureAppOptions(Configuration); }
/// <summary> /// Use client certificate for authenticating against the BankID API from Azure Key Vault. /// </summary> /// <param name="builder"></param> /// <param name="configurationSection">Configuration section to bind the Key Vault options from.</param> /// <returns></returns> public static IBankIdBuilder UseClientCertificateFromAzureKeyVault(this IBankIdBuilder builder, IConfigurationSection configurationSection) { var options = new ClientCertificateFromAzureKeyVaultOptions(); configurationSection.Bind(options); return(UseClientCertificateFromAzureKeyVault(builder, options)); }
private static EndpointConfiguration ElementSelector(IConfigurationSection iConfigurationSection) { var endpoint = new EndpointConfiguration(); iConfigurationSection.Bind(endpoint); return(endpoint); }
public static IServiceCollection AddZeroMq(this IServiceCollection services, IConfigurationSection queueConfig) { var options = new Options(); queueConfig.Bind(options); return services.AddSingleton<IMessageQueueFactory>(sp => ActivatorUtilities.CreateInstance<ZeroMqQueueFactory>(sp, options.Queues.OfType<IMessageQueueConnection>().ToList())); }
/// <summary> /// Binds, validates and normalizes WebDAV logger options. /// </summary> /// <param name="configurationSection">Instance of <see cref="IConfigurationSection"/>.</param> /// <param name="options">WebDAV Logger configuration options.</param> public static async Task ReadOptionsAsync(this IConfigurationSection configurationSection, DavLoggerOptions options, IHostingEnvironment env) { if (configurationSection == null) { throw new ArgumentNullException("configurationSection"); } configurationSection.Bind(options); if (string.IsNullOrEmpty(options.LogFile)) { throw new ArgumentNullException("LoggerOptions.LogFile"); } if (!Path.IsPathRooted(options.LogFile)) { options.LogFile = Path.GetFullPath(Path.Combine(env.ContentRootPath, options.LogFile)); } // Create log folder and log file if does not exists. FileInfo logInfo = new FileInfo(options.LogFile); if (!logInfo.Exists) { if (!logInfo.Directory.Exists) { logInfo.Directory.Create(); } using (FileStream stream = logInfo.Create()) { } } }
/// <summary> /// Binds, validates and normalizes WebDAV Context configuration. /// </summary> /// <param name="configurationSection">Instance of <see cref="IConfigurationSection"/>.</param> /// <param name="config">WebDAV Context configuration.</param> /// <param name="env">Instance of <see cref="IWebHostEnvironment"/>.</param> public static async Task ReadConfigurationAsync(this IConfigurationSection configurationSection, DavContextConfig config, IWebHostEnvironment env) { if (configurationSection == null) { throw new ArgumentNullException("configurationSection"); } configurationSection.Bind(config); if (string.IsNullOrEmpty(config.RepositoryPath)) { throw new ArgumentNullException("DavContext.RepositoryPath"); } if (!Path.IsPathRooted(config.RepositoryPath)) { config.RepositoryPath = Path.GetFullPath(Path.Combine(env.ContentRootPath, config.RepositoryPath)); } if (!(string.IsNullOrEmpty(config.AttrStoragePath) || Path.IsPathRooted(config.AttrStoragePath))) { config.AttrStoragePath = Path.GetFullPath(Path.Combine(env.ContentRootPath, config.AttrStoragePath)); } if (!string.IsNullOrEmpty(config.AttrStoragePath)) { FileSystemInfoExtension.UseFileSystemAttribute(new FileSystemExtendedAttribute(config.AttrStoragePath, config.RepositoryPath)); } else if (!await new DirectoryInfo(config.RepositoryPath).IsExtendedAttributesSupportedAsync()) { var tempPath = Path.Combine(Path.GetTempPath(), System.Reflection.Assembly.GetExecutingAssembly().GetName().Name); FileSystemInfoExtension.UseFileSystemAttribute(new FileSystemExtendedAttribute(tempPath, config.RepositoryPath)); } }
/// <summary> /// 启动服务注册与发现 /// </summary> public static IServiceCollection AddNacosNaming(this IServiceCollection services, IConfigurationSection section) { var mainCfg = new NamingConfig(); section.Bind(mainCfg); return(AddNacosNaming(services, mainCfg)); }
public static LoggerConfiguration BigQuery(this LoggerSinkConfiguration sinkConfiguration, IConfigurationSection configuration, LogEventLevel logLevel = LogEventLevel.Warning) { var sinkOptions = new BigQuerySinkOptions(); configuration.Bind(sinkOptions); return(sinkConfiguration.BigQuery(sinkOptions, logLevel)); }
private void AddRabbitMqService(IServiceCollection services, IConfigurationSection configuration) { var options = new RawRabbitConfiguration(); configuration.Bind(options); services.AddSingleton <IBusClient>(_ => BusClientFactory.CreateDefault(options)); }
/// <summary> /// Add support to call Microsoft Graph. From a named option and a configuration section. /// </summary> /// <param name="builder">Builder.</param> /// <param name="configurationSection">Configuration section.</param> /// <returns>The builder to chain.</returns> public static MicrosoftIdentityAppCallsWebApiAuthenticationBuilder AddMicrosoftGraph( this MicrosoftIdentityAppCallsWebApiAuthenticationBuilder builder, IConfigurationSection configurationSection) { return(builder.AddMicrosoftGraph( options => configurationSection.Bind(options))); }
private void InitializeConfig(IApplicationEnvironment appEnv) { _configuration = ConfigurationFactory.CreateConfig(appEnv); IConfigurationSection appSettingsConfig = _configuration.GetSection("AppSettings"); appSettingsConfig.Bind(_appSettings); }
public static List <ApiResource> LoadApiResourcesFromSettings(this IConfiguration configuration) { IConfigurationSection section = configuration.GetSection("apiResources"); var apiResourceRecords = new List <ApiResourceRecord>(); section.Bind(apiResourceRecords); List <ApiResource> apiResources = new List <ApiResource>(); foreach (var apiResourceRecord in apiResourceRecords) { // no matter what add the api resource as a scope List <Scope> scopes = new List <Scope> { new Scope(apiResourceRecord.Name) }; if (apiResourceRecord.Scopes != null) { var prePend = string.IsNullOrWhiteSpace(apiResourceRecord.ScopeNameSpace) ? $"{apiResourceRecord.Name}." : $"{apiResourceRecord.ScopeNameSpace}."; foreach (var scopeRecord in apiResourceRecord.Scopes) { scopes.Add(new Scope($"{prePend}{scopeRecord.Name}", scopeRecord.DisplayName)); } } apiResources.Add(new ApiResource(apiResourceRecord.Name) { Scopes = scopes }); } return(apiResources); }
private static CacheManagerConfiguration GetFromConfiguration(IConfigurationSection configuration) { var managerConfiguration = new CacheManagerConfiguration(); configuration.Bind(managerConfiguration); var handlesConfiguration = configuration.GetSection(HandlesSection); if (handlesConfiguration.GetChildren().Count() == 0) { throw new InvalidOperationException( $"No cache handles defined in '{configuration.Path}'."); } foreach (var handleConfiguration in handlesConfiguration.GetChildren()) { var cacheHandleConfiguration = GetHandleFromConfiguration(handleConfiguration); managerConfiguration.CacheHandleConfigurations.Add(cacheHandleConfiguration); } GetBackplaneConfiguration(managerConfiguration, configuration); GetLoggerFactoryConfiguration(managerConfiguration, configuration); GetSerializerConfiguration(managerConfiguration, configuration); return(managerConfiguration); }
protected internal ConfigSection(IConfiguration configuration, IConfigurationSection section) { if (section != null) { // bind appsettings.json section.Bind(this); // overwrite with environment variables (loaded into configuration in Program.cs by calling config.AddEnvironmentVariables()) // Azure Application Settings / Connection strings goes to GetSection("ConnectionStrings")["..."], overwriting values coming from appsettings.json // Azure Application Settings / Application settings goes to root config (configuration["..."]) and therefore expected to be specified as sectionName.propertyName var properties = this.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic); foreach (var property in properties) { var key = $"{section.Key}.{property.Name}"; try { property.SetValue(this, configuration.GetValue(property.PropertyType, key, property.GetValue(this))); } catch { throw new InvalidCastException($"Value of environment variable '{key}' cannot be set into {property.PropertyType}."); } } } }
public static IContainer IocContainerFactory(IServiceCollection services, IConfigurationRoot configuration) { var builder = new ContainerBuilder(); IConfigurationSection sectionData = configuration.GetSection("AppSetting"); var section = new AppSetting(); sectionData.Bind(section); List <Assembly> assemblyList = new List <Assembly>(); if (section.AssemblyNames != null && section.AssemblyNames.Count > 0) { section.AssemblyNames.ForEach(x => { assemblyList.Add(AssemblyLoadContext.Default.LoadFromAssemblyPath(Path.Combine(AppContext.BaseDirectory, x))); //assemblyList.Add(Assembly.Load(new AssemblyName(x))); }); builder.RegisterAssemblyModules(assemblyList.ToArray()); } //builder.RegisterInstance<string>(configuration.GetConnectionString("DefaultConnection")).Named<string>("DefaultConnection"); builder.RegisterType <DataContext>() .WithParameter("connectionString", configuration.GetConnectionString("DefaultConnection")); builder.Populate(services); return(builder.Build()); }
public static void AddRetryPolicy(this IServiceCollection services, IConfigurationSection configurationSection) { var retryPolicyOptions = new RetryPolicyOptions(); configurationSection?.Bind(retryPolicyOptions); services.AddSingleton <IRetryPolicyOptions>(retryPolicyOptions); }
/// <summary> /// Maps a ConfigSection to a List<XmlTranslationsConfig> object /// </summary> public static List <XmlTranslationsConfig> GetXmlTranslationsConfigs(this IConfigurationSection config) { var conf = new List <XmlTranslationsConfig>(); config.Bind(conf); return(conf); }
private void SetDbContextOptionses(OSharpOptions options) { IConfigurationSection section = _configuration.GetSection("OSharp:DbContexts"); if (section == null) { string connectionString = _configuration["ConnectionStrings:DefaultDbContext"]; if (connectionString == null) { return; } OSharpDbContextOptions dbContextOptions = new OSharpDbContextOptions() { DbContextTypeName = "OSharp.Entity.DefaultDbContext,OSharp.EntityFrameworkCore", ConnectionString = connectionString, DatabaseType = DatabaseType.SqlServer }; options.DbContextOptionses.Add("DefaultDbContext", dbContextOptions); return; } IDictionary <string, OSharpDbContextOptions> dict = new Dictionary <string, OSharpDbContextOptions>(); section.Bind(dict); foreach (KeyValuePair <string, OSharpDbContextOptions> pair in dict) { options.DbContextOptionses.Add(pair.Key, pair.Value); } }
/// <summary> /// Maps a ConfigSection to a XmlTranslationsConfig object /// </summary> public static XmlTranslationsConfig GetXmlTranslationsConfig(this IConfigurationSection config) { var conf = new XmlTranslationsConfig(); config.Bind(conf); return(conf); }
public static IServiceCollection AddBigQuerySchemaHelper(this IServiceCollection services, IConfigurationSection configurationSection, string optionsName) { var helperOptions = new BigQuerySchemaHelperOptions(); configurationSection.Bind(helperOptions); return(services.AddBigQuerySchemaHelper(helperOptions, optionsName)); }
public static IServiceCollection AddAzure(this IServiceCollection services, IConfigurationSection queueConfig) { var options = new Options(); queueConfig.Bind(options); return services.AddSingleton<IMessageQueueFactory>(sp => ActivatorUtilities.CreateInstance<AzureQueueFactory>(sp, options.Queues)); }
/// <summary> /// Add authentication with Microsoft identity platform. /// This method expects the configuration file will have a section, named "AzureAd" as default, with the necessary settings to initialize authentication options. /// </summary> /// <param name="builder">The <see cref="AuthenticationBuilder"/> to which to add this configuration.</param> /// <param name="configurationSection">The configuration section from which to get the options.</param> /// <param name="openIdConnectScheme">The OpenID Connect scheme name to be used. By default it uses "OpenIdConnect".</param> /// <param name="cookieScheme">The cookie-based scheme name to be used. By default it uses "Cookies".</param> /// <param name="subscribeToOpenIdConnectMiddlewareDiagnosticsEvents"> /// Set to true if you want to debug, or just understand the OpenID Connect events. /// </param> /// <returns>The authentication builder for chaining.</returns> public static MicrosoftIdentityWebAppAuthenticationBuilderWithConfiguration AddMicrosoftIdentityWebApp( this AuthenticationBuilder builder, IConfigurationSection configurationSection, string openIdConnectScheme = OpenIdConnectDefaults.AuthenticationScheme, string?cookieScheme = CookieAuthenticationDefaults.AuthenticationScheme, bool subscribeToOpenIdConnectMiddlewareDiagnosticsEvents = false) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (configurationSection == null) { throw new ArgumentException(nameof(configurationSection)); } return(builder.AddMicrosoftIdentityWebAppWithConfiguration( options => configurationSection.Bind(options), null, openIdConnectScheme, cookieScheme, subscribeToOpenIdConnectMiddlewareDiagnosticsEvents, configurationSection)); }
private static DkpBotConfiguration GetBotConfiguration(IConfigurationSection configuration) { DkpBotConfiguration botConfig = new DkpBotConfiguration(); configuration.Bind(botConfig); return(botConfig); }
/// <summary> /// Define trusted Client client /// </summary> /// <returns></returns> public static IEnumerable <Client> GetClients(IConfigurationSection section) { List <Client> clients = new List <Client>(); if (section != null) { List <ClientConfig> configs = new List <ClientConfig>(); section.Bind("Clients", configs); foreach (var config in configs) { Client client = new Client(); client.ClientId = config.ClientId; List <Secret> clientSecrets = new List <Secret>(); foreach (var secret in config.ClientSecrets) { clientSecrets.Add(new Secret(secret.Sha256())); } client.ClientSecrets = clientSecrets.ToArray(); GrantTypes grantTypes = new GrantTypes(); var allowedGrantTypes = grantTypes.GetType().GetProperty(config.AllowedGrantTypes); client.AllowedGrantTypes = allowedGrantTypes == null ? GrantTypes.ClientCredentials : (ICollection <string>)allowedGrantTypes.GetValue(grantTypes, null); client.AllowedScopes = config.AllowedScopes.ToArray(); clients.Add(client); } } return(clients.ToArray()); }
public static IServiceCollection BindAndConfigure <TConfig>(this IServiceCollection services, IConfigurationSection section, TConfig config) where TConfig : class, new() { section.Bind(config); services.AddSingleton(config); return(services); }
private static CacheHandleConfiguration GetHandleFromConfiguration(IConfigurationSection handleConfiguration) { var type = handleConfiguration[ConfigurationType]; var knownType = handleConfiguration[ConfigurationKnownType]; var key = handleConfiguration[ConfigurationKey] ?? handleConfiguration[ConfigurationName]; // name fallback for key var name = handleConfiguration[ConfigurationName]; var cacheHandleConfiguration = new CacheHandleConfiguration(); handleConfiguration.Bind(cacheHandleConfiguration); cacheHandleConfiguration.Key = key; cacheHandleConfiguration.Name = name ?? cacheHandleConfiguration.Name; if (string.IsNullOrEmpty(type) && string.IsNullOrEmpty(knownType)) { throw new InvalidOperationException( $"No '{ConfigurationType}' or '{ConfigurationKnownType}' defined in cache handle configuration '{handleConfiguration.Path}'."); } if (string.IsNullOrWhiteSpace(type)) { var keyRequired = false; cacheHandleConfiguration.HandleType = GetKnownHandleType(knownType, handleConfiguration.Path, out keyRequired); // some handles require name or key to be set to link to other parts of the configuration // lets check if that condition is satisfied if (keyRequired && string.IsNullOrWhiteSpace(key) && string.IsNullOrWhiteSpace(name)) { throw new InvalidOperationException( $@"Known handle of type '{knownType}' requires '{ConfigurationKey}' or '{ConfigurationName}' to be defined. Check configuration at '{handleConfiguration.Path}'."); } } else { cacheHandleConfiguration.HandleType = Type.GetType(type, true); } return cacheHandleConfiguration; }
private static CacheManagerConfiguration GetFromConfiguration(IConfigurationSection configuration) { var managerConfiguration = new CacheManagerConfiguration(); configuration.Bind(managerConfiguration); var handlesConfiguration = configuration.GetSection(HandlesSection); if (handlesConfiguration.GetChildren().Count() == 0) { throw new InvalidOperationException( $"No cache handles defined in '{configuration.Path}'."); } foreach (var handleConfiguration in handlesConfiguration.GetChildren()) { var cacheHandleConfiguration = GetHandleFromConfiguration(handleConfiguration); managerConfiguration.CacheHandleConfigurations.Add(cacheHandleConfiguration); } GetBackplaneConfiguration(managerConfiguration, configuration); GetLoggerFactoryConfiguration(managerConfiguration, configuration); GetSerializerConfiguration(managerConfiguration, configuration); return managerConfiguration; }