Всё о конфигурации ASP.NET Core

var builder = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
    .AddEnvironmentVariables()
    .AddCommandLine(args);
    
Configuration = builder.Build();

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder();
    
    // Базовый уровень - значения по умолчанию
    builder.AddJsonFile("appsettings.json");
    
    // Специфичные для окружения настройки
    if (env.IsDevelopment())
    {
        builder.AddUserSecrets<Startup>();
    }
    
    // Настройки инфраструктуры
    builder.AddEnvironmentVariables();
    
    // Временные переопределения
    if (args != null)
    {
        builder.AddCommandLine(args);
    }
    
    Configuration = builder.Build();
}

// Получение строкового значения по ключу
string value = Configuration["SomeKey"];
 
// Получение вложеного значения
string nestedValue = Configuration["SomeSection:SomeKey"];
 
// Получение целой секции
IConfigurationSection section = Configuration.GetSection("SomeSection");

services.AddSingleton<IConfiguration>(Configuration);

public class SomeService
{
    private readonly IConfiguration _configuration;
    
    public SomeService(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    
    public void DoSomething()
    {
        var apiKey = _configuration["ApiKey"];
        // Используем apiKey...
    }
}

.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)

public class ApiClient
{
  private readonly string _apiKey;
  
  public ApiClient(IConfiguration config)
  {
      _apiKey = config["Services:ExternalApi:ApiKey"];
  }
}

// Получение всей секции целиком
var loggingSection = Configuration.GetSection("Logging");
 
// Навигация по иерархии
var microsoftLogLevel = loggingSection.GetSection("LogLevel").GetValue<string>("Microsoft");
 
// Привязка секции к объекту
var loggingOptions = new LoggingOptions();
loggingSection.Bind(loggingOptions);

var memoryConfig = new Dictionary<string, string>
{
    {"Profile:FirstName", "Иван"},
    {"Profile:LastName", "Петров"},
    {"Profile:Designation", "Разработчик"}
};
 
var builder = new ConfigurationBuilder();
builder.AddInMemoryCollection(memoryConfig);
var configuration = builder.Build();
 
// Теперь можно работать с конфигурацией как обычно
var firstName = configuration["Profile:FirstName"]; // "Иван"

var builder = WebApplication.CreateBuilder(args);
 
// Конфигурация уже настроена с базовыми провайдерами
// Можно добавить дополнительные источники
builder.Configuration.AddJsonFile("customSettings.json", optional: true);
 
// Доступ к конфигурации
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
 
var app = builder.Build();

public class SmtpSettings
{
    public string Server { get; set; }
    public int Port { get; set; }
    public string UserName { get; set; }
    public string Password { get; set; }
    public bool EnableSsl { get; set; }
}

services.Configure<SmtpSettings>(Configuration.GetSection("SmtpSettings"));

public class EmailService
{
    private readonly SmtpSettings _smtpSettings;
 
    public EmailService(IOptions<SmtpSettings> smtpSettingsOptions)
    {
        _smtpSettings = smtpSettingsOptions.Value;
    }
 
    public void SendEmail(string to, string subject, string body)
    {
        // Используем _smtpSettings.Server, _smtpSettings.Port и т.д.
    }
}

services.AddOptions<SmtpSettings>()
    .Bind(Configuration.GetSection("SmtpSettings"))
    .Validate(settings => 
    {
        return !string.IsNullOrEmpty(settings.Server) 
            && settings.Port > 0 
            && settings.Port < 65536;
    }, "SMTP server and port must be specified correctly.");

public class SmtpSettings
{
    [Required]
    public string Server { get; set; }
    
    [Range(1, 65535)]
    public int Port { get; set; }
    
    [EmailAddress]
    public string UserName { get; set; }
    
    [MinLength(8)]
    public string Password { get; set; }
    
    public bool EnableSsl { get; set; } = true;
}
 
// Регистрация с валидацией через DataAnnotations
services.AddOptions<SmtpSettings>()
    .Bind(Configuration.GetSection("SmtpSettings"))
    .ValidateDataAnnotations();

public class LoggingController : Controller
{
    private readonly IOptionsSnapshot<LoggingSettings> _loggingSettings;
    
    public LoggingController(IOptionsSnapshot<LoggingSettings> loggingSettings)
    {
        _loggingSettings = loggingSettings;
    }
    
    public IActionResult Index()
    {
        // Всегда получаем актуальные настройки
        var currentLogLevel = _loggingSettings.Value.DefaultLogLevel;
        return View(new LoggingViewModel { CurrentLogLevel = currentLogLevel });
    }
}

public class ConfigAwareService
{
    private LoggingSettings _currentSettings;
    private readonly IDisposable _changeListener;
    
