# Setup multiple appsetting-files with a .NET Console Application

**Date:** 2019-01-03  
**Author:** Kees C. Bakker  
**Categories:** .NET / C#  
**Tags:** Console Application  
**Original:** https://keestalkstech.com/setup-multiple-setting-files-with-a-net-console-application/

![Setup multiple appsetting-files with a .NET Console Application](https://keestalkstech.com/wp-content/uploads/2018/12/Use-multiple-appsettings.json-in-a-Console-Application.jpg)

---

In *ASP.NET Core* we are used to having multiple `appsettings.json` files with settings that differ per environment. I want to do the same in a *Console Application*. This makes debugging the application easier.

## Multiple environments

First, I would like to distinguish between environments. For ASP.NET Core, I use *Local*, *Development* and *Production*. Because I don't have a *Development* environment for my application, I'll only use *Local*.

Just like ASP.NET Core, we will specify the environment as an *environment variable*. Right click on the project file > properties > click the debug tab. Add a new environment variable with the name `ENVIRONMENT` and the value `Local`.

![](https://keestalkstech.com/wp-content/uploads/2018/12/2018-12-27_1109.png)
*Screenshot of the debug tab of a console application.*

In ASP.NET this variable is named `ASPNETCORE_ENVIRONMENT`.

## Multiple appsettings

Add the following JSON files to the root of your application:

In my case, I don't use a special *Production* file, but I'll override local setting values in the appsettings.Local.json file. Next, we must create a settings class, something like:

```cs
public class AppSettings
{
    public string TempDirectory { get; set; }
}
```

Open the appsettings.json and add an `app` section:

```json
{
    "App": {
        "TempDirectory": "c:\\temp\\rss-hero\\tmp\\"
    }
}
```

Note: I only add settings that differ from production in my local settings file. The system will override the settings of the main file.

## Hook 'em up!

Next, we need to hook the settings up in the application. In a [previous article I've demonstrated how to leverage dependency injection](https://keestalkstech.com/2018/04/dependency-injection-with-ioptions-in-console-apps-in-net-core-2/) to support `IOptions` and we're building upon that. Install the following packages:

Now add this code to your `Main` class:

```cs
var environmentName =
    Environment.GetEnvironmentVariable("ENVIRONMENT");

// create service collection
var services = new ServiceCollection();

// build config
var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", false)
    .AddJsonFile($"appsettings.{environmentName}.json", true)
    .AddEnvironmentVariables()
    .Build();

// setup config
services.AddOptions();
services.Configure<AppSettings>(configuration.GetSection("App"));

// create service provider
var serviceProvider = services.BuildServiceProvider();
```

We can now resolve settings using dependency injection or directly by doing:

```cs
var appSettings = serviceProvider
    .GetService<IOptions<AppSettings>>();
```

## AddEnvironmentVariables?

The environment variables are used as a way to *override* the app settings. In this case we can override the setting adding an environment variable with the name `App__TempDirectory`. The `__` can be used to set deeper level settings.

## That's all

Setting this up shouldn't be more than copy-paste. For a more comprehensive overview of dependency injection for console applications check: [Dependency injection (with IOptions) in Console Apps in .NET Core](https://keestalkstech.com/2018/04/dependency-injection-with-ioptions-in-console-apps-in-net-core-2/).

## Improvements

2019-09-19: Explained how `AddEnvironmentVariables` can be used to override settings.