ASP.NET Configuration

last modified April 3, 2025

In this article, we explore Configuration in ASP.NET 8. Configuration is essential for managing application settings across different environments.

ASP.NET provides a flexible configuration system that works with various sources like JSON files, environment variables, and command-line arguments.

Basic Definition

Configuration in ASP.NET refers to the system that manages application settings. These settings can be stored in different sources and accessed uniformly.

The configuration system is built around the IConfiguration interface. It provides methods to read configuration values from various providers.

Configuration values can be organized hierarchically using sections. The system supports binding configuration values to strongly-typed objects.

Common configuration sources include appsettings.json, environment variables, user secrets, and command-line arguments. Multiple sources can be combined.

The configuration system is set up automatically when creating a new ASP.NET application using WebApplication.CreateBuilder().

ASP.NET Configuration Example

The following example demonstrates how to use configuration in an ASP.NET 8 app.

{
  "AppSettings": {
    "Title": "Product Catalog",
    "MaxItems": 50,
    "Enabled": true,
    "ApiSettings": {
      "BaseUrl": "https://api.example.com",
      "Timeout": 30
    }
  },
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=Products;Trusted_Connection=True;"
  }
}

This JSON configuration file defines application settings in hierarchical structure. It includes both simple values and nested objects.

var builder = WebApplication.CreateBuilder(args);

// Add services to the container
builder.Services.AddControllers();

// Bind configuration to strongly-typed objects
builder.Services.Configure<AppSettings>(builder.Configuration.GetSection("AppSettings"));

var app = builder.Build();

app.MapControllers();

// Access configuration directly
var config = app.Services.GetRequiredService<IConfiguration>();
var title = config["AppSettings:Title"];
Console.WriteLine($"Application Title: {title}");

app.Run();

public class AppSettings
{
    public string Title { get; set; }
    public int MaxItems { get; set; }
    public bool Enabled { get; set; }
    public ApiSettings ApiSettings { get; set; }
}

public class ApiSettings
{
    public string BaseUrl { get; set; }
    public int Timeout { get; set; }
}

This code sets up configuration binding and demonstrates different ways to access configuration values. The Configure method binds settings to classes.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;

[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IConfiguration _config;
    private readonly AppSettings _appSettings;
    private readonly string _connectionString;

    public ProductsController(IConfiguration config, 
        IOptions<AppSettings> appSettings)
    {
        _config = config;
        _appSettings = appSettings.Value;
        _connectionString = _config.GetConnectionString("DefaultConnection");
    }

    [HttpGet("settings")]
    public IActionResult GetSettings()
    {
        var settings = new
        {
            Title = _appSettings.Title,
            MaxItems = _appSettings.MaxItems,
            ApiUrl = _appSettings.ApiSettings.BaseUrl,
            ConnectionString = _connectionString
        };
        
        return Ok(settings);
    }

    [HttpGet("config-example")]
    public IActionResult GetConfigExample()
    {
        var timeout = _config["AppSettings:ApiSettings:Timeout"];
        var enabled = _config.GetValue<bool>("AppSettings:Enabled");
        
        return Ok(new { Timeout = timeout, Enabled = enabled });
    }
}

The controller demonstrates three ways to access configuration: through IConfiguration, strongly-typed options, and connection strings. Each approach has different use cases.

The strongly-typed options pattern (IOptions<T>) is preferred for complex scenarios. Direct IConfiguration access is useful for simple values or dynamic access.

Source

Microsoft ASP.NET Configuration Documentation

In this article, we have explored the Configuration system in ASP.NET 8. This powerful feature provides flexible ways to manage application settings.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all ASP.NET tutorials.