    public ConfigAwareService(IOptionsMonitor<LoggingSettings> settingsMonitor)
    {
        _currentSettings = settingsMonitor.CurrentValue;
        
        // Подписка на изменения
        _changeListener = settingsMonitor.OnChange(newSettings => 
        {
            Console.WriteLine($"Настройки изменились! Новый уровень логирования: {newSettings.DefaultLogLevel}");
            _currentSettings = newSettings;
            ApplyNewSettings(newSettings);
        });
    }
    
    private void ApplyNewSettings(LoggingSettings settings)
    {
        // Применяем новые настройки
    }
    
    public void Dispose()
    {
        _changeListener?.Dispose();
    }
}

public class CustomHeaderMiddleware
{
    private readonly RequestDelegate _next;
    private readonly CustomHeaderSettings _settings;
 
    public CustomHeaderMiddleware(RequestDelegate next, IOptions<CustomHeaderSettings> settings)
    {
        _next = next;
        _settings = settings.Value;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Добавляем заголовок из конфигурации
        context.Response.Headers.Add(_settings.HeaderName, _settings.HeaderValue);
        
        // Передаем управление следующему компоненту
        await _next(context);
    }
}
 
// Регистрация в pipeline
app.UseMiddleware<CustomHeaderMiddleware>();

public class ApiKeyAuthFilter : IAuthorizationFilter
{
    private readonly string _validApiKey;
 
    public ApiKeyAuthFilter(IOptions<SecuritySettings> securitySettings)
    {
        _validApiKey = securitySettings.Value.ApiKey;
    }
 
    public void OnAuthorization(AuthorizationFilterContext context)
    {
        if (!context.HttpContext.Request.Headers.TryGetValue("X-API-KEY", out var apiKeyValues))
        {
            context.Result = new UnauthorizedResult();
            return;
        }
 
        var providedApiKey = apiKeyValues.FirstOrDefault();
        if (providedApiKey != _validApiKey)
        {
            context.Result = new UnauthorizedResult();
        }
    }
}
 
