Configuration

Introduction to Configuration

Configuration is a critical aspect of .NET applications, allowing developers to define and manage application settings in a centralized manner. .NET provides a flexible and powerful configuration system that supports various configuration sources such as JSON files, environment variables, command-line arguments, and more.

Setting Up Configuration

To set up configuration in a .NET application, follow these steps:

Step 1: Add Configuration Files

Add a appsettings.json file to the root of your project. This file will hold your configuration settings in JSON format.


{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    }
  },
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=aspnet-MyApp-53B1F0;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "AppSettings": {
    "ApplicationName": "MyApp",
    "Version": "1.0.0"
  }
}

Step 2: Configure the Configuration Builder

Configure the configuration builder in the Program.cs file:


using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;

public class Program {
    public static void Main(string[] args) {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureAppConfiguration((hostingContext, config) => {
                config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
                config.AddEnvironmentVariables();
                if (args != null) {
                    config.AddCommandLine(args);
                }
            })
            .ConfigureWebHostDefaults(webBuilder => {
                webBuilder.UseStartup<Startup>();
            });
}

Step 3: Access Configuration Settings

Access the configuration settings in your application using dependency injection. For example, in a controller:


using Microsoft.Extensions.Configuration;

public class HomeController : Controller {
    private readonly IConfiguration _configuration;

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

    public IActionResult Index() {
        var appName = _configuration["AppSettings:ApplicationName"];
        var appVersion = _configuration["AppSettings:Version"];
        ViewData["Message"] = $"Welcome to {appName} v{appVersion}!";
        return View();
    }
}

Using Strongly Typed Configuration

For better type safety and intellisense support, you can use strongly typed configuration. First, define a POCO class that matches the structure of your configuration section:


public class AppSettings {
    public string ApplicationName { get; set; }
    public string Version { get; set; }
}

Next, bind the configuration section to this class in the Startup.cs file:


public void ConfigureServices(IServiceCollection services) {
    services.Configure<AppSettings>(_configuration.GetSection("AppSettings"));
    // Other service configurations
}

Finally, inject the configured options into your services or controllers:


using Microsoft.Extensions.Options;

public class HomeController : Controller {
    private readonly AppSettings _appSettings;

    public HomeController(IOptions<AppSettings> appSettings) {
        _appSettings = appSettings.Value;
    }

    public IActionResult Index() {
        ViewData["Message"] = $"Welcome to {_appSettings.ApplicationName} v{_appSettings.Version}!";
        return View();
    }
}

Using Multiple Configuration Providers

.NET allows you to use multiple configuration providers simultaneously. For example, you can combine JSON files, environment variables, and command-line arguments:


public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration((hostingContext, config) => {
            config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
            config.AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", optional: true, 
			reloadOnChange: true);
            config.AddEnvironmentVariables();
            if (args != null) {
                config.AddCommandLine(args);
            }
        })
        .ConfigureWebHostDefaults(webBuilder => {
            webBuilder.UseStartup<Startup>();
        });

Handling Configuration Changes

Configuration settings can be reloaded at runtime if the underlying configuration source changes. This is useful for settings that may change without requiring an application restart. To enable this, set the reloadOnChange parameter to true when adding the configuration source:


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

You can then register a callback to handle the configuration change event:


_configuration.GetReloadToken().RegisterChangeCallback(callback => {
    // Handle configuration change
}, null);

Conclusion

Effective configuration management is essential for building flexible and maintainable .NET applications. By leveraging the powerful configuration system in .NET, you can manage your application's settings efficiently, support multiple configuration sources, and handle changes at runtime.