Creating and Utilizing Shared Configurations in ASP.NET Core

In the world of software development, maintaining consistency across different environments (development, staging, production) or across various projects within the same solution is crucial. ASP.NET Core offers a robust configuration system that’s both flexible and powerful, allowing settings to be sourced from JSON files, environment variables, command-line arguments, and more. A common practice to achieve consistency is the use of shared configurations. This article will guide you through setting up and using shared configurations in ASP.NET Core.

Step 1: Creating a Shared Configuration File

A shared configuration typically resides in a JSON file. This file contains all the settings that need to be consistent across different parts of an application or multiple applications. For example, create a file named appsettings.Shared.json with the following content:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    }
  },
  "ApplicationSettings": {
    "ApplicationName": "My Application",
    "Version": "1.0.0"
  }
}

Step 2: Loading the Shared Configuration File

The shared configuration file must be loaded so that its settings can be utilized by your application. This is done in the CreateHostBuilder method within the Program.cs file. It’s crucial to load the shared configuration alongside environment-specific settings, ensuring that environment-specific settings can override the shared ones if needed:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration((hostingContext, config) =>
        {
            var env = hostingContext.HostingEnvironment;
            
            // Load the shared configuration first.
            config.AddJsonFile("appsettings.Shared.json", optional: true, reloadOnChange: true);
            
            // Load the environment-specific settings next.
            config.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

Step 3: Accessing Configuration Values

To utilize the configuration values in your application, you can either directly inject IConfiguration into your classes or use the options pattern for more structured settings.

Directly Injecting IConfiguration:

Here’s how you can inject IConfiguration to access the ApplicationName setting:

public class MyController : ControllerBase
{
    private readonly IConfiguration _configuration;

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

    public IActionResult GetAppName()
    {
        var appName = _configuration.GetValue<string>("ApplicationSettings:ApplicationName");
        return Ok(appName);
    }
}

Using the Options Pattern:

For complex configurations, the options pattern is recommended. First, define a class that represents your settings:

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

Register it in the ConfigureServices method of your Startup class:

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<ApplicationSettings>(Configuration.GetSection("ApplicationSettings"));
    // Add other services
}

Inject IOptions<ApplicationSettings> to access the settings in your classes:

public class MyOtherController : ControllerBase
{
    private readonly ApplicationSettings _appSettings;

    public MyOtherController(IOptions<ApplicationSettings> appSettings)
    {
        _appSettings = appSettings.Value;
    }

    public IActionResult GetAppVersion()
    {
        return Ok(_appSettings.Version);
    }
}

Conclusion

Using shared configurations in ASP.NET Core not only helps in maintaining consistency across different environments and projects but also makes configuration management cleaner and more maintainable. By leveraging the flexibility of ASP.NET Core’s configuration system, developers can streamline their development processes, reduce errors, and ensure that their applications behave consistently regardless of the environment or project they’re deployed in.