Setting up .NET Core Configuration Providers


In this blog post, Premier Developer Consultant Randy Patterson teaches us how to set up .NET Core configuration providers in Visual Studio. He shows how to look at NuGet packages to access the Configuration API and then setup the providers as ASP .NET Core web applications.


ASP Core uses the convenient Provider Pattern to load configuration key/value pairs from various sources and expose those to you as a single Configuration object. This allows you to grab a configuration key like ConnectionString with one line of code regardless of where it was sourced from. However, the configuration API is not available by default in .NET Core Console applications.

In this article we will look at the NuGet packages necessary to access the Configuration API and setup the same providers as ASP .NET Core web applications.

Create a .NET Core Console Application

In Visual Studio 2017 go to .NET Core Then Console Application and give it a name like “MyCoreConsoleApp”.

Next, add a JSON configuration file with the name of appsettings.json as the first source of configuration keys:

image

Be sure the property “Copy to Output Directory” is set to “Copy Always” for the newly added JSON file. This will ensure that the file is published with the application.

image

Replace the contents of the appsettings.json file with the following content:

{
"Message":"Hello from appsettings.json"
}


This will set the property “Message” to the value of “Hello……”

Write Some Code

Before we update the application, we need to add the NuGet package that contains the provider needed to load JSON configuration files.

install-package Microsoft.Extensions.Configuration.Json

Next, replace the contents of the Main method with the following code:

static void Main(string[] args)
{
IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional:true, reloadOnChange:true)
.Build();

Console.WriteLine($"Contents of Message Property: {message}");
Console.ReadKey();
}

This will load the appsettings.json file into the configuration object extracting each property and value. In our case we have one property defined named Message set to the value of “Hello from appsettings.json”. The WriteLine method will display the value of the Message property to the console window.

Running the application yields the following output:

image

You’ve successfully loaded configuration data from an appsettings.json file.

Add Environment Variables

Next, add the Environment Variables Provider by installing the following Nuget Package:

install-package Microsoft.Extensions.Configuration.EnvironmentVariables

Then update the Main method to include the provider:

IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional:true, reloadOnChange:true)
.AddEnvironmentVariables()
.Build();

This will load environments variables into the configuration object and is useful for cross-platform or container deployments. Furthermore, because Environment Variables are loaded after the appsettings.json file, any duplicate keys will replace the values from the appsettings.json file.

Next, add an environment variable named “Message” to override the Message property in appsettings.json from the Project Properties Page.

image

Looking at the output displayed below you can see that the environment variables provider replaced the Message key that was initially set in the appsettings.json file with the contents of the environment variable.

image

Add Command Line Arguments

Finally, we’ll add the Command Line Arguments configuration provider. Similar to the previous providers, the first step is to install the proper Nuget package:

Install-Package Microsoft.Extensions.Configuration.CommandLine

Next, update the Main method to load the new provider:

IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional:true, reloadOnChange:true)
.AddEnvironmentVariables()
.AddCommandLine(args)
.Build();

Finally, update the project properties to add a command line argument to replace the Message property with the string “Hello from args”:

image

Run the application and the output should look like the following:

image

The property “Message” was set three times. Once in appsettings.json file, then as an environment variable and finally as a command line argument. The last provider loaded wins any conflicts.

Conclusion

.NET Core added a powerful and flexible configuration API that is available by default in ASP Core application. Simply adding a few NuGet Packages to any .NET Core application will give you the same flexibility. The order the providers are added to the configuration builder is critical as the last loaded overrides any previous values. By applying the providers in the order specified in this article (Json, Environment Variables and Command Line Arguments) you will have a similar configuration environment found in ASP Core applications.

Comments (3)

  1. James Webster says:

    Your code sample after the ‘Write Some Code’ heading is missing a few lines. As it is, it won’t compile as the message variable isn’t declared, and there must be some magic going from an instance of IConfiguration to the message variable providing the expected value to the interpolated string.

  2. Beth Appel says:

    I think you are missing a line of code from the “Write Some Code” section. I had to add this code:

    var message = config[“Message”];

    1. Randy Patterson says:

      Yes, please add the line
      var message = config[“Message”];”
      just prior to the line
      Console.WriteLine($”Contents of Message Property: {message}”);

      Thanks for catching that

Skip to main content