Indiko.Blocks.Configuration.AppSettings 2.1.2

Indiko.Blocks.Configuration.AppSettings

Configuration block for loading application settings from JSON files (appsettings.json) in the Indiko framework.

Overview

This package provides a configuration block that loads settings from appsettings.json files, supporting environment-specific configurations and the standard ASP.NET Core configuration hierarchy.

Features

• AppSettings Support: Load configuration from appsettings.json
• Environment-Specific: Automatic loading of appsettings.{Environment}.json
• Type-Safe Configuration: Bind to strongly-typed settings classes
• Hot Reload: Watch for configuration file changes
• Early Loading: Loads before other blocks (BlockLoadOrder -1)
• IConfiguration Integration: Seamlessly integrates with ASP.NET Core configuration

Installation

dotnet add package Indiko.Blocks.Configuration.AppSettings

Quick Start

Enable in Your Application

The AppSettings configuration block is typically auto-discovered and loaded. Simply ensure your appsettings.json file exists:

// appsettings.json
{
  "Logging": {
    "LogLevel": {
      "Default": "Information"
    }
  },
  "MySettings": {
    "ApiKey": "your-api-key",
    "Endpoint": "https://api.example.com"
  }
}

Create Environment-Specific Settings

// appsettings.Development.json
{
  "MySettings": {
    "Endpoint": "https://dev-api.example.com"
  }
}

// appsettings.Production.json
{
  "MySettings": {
    "ApiKey": "prod-api-key",
    "Endpoint": "https://api.example.com"
  }
}

Usage Examples

Accessing Configuration

using Microsoft.Extensions.Configuration;

public class MyService
{
    private readonly IConfiguration _configuration;

    public MyService(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public void DoSomething()
    {
        var apiKey = _configuration["MySettings:ApiKey"];
        var endpoint = _configuration["MySettings:Endpoint"];
    }
}

Type-Safe Configuration with Options Pattern

// Define settings class
public class MySettings
{
    public string ApiKey { get; set; }
    public string Endpoint { get; set; }
    public int Timeout { get; set; } = 30;
}

// Register in ConfigureServices
services.Configure<MySettings>(configuration.GetSection("MySettings"));

// Inject and use
public class MyService
{
    private readonly MySettings _settings;

    public MyService(IOptions<MySettings> options)
    {
        _settings = options.Value;
    }

    public async Task<string> CallApiAsync()
    {
        var client = new HttpClient
        {
            BaseAddress = new Uri(_settings.Endpoint),
            Timeout = TimeSpan.FromSeconds(_settings.Timeout)
        };
        
        client.DefaultRequestHeaders.Add("X-API-Key", _settings.ApiKey);
        
        return await client.GetStringAsync("/data");
    }
}

Explicit Service Registration

using Indiko.Blocks.Configuration.AppSettings.Extensions;

public override void ConfigureServices(IServiceCollection services)
{
    // Explicitly use appsettings configuration
    services.UseAppsettingsConfiguration();
    
    // Bind configuration sections
    services.Configure<DatabaseSettings>(Configuration.GetSection("Database"));
    services.Configure<CacheSettings>(Configuration.GetSection("Cache"));
}

Configuration Hierarchy

The standard ASP.NET Core configuration hierarchy applies:

1. appsettings.json
2. appsettings.{Environment}.json
3. User Secrets (Development only)
4. Environment Variables
5. Command Line Arguments

Later sources override earlier ones.

Key Components

AppSettingsConfigurationBlock

The main configuration block implementation.

[BlockLoadOrder(-1)]
public sealed class AppSettingsConfigurationBlock : BlockBase, IAppSettingsConfigurationBlock
{
    public override void ConfigureServices(IServiceCollection services)
    {
        services.UseAppsettingsConfiguration();
        base.ConfigureServices(services);
    }
}

AppsettingsConfigurationBuilder

Builder for creating the AppSettings configuration block.

public class AppsettingsConfigurationBuilder : IBlockConfigurationBuilder
{
    public IConfigurationBlock Build()
    {
        return new AppSettingsConfigurationBlock(configuration, logger);
    }
}

Advanced Features

Nested Configuration Sections

{
  "Database": {
    "ConnectionStrings": {
      "Default": "Server=localhost;Database=mydb",
      "ReadOnly": "Server=replica;Database=mydb"
    },
    "CommandTimeout": 30,
    "MaxRetryCount": 3
  }
}

public class DatabaseSettings
{
    public Dictionary<string, string> ConnectionStrings { get; set; }
    public int CommandTimeout { get; set; }
    public int MaxRetryCount { get; set; }
}

services.Configure<DatabaseSettings>(Configuration.GetSection("Database"));

Array Configuration

{
  "AllowedHosts": ["example.com", "*.example.com"],
  "Endpoints": [
    {
      "Name": "Primary",
      "Url": "https://api1.example.com"
    },
    {
      "Name": "Secondary",
      "Url": "https://api2.example.com"
    }
  ]
}

var allowedHosts = Configuration.GetSection("AllowedHosts").Get<string[]>();

public class EndpointSettings
{
    public string Name { get; set; }
    public string Url { get; set; }
}

var endpoints = Configuration.GetSection("Endpoints").Get<List<EndpointSettings>>();

Configuration Validation

using System.ComponentModel.DataAnnotations;

public class ApiSettings
{
    [Required]
    [Url]
    public string Endpoint { get; set; }
    
    [Required]
    [MinLength(10)]
    public string ApiKey { get; set; }
    
    [Range(1, 300)]
    public int Timeout { get; set; } = 30;
}

// Enable validation
services.AddOptions<ApiSettings>()
    .Bind(Configuration.GetSection("Api"))
    .ValidateDataAnnotations()
    .ValidateOnStart(); // Validate at startup

File Watching and Hot Reload

Configuration files are automatically watched for changes:

// Changes to appsettings.json are automatically picked up
// when using IOptionsSnapshot or IOptionsMonitor

public class MyService
{
    private readonly IOptionsMonitor<MySettings> _settings;

    public MyService(IOptionsMonitor<MySettings> settings)
    {
        _settings = settings;
        
        // Subscribe to changes
        _settings.OnChange(newSettings =>
        {
            Console.WriteLine($"Configuration changed: {newSettings.Endpoint}");
        });
    }

    public void DoWork()
    {
        // Always gets current value
        var current = _settings.CurrentValue;
    }
}

Target Framework

• .NET 10

Dependencies

• Indiko.Blocks.Configuration.Abstractions
• Indiko.Blocks.Common.Abstractions
• Microsoft.Extensions.Configuration
• Microsoft.Extensions.Configuration.Json

License

See LICENSE file in the repository root.

Related Packages

• Indiko.Blocks.Configuration.Abstractions - Configuration abstractions
• Indiko.Blocks.Configuration.Consul - Consul-based configuration
• Indiko.Blocks.Common.Management - Block management system