October 22, 2020 · .NET .NET Core Programming Visual Studio Visual C# Tech Tips

Using Config.Net for .NET Application Configurations

A while back I wrote an article describing how to create custom configuration sections in the App.config file in .NET. This is by far the most popular blog post I have posted on this website as it has consistently outperformed all of my other posts:

I decided to write this follow-up post describing how you can use Config.Net for configurations in your .NET (and .NET Core) applications for a few reasons:

There are a lot more benefits I could go through as it's very well-written. There are also other configuration libraries available that we could use, however, unless you are developing an ASP.NET Core Web Application or something that already has its own configuration library baked in, I have found Config.Net to be the easiest to get started with and maintain.

Installing

Base Library

The first step is to install the base Nuget package. This contains all the code that is common between the different configuration formats. You can install it using either one of the following commands depending on your environment:

Package Manager

Install-Package Config.Net

.NET CLI

dotnet add package Config.Net

The base library has a few configuration providers builtin. You'll find the following providers:

Additional Configuration Provider Libraries

There are some additional configuration provider library that you can also install if the format you need is not supported in the base library (e.g. JSON):

Once you've installed the Configuration Provider Library that you want to use, you can use the appropriate extension method to configure it (see below).

Our sample configuration file (JSON)

For this article, we will be basing our configuration code on this appsettings.json file. This is just to give an overview of using the Config.Net library. You can very easily change your configuration provider and still follow along.

{
    "Application": {
        "AllowBetaFunctionality": false,
    	"Version": "1.0.0",
        "Support": {
        	"Name": "Ivan Kahl",
            "Email": "ivan@example.com",
            "Phone": "030-555-3233"
        }
    },
    "Theme": {
    	"Primary": "#e02834",
        "Secondary": "#2d2d2d"
    }
}

Make sure that you create your appsettings.json file in the root of your project and set Copy to Output Directory to Copy if newer:

Defining your configuration interfaces

This first thing you need to do is define the structure of your configuration file using interfaces.  These interfaces will provide us with a structured method of accessing our configuration file.

Let's define the interfaces to match our configuration file above. To keep my code clean, I am creating a Configuration folder in my project where I will store all these interfaces.

IAppSettings.cs

namespace ConfigNetTutorial.Configuration
{
    public interface IAppSettings
    {
        IApplicationSettings Application { get; set; }
        IThemeSettings Theme { get; set; }
    }
}

IApplicationSettings.cs

namespace ConfigNetTutorial.Configuration
{
    public interface IApplicationSettings
    {
        bool AllowBetaFunctionality { get; set; }
        // We don't want to let the program update these 
        // so we only specify getters for these properties
        string Version { get; }
        ISupportSettings Support { get; }
    }
}

ISupportSettings.cs

namespace ConfigNetTutorial.Configuration
{
    public interface ISupportSettings
    {
        string Name { get; }
        string Email { get; }
        string Phone { get; }
    }
}

IThemeSettings.cs

namespace ConfigNetTutorial.Configuration
{
    public interface IThemeSettings
    {
        string Primary { get; set; }
        string Secondary { get; set; }
    }
}

Create our configuration object

Now that we have created the interfaces, we can use Config.Net's ConfigurationBuilder to specify the format and location of our configuration and then build an object that we can use to access our configuration.

When using the ConfigurationBuilder class, we need to specify the interface type that matches the configuration file structure. In this case, our top-most interface is IAppSettings so we will specify that.

We then specify what configuration provider we want to use with the appropriate method. In this case since we want to use a JSON file called appsettings.json, we will use the .UseJsonFile("appsettings.json") method (available in the Config.Net.Json package) and specify the JSON filename as a parameter. You might notice there is also a .UseJsonConfig() method which looks similar, however, we are not going to use it since it doesn't seem to support writing to the configuration file, only reading from it.

We then build our final configuration object after configuring the builder.

using Config.Net;
using ConfigNetTutorial.Configuration;

namespace ConfigNetTutorial
{
    class Program
    {
        static void Main(string[] args)
        {
            var settings = new ConfigurationBuilder<IAppSettings>()
                .UseJsonFile("appsettings.json")
                .Build();
        }
    }
}

Reading and writing configuration settings

We can now use our newly created object to read and write settings in the configuration file. Notice that we just have to use the properties we defined in our interface, Config.Net does the rest.

using System;
using Config.Net;
using ConfigNetTutorial.Configuration;

namespace ConfigNetTutorial
{
    class Program
    {
        static void Main(string[] args)
        {
            var settings = new ConfigurationBuilder<IAppSettings>()
                .UseJsonFile("appsettings.json")
                .Build();

            Console.WriteLine("Welcome to Config.Net Tutorial Application");
            Console.WriteLine("===========================================");
            Console.WriteLine($" - Version: {settings.Application.Version}");
            Console.WriteLine($" - Beta Version: {(settings.Application.AllowBetaFunctionality ? "Yes" : "No")}");
            Console.WriteLine(" - Support:");
            Console.WriteLine($"   - Name: {settings.Application.Support.Name}");
            Console.WriteLine($"   - Email: {settings.Application.Support.Email}");
            Console.WriteLine($"   - Phone: {settings.Application.Support.Phone}");

            Console.WriteLine();
            Console.WriteLine("Configure your theme");
            Console.WriteLine("--------------------");
            
            Console.Write("Primary Colour > ");
            settings.Theme.Primary = Console.ReadLine();

            Console.Write("Secondary Colour > ");
            settings.Theme.Secondary = Console.ReadLine();

            Console.WriteLine("Thank you!");
        }
    }
}

The program above prints the following in the console:

Welcome to Config.Net Tutorial Application
===========================================
 - Version: 1.0.0
 - Beta Version: No
 - Support:
   - Name: Ivan Kahl
   - Email: ivan@example.com
   - Phone: 030-555-3233

Configure your theme
--------------------
Primary Colour > #ac2121
Secondary Colour > #111111
Thank you!

And the appsettings.json file looks like this after running the program (notice how our theme colours were updated).

{
  "Application": {
    "AllowBetaFunctionality": false,
    "Version": "1.0.0",
    "Support": {
      "Name": "Ivan Kahl",
      "Email": "ivan@example.com",
      "Phone": "030-555-3233"
    }
  },
  "Theme": {
    "Primary": "#ac2121",
    "Secondary": "#111111"
  }
}

Conclusion

I hope this article has given you a good overview of the Config.Net library and you have a better idea where you can use it in your projects. I have used it extensively in my projects and it works well. If you would like to learn more about Config.Net or contribute (both code-wise or financially), you can view the repository on GitHub here.

If you have any questions or suggestions, please leave them in the comments below.

Like what you read?

If you liked what you just read and found it useful, please consider buying me a coffee as a token of your support. It brings a warm fuzzy feeling inside!

Buy me a coffeeBuy me a coffee
  • LinkedIn
  • Tumblr
  • Reddit
  • Google+
  • Pinterest
  • Pocket