Reading appsettings.json in Class Libraries: A Guide for ASP.NET Core Developers

ASP.NET Core allows developers to easily manage application settings through the use of a JSON file, appsettings.json. This file is typically located in the root of the application and contains key-value pairs of configuration settings. However, sometimes you may want to read these settings from a class library rather than the main application. In this article, we will explore how to read appsettings.json from a class library in an ASP.NET Core application.

Accessing appsettings.json using Microsoft.Extensions.Configuration

First, let's create a new class library in our ASP.NET Core solution. This library will be used to store our configuration classes, which will be responsible for reading the settings from appsettings.json. We can add a new class called AppSettings to this library. This class will have properties for each of the settings that we want to read from appsettings.json.

public class AppSettings
{
    public string Setting1 { get; set; }
    public int Setting2 { get; set; }
    // additional properties
}

Next, we need to add the Microsoft.Extensions.Configuration package to our class library. This package provides the classes and extension methods needed to read configuration data from various sources, including appsettings.json.

We can then create an instance of the IConfiguration interface in our class library. This interface allows us to read data from configuration sources, such as appsettings.json.

var builder = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json");

var configuration = builder.Build();

We can then use the Bind method on the IConfiguration instance to map the settings in appsettings.json to the properties of our AppSettings class.

configuration.GetSection("AppSettings").Bind(appSettings);

Finally, we can use the properties of the AppSettings class in our class library to access the configuration settings in appsettings.json.

var setting1 = appSettings.Setting1;
var setting2 = appSettings.Setting2;

Accessing appsettings.json Using Dependency Injection

It's also possible to use dependency injection to inject an IConfiguration instance into our class library. This allows us to centralize the configuration management in the main application and eliminates the need to manually build the configuration in our class library. Here are the steps of how to use dependency injection to access the appsettings.json configuration settings in an ASP.NET Core application:

In your Startup.cs file, add the following line in the ConfigureServices method to add the IConfiguration service to the dependency injection container:

services.AddSingleton<IConfiguration>(Configuration);

In your class library, create a new class, for example AppSettings, that has properties for each of the settings that you want to read from the appsettings.json file.

public class AppSettings
{
    public string Setting1 { get; set; }
    public int Setting2 { get; set; }
    // additional properties
}

In the class library, add a constructor that accepts an IConfiguration instance as a parameter and uses it to bind the settings to the properties of the AppSettings class.

public class MyClass
{
    private readonly AppSettings _appSettings;

    public MyClass(IConfiguration configuration)
    {
        _appSettings = new AppSettings();
        configuration.GetSection("AppSettings").Bind(_appSettings);
    }
}

In your Startup.cs file, add the following line in the ConfigureServices method to register your AppSettings class for dependency injection

services.AddSingleton<AppSettings>();

Now you can inject the AppSettings class into any class that needs access to the configuration settings.

public class MyController : Controller
{
    private readonly AppSettings _appSettings;

    public MyController(AppSettings appSettings)
    {
        _appSettings = appSettings;
    }

    public IActionResult Index()
    {
        var setting1 = _appSettings.Setting1;
        var setting2 = _appSettings.Setting2;
        // use settings
    }
}

In this example, we are using the AddSingleton method to register the IConfiguration and AppSettings classes for dependency injection. This ensures that a single instance of the classes will be created and used throughout the lifetime of the application. There are other lifetime options such as AddTransient and AddScoped which can be used depending on the requirement.

Final Words

In summary, reading appsettings.json from a class library in an ASP.NET Core application is a simple process. The first option is by using the Microsoft.Extensions.Configuration package and the IConfiguration interface, we can easily read and use configuration settings in our class library. The second option is by using dependency injection. Both approaches allow for a clean separation of concerns, making it easy to manage and update application settings.