3 September 2017
In this post, we will explore how to manage configuration in .NET Core applications using the appsettings.json file. Configuration management is an essential part of any modern application, and .NET Core provides a flexible and powerful way to handle configuration settings using this file. We will also look at how to access these configuration values within your controllers and services.
1. What Is appsettings.json?
The appsettings.json file is where you store your application’s configuration settings. This file can hold key-value pairs that define things like connection strings, API keys, and other configurable parameters that your application needs. The advantage of using a configuration file like appsettings.json is that it keeps your application flexible and environment-specific without hardcoding values into your source code.
Here is an example of what appsettings.json might look like:
{
"AppSettings": {
"SiteName": "My Awesome Application",
"ApiUrl": "https://api.example.com"
},
"ConnectionStrings": {
"DefaultConnection": "Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;"
}
}
In this example, we have two sections: AppSettings and ConnectionStrings. The AppSettings section stores general application settings like the site name and API URL, while the ConnectionStrings section holds a database connection string.
2. Setting Up Configuration in .NET Core
By default, .NET Core applications are already set up to read configuration values from the appsettings.json file, but let’s walk through the process of configuring it manually and accessing these values.
Step 1: Include appsettings.json in Your Project
First, make sure the appsettings.json file is included in your project. By default, this file should be in the root of your project. If it’s missing, simply create a new JSON file named appsettings.json in the root folder and add your configuration data to it.
Also, ensure that the file has the following properties set in the .csproj file:
<ItemGroup>
<None Update="appsettings.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
This ensures that the appsettings.json file is copied to the output directory when you build your project.
Step 2: Configure Services to Use appsettings.json
In your Startup.cs file, the configuration is already set up in most .NET Core projects by default. But if you want to explicitly configure it, you can add the following code in the ConfigureServices method:
public void ConfigureServices(IServiceCollection services)
{
// Add configuration from appsettings.json
IConfiguration configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory()) // Set the base path to the current directory
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) // Load appsettings.json
.Build();
services.AddSingleton<IConfiguration>(configuration); // Make the IConfiguration available throughout the app
}
This configuration builder loads the appsettings.json file and makes it available as an IConfiguration object for the entire application.
Step 3: Access Configuration Values in Your Code
Now that the appsettings.json file is loaded into the configuration system, you can inject and access the configuration values in your controllers, services, or any other class.
Accessing Configuration in Controllers
For example, in your controller, you can inject the IConfiguration interface to access the values in appsettings.json:
public class HomeController : Controller
{
private readonly IConfiguration _configuration;
public HomeController(IConfiguration configuration)
{
_configuration = configuration;
}
public IActionResult Index()
{
// Access configuration values
string siteName = _configuration["AppSettings:SiteName"];
string apiUrl = _configuration["AppSettings:ApiUrl"];
// Use configuration values
ViewBag.SiteName = siteName;
ViewBag.ApiUrl = apiUrl;
return View();
}
}
In this example, the values for SiteName and ApiUrl are retrieved from the appsettings.json file and passed to the view using ViewBag.
Accessing Configuration in Services
You can also inject the IConfiguration into services to access configuration settings:
public class MyService
{
private readonly IConfiguration _configuration;
public MyService(IConfiguration configuration)
{
_configuration = configuration;
}
public void LogSiteInfo()
{
string siteName = _configuration["AppSettings:SiteName"];
Console.WriteLine($"Site Name: {siteName}");
}
}
3. Using Strongly Typed Configuration
While accessing configuration values directly through the IConfiguration interface is straightforward, it can become cumbersome when you have nested or complex configuration objects. For a cleaner approach, .NET Core allows you to bind configuration sections to strongly typed objects.
Step 1: Create a Configuration POCO (Plain Old CLR Object)
First, create a class that will represent the structure of the configuration section:
public class AppSettings
{
public string SiteName { get; set; }
public string ApiUrl { get; set; }
}
Step 2: Bind Configuration to the POCO
Next, bind the configuration to your class in the ConfigureServices method:
public void ConfigureServices(IServiceCollection services)
{
services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
}
This will bind the AppSettings section from appsettings.json to the AppSettings class.
Step 3: Inject and Access the Strongly Typed Configuration
Now, you can inject IOptions<AppSettings> into your classes (controllers, services, etc.):
public class HomeController : Controller
{
private readonly AppSettings _appSettings;
public HomeController(IOptions<AppSettings> appSettings)
{
_appSettings = appSettings.Value;
}
public IActionResult Index()
{
string siteName = _appSettings.SiteName;
string apiUrl = _appSettings.ApiUrl;
ViewBag.SiteName = siteName;
ViewBag.ApiUrl = apiUrl;
return View();
}
}
With this approach, you get the benefits of strongly typed configuration, which can be easier to work with and refactor in large applications.
4. Conclusion
In this post, we learned how to manage application configuration in .NET Core using the appsettings.json file. We covered how to:
- Set up configuration in your project.
- Access configuration values in controllers and services.
- Use strongly typed configuration for cleaner code.
This is an essential part of building flexible and maintainable applications, and with .NET Core, you have a great deal of flexibility in how you manage and access these settings.
Happy coding!