// Регистрация фильтра глобально
services.AddMvc(options =>
{
    options.Filters.Add<ApiKeyAuthFilter>();
});

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureLogging((hostContext, logging) =>
        {
            logging.ClearProviders();
            logging.AddConfiguration(hostContext.Configuration.GetSection("Logging"));
            logging.AddConsole();
            logging.AddDebug();
            logging.AddEventSourceLogger();
            
            // Условное добавление провайдеров
            if (hostContext.HostingEnvironment.IsProduction())
            {
                logging.AddEventLog();
            }
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

IChangeToken token = Configuration.GetReloadToken();
token.RegisterChangeCallback(state => 
{
    Console.WriteLine("Конфигурация изменилась!");
    // Перечитать конфигурацию или выполнить нужные действия
}, null);

void RegisterChangeCallback()
{
    ChangeToken.OnChange(
        () => Configuration.GetReloadToken(),
        () => 
        {
            Console.WriteLine($"Конфигурация обновилась в {DateTime.Now}");
            // Применить изменения
            
            // Не нужно явно регистрироваться снова - OnChange делает это автоматически
        });
}

public class FeatureFlagsController : Controller
{
    private readonly IOptionsSnapshot<FeatureFlags> _featureFlags;
    
    public FeatureFlagsController(IOptionsSnapshot<FeatureFlags> featureFlags)
    {
        _featureFlags = featureFlags;
    }
    
    public IActionResult Index()
    {
        // Текущее состояние фичефлагов на момент запроса
        return View(_featureFlags.Value);
    }
}

// Регистрация
services.Configure<ConnectionString>(
    "ReadOnly", 
    Configuration.GetSection("ConnectionStrings:ReadOnlyDb"));
    
services.Configure<ConnectionString>(
    "ReadWrite", 
    Configuration.GetSection("ConnectionStrings:ReadWriteDb"));
 
// Использование в контроллере
public class DbController : Controller
{
    private readonly ConnectionString _readOnlyConnection;
    private readonly ConnectionString _readWriteConnection;
    
    public DbController(IOptionsSnapshot<ConnectionString> connectionFactory)
    {
        _readOnlyConnection = connectionFactory.Get("ReadOnly");
        _readWriteConnection = connectionFactory.Get("ReadWrite");
    }
}

services.AddOptions<ApiClientSettings>()
    .Bind(Configuration.GetSection("ApiClient"))
    .PostConfigure(settings => 
    {
        // Расшифровываем зашифрованный API-ключ
        if (!string.IsNullOrEmpty(settings.EncryptedApiKey)) 
        {
            settings.ApiKey = _decryptionService.Decrypt(settings.EncryptedApiKey);
            settings.EncryptedApiKey = null; // Очищаем зашифрованное значение из памяти
        }
    });

public void ConfigureServices(IServiceCollection services)
{
    // Базовая конфигурация для всех окружений
    services.Configure<EmailSenderOptions>(Configuration.GetSection("Email"));
    
    // Переопределения для разработки
    if (_environment.IsDevelopment())
    {
        services.PostConfigure<EmailSenderOptions>(options => 
        {
            // В разработке все письма отправляем на тестовый адрес
            options.OverrideRecipient = "dev-test@example.com";
            options.DisableActualSending = true;
        });
    }
    
    // Настройки для продакшена
    if (_environment.IsProduction())
    {
        services.PostConfigure<EmailSenderOptions>(options =>
        {
            // В продакшене обязательно шифруем
            options.EnableEncryption = true;
        });
    }
}

// Модели настроек
public class NotificationSettings
{
    public EmailSettings Email { get; set; }
    public SmsSettings Sms { get; set; }
    public PushSettings Push { get; set; }
    public bool EnableEmails { get; set; } = true;
    public bool EnableSms { get; set; } = false;
    public bool EnablePush { get; set; } = false;
}
 
public class EmailSettings
{
    [Required]
    public string SmtpServer { get; set; }
    
    [Range(1, 65535)]
    public int Port { get; set; } = 25;
    
    public string Username { get; set; }
    public string Password { get; set; }
    public bool UseSsl { get; set; } = true;
}
 
// Регистрация в DI
services.Configure<NotificationSettings>(
    Configuration.GetSection("Notifications"));
 
// Сервис уведомлений
public class NotificationService
{
    private readonly IOptionsMonitor<NotificationSettings> _settings;
    private readonly ILogger<NotificationService> _logger;
    
    public NotificationService(
        IOptionsMonitor<NotificationSettings> settings,
        ILogger<NotificationService> logger)
    {
        _settings = settings;
        _logger = logger;
        
        // Подписываемся на изменения настроек
        _settings.OnChange(newSettings => {
            _logger.LogInformation("Настройки уведомлений обновлены");
            // Можно перенастроить клиенты, сбросить кеши и т.д.
        });
    }
    
    public async Task SendNotificationAsync(string userId, string message)
    {
        // Получаем текущие настройки
        var settings = _settings.CurrentValue;
        
        if (settings.EnableEmails)
        {
            await SendEmailAsync(userId, message);
        }
        
        if (settings.EnableSms)
        {
            await SendSmsAsync(userId, message);
        }
        
        if (settings.EnablePush)
        {
            await SendPushAsync(userId, message);
        }
    }
    
    private Task SendEmailAsync(string userId, string message)
    {
        var emailSettings = _settings.CurrentValue.Email;
        // Логика отправки email
        return Task.CompletedTask;
    }
    
    // Аналогичные методы для SMS и Push
}

public interface ISettingsProvider
{
    T GetSettings<T>() where T : class, new();
    string GetConnectionString(string name);
    string GetValue(string key);
}
 
public class SettingsProvider : ISettingsProvider
{
    private readonly IConfiguration _configuration;
 
    public SettingsProvider(IConfiguration configuration)
    {
        _configuration = configuration;
    }
 
    public T GetSettings<T>() where T : class, new()
    {
        var result = new T();
        var sectionName = typeof(T).Name.Replace("Settings", "");
        _configuration.GetSection(sectionName).Bind(result);
        return result;
    }
 
    public string GetConnectionString(string name)
    {
        return _configuration.GetConnectionString(name);
    }
 
    public string GetValue(string key)
    {
        return _configuration[key];
    }
}

public class FeatureFlags
{
    public bool EnableNewCheckout { get; set; }
    public bool UseNewSearchAlgorithm { get; set; }
    public Dictionary<string, bool> BetaFeatures { get; set; } = new();
}
 
// В JSON
{
  "Features": {
    "EnableNewCheckout": false,
    "UseNewSearchAlgorithm": true,
    "BetaFeatures": {
      "RedesignedProfile": true,
      "AIRecommendations": false
    }
  }
}
 
// В контроллере
public class CheckoutController : Controller
{
    private readonly IOptionsSnapshot<FeatureFlags> _featureFlags;
    
    public CheckoutController(IOptionsSnapshot<FeatureFlags> featureFlags)
    {
        _featureFlags = featureFlags;
    }
    
    public IActionResult Index()
    {
        if (_featureFlags.Value.EnableNewCheckout)
        {
            return View("NewCheckout");
        }
        
        return View("Checkout");
    }
}

public class CorsSettings
{
    public string[] AllowedOrigins { get; set; }
}
 
public class RateLimitSettings
{
    public List<RateLimitRule> Rules { get; set; }
}
 
public class RateLimitRule
{
    public string Endpoint { get; set; }
    public int Limit { get; set; }
    public string Period { get; set; }
}

public void ConfigureServices(IServiceCollection services)
{
    var locSettings = new LocalizationSettings();
    Configuration.GetSection("Localization").Bind(locSettings);
    
    services.AddLocalization(options => options.ResourcesPath = locSettings.ResourcesPath);
    
    services.Configure<RequestLocalizationOptions>(options =>
    {
        var cultures = locSettings.SupportedCultures
            .Select(c => new CultureInfo(c))
            .ToList();
        
        options.DefaultRequestCulture = new RequestCulture(locSettings.DefaultCulture);
        options.SupportedCultures = cultures;
        options.SupportedUICultures = cultures;
        options.FallBackToParentCultures = locSettings.FallbackToParentCultures;
    });
}

public void ConfigureServices(IServiceCollection services)
{
    // Добавляем провайдер для зашифрованных секций
    services.AddDataProtection();
    
    var connectionStrings = Configuration
        .GetSection("ConnectionStrings")
        .Get<Dictionary<string, string>>();
    
    // Расшифровываем защищенные строки
    foreach (var key in connectionStrings.Keys.ToList())
    {
        if (connectionStrings[key].StartsWith("enc:"))
        {
            var protector = _dataProtectionProvider
                .CreateProtector("ConnectionStrings");
            var encryptedValue = connectionStrings[key].Substring(4);
            connectionStrings[key] = protector.Unprotect(encryptedValue);
        }
    }
    
    // Регистрируем расшифрованные значения
    services.AddSingleton(connectionStrings);
}

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration((context, config) =>
        {
            var builtConfig = config.Build();
            var keyVaultEndpoint = builtConfig["AzureKeyVault:Endpoint"];
            
            if (!string.IsNullOrEmpty(keyVaultEndpoint))
            {
                var azureServiceTokenProvider = new AzureServiceTokenProvider();
                var keyVaultClient = new KeyVaultClient(
                    new KeyVaultClient.AuthenticationCallback(
                        azureServiceTokenProvider.KeyVaultTokenCallback));
                        
                config.AddAzureKeyVault(
                    keyVaultEndpoint,
                    keyVaultClient,
                    new DefaultKeyVaultSecretManager());
            }
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

public class RedisConfigurationProvider : ConfigurationProvider, IDisposable
{
    private readonly string _redisConnectionString;
    private readonly string _keyPrefix;
    private ConnectionMultiplexer _redis;
    private ISubscriber _subscriber;
    
    public RedisConfigurationProvider(RedisConfigurationSource source)
    {
        _redisConnectionString = source.ConnectionString;
        _keyPrefix = source.KeyPrefix;
    }
    
    public override void Load()
    {
        _redis = ConnectionMultiplexer.Connect(_redisConnectionString);
        var db = _redis.GetDatabase();
        
        // Загрузка всех ключей с префиксом
        var server = _redis.GetServer(_redis.GetEndPoints().First());
        var keys = server.Keys(pattern: $"{_keyPrefix}*");
        
        var data = new Dictionary<string, string>();
        foreach (var key in keys)
        {
            var configKey = key.ToString().Substring(_keyPrefix.Length);
            var value = db.StringGet(key);
            data[configKey] = value;
        }
        
        Data = data;
        
        // Подписка на изменения
        _subscriber = _redis.GetSubscriber();
        _subscriber.Subscribe($"{_keyPrefix}-changes", (channel, message) => 
        {
            // При получении уведомления перезагружаем конфигурацию
            Load();
            OnReload();
        });
    }
    
    public void Dispose()
    {
        _redis?.Dispose();
    }
}
 
public class RedisConfigurationSource : IConfigurationSource
{
    public string ConnectionString { get; set; }
    public string KeyPrefix { get; set; } = "app:config:";
    
    public IConfigurationProvider Build(IConfigurationBuilder builder)
    {
        return new RedisConfigurationProvider(this);
    }
}
 
// Расширение для удобства использования
public static class RedisConfigurationExtensions
{
    public static IConfigurationBuilder AddRedis(
        this IConfigurationBuilder builder,
        string connectionString,
        string keyPrefix = "app:config:")
    {
        return builder.Add(new RedisConfigurationSource 
        { 
            ConnectionString = connectionString,
            KeyPrefix = keyPrefix
        });
    }
}

var configuration = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .AddRedis(redisConnectionString)
    .Build();

public class ConsulConfigurationProvider : ConfigurationProvider, IDisposable
{
    private readonly ConsulClient _client;
    private readonly string _keyPrefix;
    private readonly int _pollingInterval;
    private Timer _pollingTimer;
    
    public ConsulConfigurationProvider(string consulAddress, string keyPrefix, int pollingIntervalMs)
    {
        _client = new ConsulClient(config => 
        { 
            config.Address = new Uri(consulAddress); 
        });
        _keyPrefix = keyPrefix;
        _pollingInterval = pollingIntervalMs;
    }
    
    public override void Load()
    {
        var result = _client.KV.List(_keyPrefix).Result;
        if (result.StatusCode == HttpStatusCode.OK)
        {
            var data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            
            foreach (var pair in result.Response)
            {
                var key = pair.Key.Substring(_keyPrefix.Length);
                var value = Encoding.UTF8.GetString(pair.Value);
                data[key] = value;
            }
            
            Data = data;
        }
        
        // Запускаем периодическое обновление
        if (_pollingTimer == null)
        {
            _pollingTimer = new Timer(_ => 
            {
                Load();
                OnReload();
            }, null, _pollingInterval, _pollingInterval);
        }
    }
    
    public void Dispose()
    {
        _pollingTimer?.Dispose();
        _client?.Dispose();
    }
}
 
// Использование при инициализации
config.AddConsulConfiguration(
    "http://localhost:8500",
    "myapp/settings/",
    pollingIntervalMs: 30000);

public void ConfigureServices(IServiceCollection services)
{
  // Настраиваем защиту данных
  services.AddDataProtection()
      .PersistKeysToFileSystem(new DirectoryInfo(@"C:\keys"))
      .SetDefaultKeyLifetime(TimeSpan.FromDays(14));
  
  // Получаем протектор с определенным назначением
  var provider = services.BuildServiceProvider();
  var dataProtectionProvider = provider.GetRequiredService<IDataProtectionProvider>();
  var protector = dataProtectionProvider.CreateProtector("Configuration.ConnectionStrings");
  
  // Зашифровываем строку подключения
  var rawConnectionString = Configuration.GetConnectionString("DefaultConnection");
  var encryptedConnectionString = protector.Protect(rawConnectionString);
  
  // Регистрируем зашифрованную версию
  var inMemoryConfig = new Dictionary<string, string>
  {
      {"ConnectionStrings:DefaultConnection", encryptedConnectionString}
  };
  
  var memoryConfigSource = new MemoryConfigurationSource { InitialData = inMemoryConfig };
  Configuration.Add(memoryConfigSource);
  
  // А вот и сервис, который умеет расшифровывать
  services.AddTransient<IConnectionStringProvider, ProtectedConnectionStringProvider>();
}
 
public class ProtectedConnectionStringProvider : IConnectionStringProvider
{
  private readonly IDataProtector _protector;
  private readonly IConfiguration _configuration;
  
  public ProtectedConnectionStringProvider(
      IDataProtectionProvider dataProtectionProvider,
      IConfiguration configuration)
  {
      _protector = dataProtectionProvider.CreateProtector("Configuration.ConnectionStrings");
      _configuration = configuration;
  }
  
  public string GetConnectionString(string name)
  {
      var encryptedConnectionString = _configuration.GetConnectionString(name);
      if (encryptedConnectionString.StartsWith("ENC:"))
      {
          // Удаляем префикс и расшифровываем
          return _protector.Unprotect(encryptedConnectionString.Substring(4));
      }
      
      return encryptedConnectionString;
  }
}

public class DbConfigurationProvider : ConfigurationProvider, IDisposable
{
  private readonly string _connectionString;
  private readonly TimeSpan _refreshInterval;
  private Timer _timer;
  
  public DbConfigurationProvider(string connectionString, TimeSpan refreshInterval)
  {
      _connectionString = connectionString;
      _refreshInterval = refreshInterval;
  }
  
  public override void Load()
  {
      using (var connection = new SqlConnection(_connectionString))
      {
          connection.Open();
          using (var command = new SqlCommand("SELECT [Key], [Value] FROM [AppSettings]", connection))
          using (var reader = command.ExecuteReader())
          {
              var data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
              
              while (reader.Read())
              {
                  data[reader.GetString(0)] = reader.GetString(1);
              }
              
              Data = data;
          }
      }
      
      if (_timer == null)
      {
          _timer = new Timer(_ => 
          {
              Load();
              OnReload();
          }, null, _refreshInterval, _refreshInterval);
      }
  }
  
  public void Dispose()
  {
      _timer?.Dispose();
  }
}
 
// Расширение для конфигурации
public static IConfigurationBuilder AddDbConfiguration(
    this IConfigurationBuilder builder,
    string connectionString,
    TimeSpan refreshInterval)
{
    return builder.Add(new DbConfigurationSource(connectionString, refreshInterval));
}
 
// Регистрация провайдера
var configuration = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .AddDbConfiguration(
        connectionString,
        TimeSpan.FromMinutes(5))
    .Build();

public interface IConfigurationUpdateNotifier
{
  Task NotifyUpdatedAsync(string key, string value);
}
 
public class RabbitMqConfigNotifier : IConfigurationUpdateNotifier
{
  private readonly IConnection _connection;
  private readonly IModel _channel;
  private const string ExchangeName = "config.updates";
  
  public RabbitMqConfigNotifier(string connectionString)
  {
      var factory = new ConnectionFactory { Uri = new Uri(connectionString) };
      _connection = factory.CreateConnection();
      _channel = _connection.CreateModel();
      
      _channel.ExchangeDeclare(ExchangeName, ExchangeType.Topic);
  }
  
  public Task NotifyUpdatedAsync(string key, string value)
  {
      var message = JsonSerializer.Serialize(new { Key = key, Value = value });
      var body = Encoding.UTF8.GetBytes(message);
      
      _channel.BasicPublish(
          exchange: ExchangeName,
          routingKey: key,
          body: body);
          
      return Task.CompletedTask;
  }
}

public class ConfigurationUpdater : IHostedService
{
  private readonly IConfigurationRoot _configuration;
  private readonly IConnection _connection;
  private readonly IModel _channel;
  private readonly List<string> _subscribedKeys;
  
  public ConfigurationUpdater(
      IConfiguration configuration,
      IConfiguration rabbitConfig,
      string[] keysToMonitor)
  {
      _configuration = configuration as IConfigurationRoot;
      _subscribedKeys = new List<string>(keysToMonitor);
      
      var factory = new ConnectionFactory { Uri = new Uri(rabbitConfig["RabbitMQ:ConnectionString"]) };
      _connection = factory.CreateConnection();
      _channel = _connection.CreateModel();
      
      _channel.ExchangeDeclare("config.updates", ExchangeType.Topic);
  }
  
  public Task StartAsync(CancellationToken cancellationToken)
  {
      var queueName = _channel.QueueDeclare().QueueName;
      
      foreach (var key in _subscribedKeys)
      {
          _channel.QueueBind(queueName, "config.updates", key);
      }
      
      var consumer = new EventingBasicConsumer(_channel);
      consumer.Received += (model, ea) =>
      {
          var body = ea.Body.ToArray();
          var message = JsonSerializer.Deserialize<ConfigUpdateMessage>(body);
          
          // Обновляем конфигурацию
          var memoryConfig = new Dictionary<string, string>
          {
              { message.Key, message.Value }
          };
          
          // Здесь мы программно обновляем IConfigurationRoot
          _configuration.GetReloadToken().RegisterChangeCallback(_ =>
          {
              // Что-то делаем после обновления
          }, null);
      };
      
      _channel.BasicConsume(queueName, true, consumer);
      
      return Task.CompletedTask;
  }
  
  public Task StopAsync(CancellationToken cancellationToken)
  {
      _channel?.Close();
      _connection?.Close();
      return Task.CompletedTask;
  }
}

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration((context, config) =>
        {
            var settings = config.Build();
            config.AddAzureAppConfiguration(options =>
            {
                options.Connect(settings["ConnectionStrings:AppConfig"])
                       .Select(KeyFilter.Any)
                       .ConfigureRefresh(refresh =>
                       {
                           refresh.Register("Sentinel", refreshAll: true)
                                  .SetCacheExpiration(TimeSpan.FromMinutes(5));
                       })
                       .UseFeatureFlags();
            });
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

public void ConfigureServices(IServiceCollection services)
{
    services.AddAzureAppConfiguration();
    
    // Остальные сервисы
}
 
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Middleware для динамического обновления конфигурации
    app.UseAzureAppConfiguration();
    
    // Остальные компоненты pipeline
}

// Так делать не стоит в высоконагруженных компонентах
public class HighLoadController : Controller 
{
    private readonly IOptionsSnapshot<SomeFrequentlyUsedSettings> _settings;
    
    public HighLoadController(IOptionsSnapshot<SomeFrequentlyUsedSettings> settings) 
    {
        _settings = settings; // Создается на каждый запрос!
    }
}

public class OptimizedController : Controller 
{
    private readonly IOptionsMonitor<FrequentSettings> _settingsMonitor;
    
    public OptimizedController(IOptionsMonitor<FrequentSettings> settings) 
    {
        _settingsMonitor = settings;
    }
    
    public IActionResult Index() 
    {
        // Получаем значение один раз на запрос
        var currentSettings = _settingsMonitor.CurrentValue;
        // Используем currentSettings...
    }
}

var builder = WebApplication.CreateBuilder(args);
 
if (builder.Environment.IsDevelopment())
{
    builder.Configuration.AddUserSecrets<Program>();
}
else if (builder.Environment.IsProduction())
{
    // В продакшене добавляем Azure Key Vault
    var builtConfig = builder.Configuration.Build();
    var kvEndpoint = builtConfig["KeyVault:Endpoint"];
    
    builder.Configuration.AddAzureKeyVault(
        new Uri(kvEndpoint),
        new DefaultAzureCredential());
}

public static class ConfigurationExtensions
{
    public static T GetEnvironmentSpecific<T>(
        this IConfiguration config,
        string key,
        string environment)
    {
        // Сначала ищем специфичную для окружения настройку
        var envSpecificKey = $"{environment}:{key}";
        if (config.GetSection(envSpecificKey).Exists())
        {
            return config.GetValue<T>(envSpecificKey);
        }
        
        // Иначе возвращаем общую
        return config.GetValue<T>(key);
    }
}

public class EntityFrameworkConfigSync<TContext> where TContext : DbContext
{
    private readonly TContext _dbContext;
    private readonly IConfigurationRoot _configuration;
    
    public EntityFrameworkConfigSync(TContext context, IConfigurationRoot config)
    {
        _dbContext = context;
        _configuration = config;
    }
    
    public async Task SyncFromDbToConfigAsync(string settingsTable)
    {
        // Получаем настройки из БД
        var sql = $"SELECT [Key], [Value] FROM {settingsTable}";
        var settings = await _dbContext.Database
            .SqlQueryRaw<KeyValuePair<string, string>>(sql)
            .ToListAsync();
        
        // Обновляем конфигурацию
        var memoryConfig = new Dictionary<string, string>();
        foreach (var setting in settings)
        {
            memoryConfig[setting.Key] = setting.Value;
        }
        
        _configuration.Add(new MemoryConfigurationSource { InitialData = memoryConfig });
    }
}

public class ConfigurationFactory
{
    private readonly IConfiguration _configuration;
    private readonly Dictionary<Type, string> _sectionMappings = new();
    
    public ConfigurationFactory(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    
    public void RegisterSection<T>(string sectionName) where T : class, new()
    {
        _sectionMappings[typeof(T)] = sectionName;
    }
    
    public void AddAllOptionsToServices(IServiceCollection services)
    {
        foreach (var mapping in _sectionMappings)
        {
            var type = mapping.Key;
            var sectionName = mapping.Value;
            
            // Используем рефлексию для вызова Configure<T>
            var configureMethod = typeof(OptionsConfigurationServiceCollectionExtensions)
                .GetMethod(nameof(OptionsConfigurationServiceCollectionExtensions.Configure),
                    new[] { typeof(IServiceCollection), typeof(IConfiguration) })
                ?.MakeGenericMethod(type);
            
            configureMethod?.Invoke(null, new object[] 
            { 
                services, 
                _configuration.GetSection(sectionName) 
            });
        }
    }
}

var factory = new ConfigurationFactory(Configuration);
factory.RegisterSection<SmtpSettings>("Email:Smtp");
factory.RegisterSection<SmsSettings>("Messaging:Sms");
factory.RegisterSection<AuthSettings>("Security:Auth");
// и так далее для всех настроек
 
// Одна строка вместо десятков вызовов Configure<T>
factory.AddAllOptionsToServices(services);

public class ConfigurationChangeMonitor<T> where T : class, new()
{
    private readonly ILogger _logger;
    private readonly IMetrics _metrics;
    private readonly string _configName;
    
    public ConfigurationChangeMonitor(
        ILogger<ConfigurationChangeMonitor<T>> logger,
        IMetrics metrics)
    {
        _logger = logger;
        _metrics = metrics;
        _configName = typeof(T).Name;
    }
    
    public void Initialize(IOptionsMonitor<T> monitor)
    {
        monitor.OnChange((newOptions, name) => 
        {
            _logger.LogInformation("Configuration {ConfigName} changed", _configName);
            
            _metrics.Measure.Counter.Increment("configuration_changes_total", 
                new MetricTags("config_name", _configName));
                
            // Можно добавить глубокое сравнение старых и новых настроек
            // и логировать конкретные изменения
        });
    }
}

// 1. Модель настроек (Domain Layer)
public class AuthenticationSettings
{
    public int TokenExpirationMinutes { get; set; }
    public bool RequireTwoFactor { get; set; }
}
 
// 2. Интерфейс провайдера (Application Layer)
public interface ISettingsProvider<T> where T : class, new()
{
    T GetSettings();
    Task UpdateSettingsAsync(T settings);
}
 
// 3. Конкретная реализация (Infrastructure Layer)
public class ConfigurationSettingsProvider<T> : ISettingsProvider<T> 
    where T : class, new()
{
    private readonly IOptionsMonitor<T> _options;
    private readonly IConfigurationRoot _configRoot;
    private readonly string _sectionName;
 
    public ConfigurationSettingsProvider(
        IOptionsMonitor<T> options,
        IConfiguration configuration,
        string sectionName = null)
    {
        _options = options;
        _configRoot = configuration as IConfigurationRoot;
        _sectionName = sectionName ?? typeof(T).Name;
    }
 
    public T GetSettings() => _options.CurrentValue;
 
    public Task UpdateSettingsAsync(T settings)
    {
        // Логика обновления настроек
        return Task.CompletedTask;
    }
}
 
// 4. Композиция (Composition Root)
services.AddScoped<ISettingsProvider<AuthenticationSettings>, 
    ConfigurationSettingsProvider<AuthenticationSettings>>();

public class VersionedSettings<T> where T : class, new()
{
    public int Version { get; set; }
    public T Settings { get; set; }
}
 
public class ConfigurationMigrator
{
    private readonly IConfigurationRoot _configRoot;
    private readonly Dictionary<int, Func<JObject, JObject>> _migrations;
 
    public ConfigurationMigrator(IConfiguration configuration)
    {
        _configRoot = configuration as IConfigurationRoot;
        _migrations = new Dictionary<int, Func<JObject, JObject>>();
    }
 
    public void RegisterMigration(int fromVersion, Func<JObject, JObject> migrationFunc)
    {
        _migrations[fromVersion] = migrationFunc;
    }
 
    public async Task MigrateAsync<T>(string sectionName, int targetVersion) 
        where T : class, new()
    {
        var section = _configRoot.GetSection(sectionName);
        var versionedConfig = section.Get<VersionedSettings<T>>();
        
        if (versionedConfig == null || versionedConfig.Version >= targetVersion)
            return;
 
        var settingsJson = JObject.FromObject(versionedConfig.Settings);
        
        for (int v = versionedConfig.Version; v < targetVersion; v++)
        {
            if (_migrations.TryGetValue(v, out var migration))
            {
                settingsJson = migration(settingsJson);
            }
        }
 
        // Обновляем конфигурацию с новой версией
        versionedConfig.Version = targetVersion;
        versionedConfig.Settings = settingsJson.ToObject<T>();
        
        // Сохраняем изменения
        // Логика сохранения зависит от провайдера
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }
 
    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureAppConfiguration((hostContext, config) =>
            {
                // Базовая конфигурация
                config.AddJsonFile("appsettings.json", optional: false)
                      .AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", optional: true)
                      .AddEnvironmentVariables();
 
                // Секреты разработки (только в Development)
                if (hostContext.HostingEnvironment.IsDevelopment())
                {
                    config.AddUserSecrets<Program>();
                }
 
                // Динамическая конфигурация из Redis (только в Production)
                if (hostContext.HostingEnvironment.IsProduction())
                {
                    var builtConfig = config.Build();
                    config.AddRedisConfiguration(
                        builtConfig["Redis:ConnectionString"],
                        "app:config:");
                }
 
                // Command-line аргументы имеют наивысший приоритет
                config.AddCommandLine(args);
            })
            .ConfigureServices((hostContext, services) =>
            {
                // Регистрация Options с валидацией
                services.AddOptions<DatabaseSettings>()
                        .Bind(hostContext.Configuration.GetSection("Database"))
                        .ValidateDataAnnotations()
                        .Validate(settings => 
                        {
                            return !string.IsNullOrEmpty(settings.ConnectionString) 
                                && settings.MaxPoolSize > 0;
                        }, "Неверные настройки базы данных");
 
                // Настройки с мониторингом изменений
                services.Configure<NotificationSettings>(
                    hostContext.Configuration.GetSection("Notifications"));
                    
                // Службы, использующие конфигурацию
                services.AddScoped<INotificationService, EmailNotificationService>();
                services.AddScoped<ITaskRepository, TaskRepository>();
                
                // Сервис шифрования для защиты данных
                services.AddDataProtection()
                        .PersistKeysToFileSystem(new DirectoryInfo("keys"));
                        
                // Регистрация фабрики опций для постобработки
                services.AddTransient<IConfigureOptions<ApiSettings>, ApiSettingsSetup>();
            });
}

public class DatabaseSettings
{
    [Required]
    public string ConnectionString { get; set; }
    
    [Range(1, 1000)]
    public int MaxPoolSize { get; set; } = 10;
    
    [Range(1, 300)]
    public int CommandTimeout { get; set; } = 30;
}
 
public class NotificationSettings
{
    public EmailSettings Email { get; set; }
    public bool EnableEmailNotifications { get; set; } = true;
    public int TaskDueSoonThresholdHours { get; set; } = 24;
    public string OverrideRecipientEmail { get; set; }
}
 
public class EmailSettings
{
    public string SmtpServer { get; set; }
    public int Port { get; set; }
    public string SenderEmail { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
}

public class EmailNotificationService : INotificationService, IDisposable
{
    private readonly IOptionsMonitor<NotificationSettings> _settings;
    private readonly ILogger<EmailNotificationService> _logger;
    private IDisposable _settingsChangeToken;
    private SmtpClient _smtpClient;
 
    public EmailNotificationService(
        IOptionsMonitor<NotificationSettings> settings,
        ILogger<EmailNotificationService> logger)
    {
        _settings = settings;
        _logger = logger;
        
        // Инициализируем SMTP-клиент
        InitializeSmtpClient();
        
        // Подписываемся на изменения настроек
        _settingsChangeToken = _settings.OnChange(_ => {
            _logger.LogInformation("Настройки уведомлений изменились, переинициализация SMTP-клиента");
            InitializeSmtpClient();
        });
    }
    
    private void InitializeSmtpClient()
    {
        var settings = _settings.CurrentValue;
        
        _smtpClient?.Dispose();
        _smtpClient = new SmtpClient(settings.Email.SmtpServer, settings.Email.Port);
        
        // Настройка аутентификации, если указаны учетные данные
        if (!string.IsNullOrEmpty(settings.Email.Username))
        {
            _smtpClient.Credentials = new NetworkCredential(
                settings.Email.Username, 
                settings.Email.Password);
        }
    }
    
    public void Dispose()
    {
        _settingsChangeToken?.Dispose();
        _smtpClient?.Dispose();
    }
}