C# ConfigurationManager in .NET Core

now you can get it even more easy

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

string sze = Configuration.GetSection("AppSettings:MaxAttachmentSize").Value;

after adding to appsettings.json

  "AppSettings": {
    "MaxAttachmentSize": "size1",
    "MinAttachmentSize": "size2"
  }

Using ASP .NET6

Install NuGet package System.Configuration.ConfigurationManager

The name of my configuration file is App.Config

Content of App.config:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <appSettings>
        <add key="DBConnectionString" value="aa" />
        <add key="DBName" value="bb" />
        <add key="AuthKey" value="cc" />
    </appSettings>
</configuration>

File reading values, i.e. SettingsService.cs:

using namespc = System.Configuration;

namespace Ecommerce_server.Services.SetupOperation
{
    public interface ISettingsService
    {
        string MongoDBConnectionString { get => namespc.ConfigurationManager.AppSettings["DBConnectionString"]!; }

        string DataBaseName { get => namespc.ConfigurationManager.AppSettings["DBName"]!; }

        public string AuthKey { get => namespc.ConfigurationManager.AppSettings["AuthKey"]!; }

    }

    public class SettingsService : ISettingsService
    {
        public string MongoDBConnectionString { get => namespc.ConfigurationManager.AppSettings["DBConnectionString"]!; }

        public string DataBaseName { get => namespc.ConfigurationManager.AppSettings["DBName"]!; }

        public string AuthKey { get => namespc.ConfigurationManager.AppSettings["AuthKey"]!; }

    }
}

Note: We had to create a specialized namespace for ConfigurationManger to solve ambiguity.

Reply from Serge is the correct one. .Net 6 and above is suggested to use appsettings.json instead of App.Config and using Microsoft.Extensions.Configurations namespace, instead of System.Configuraiton.ConfigurationManager here Microsoft describes how to use it.

create a appsettings.json file on the root like below

 "AppSettings": {
    "MaxAttachmentSize": "size1",
    "MinAttachmentSize": "size2"
  }

Inside the App.xaml.cs get an instance of IConfiguration

using System.Windows;
using Microsoft.Extensions.Configuration;

namespace WebSiteRatings
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        public static IConfiguration Config { get; private set; }

        public App()
        {
            Config = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json")
                .Build();
        }
    }
}

And you can access within the app as below

string size = App.Config.GetSection("AppSettings:MaxAttachmentSize").Value;

We ran into a similar predicament where we have existing shared libraries that leverage reading directly from ConfigurationManager.AppSettings. These shared libraries were updated to dual target net8 and net48 but were not yet upgraded away from ConfigurationManager.AppSettings. We got around the issue for now by just dynamically copying the settings to ConfigurationManager.AppSettings.

For the net8 projects, we created the json config file like:

AppSettings": {
   "MaxAttachmentSize": "size1"
}

We read the json file within Program.cs and immediate invoke a method like this:

    /// <summary>
    /// Load specific settings from this file into the old ConfigurationManager.AppSettings that are used throughout a lot of our old code.
    /// </summary>
    public void PopulateConfigurationManagerAppSettings()
    {
        System.Configuration.ConfigurationManager.AppSettings["MaxAttachmentSize"] = MaxAttachmentSize;
    }

You could get creative using reflection or generic dictionaries to dynamically copy the values back to the old ConfigurationManager.AppSettings. This is just a simple brute force example to show you the essence of what we did.

For those upgrading to .Net 6 from .Net 4-ish:

1. Migrate your app.config to appsettings.json. Wrap your settings with AppSettings or Config or whatever makes sense. The named top level wrapper allows you to compartmentalize your configs if needed.

Existing app.config:

<configuration>
  <appSettings>
    <add key="SomeKey" value="someValue" />

becomes appsettings.json:

{
  "Config": 
  {
    "SomeKey": "someValue"
  }
}

2. Create a Config.cs POCO at the root to represent your file layout

public class Config{
  public string ConfigRoot = "Config";
  public string SomeKey { get => _someKey; set => _someKey=value; }
  private string _someKey = String.Empty;    
}

3. Load the Config from appsettings.json in your Program.cs

Note: This is only needed if you need the config properties during startup.

//inject appsettings.json values
builder.Services.AddOptions();
builder.Configuration.GetSection("Config");

var app = builder.Build();

4. Load the config as part of your Controller. You will now have to pass/push the config object from the controller into worker classes now.

public class MyController : ControllerBase
{
    private Config _Config;
    private IConfiguration _configuration;

    public MyController( IConfiguration configuration)
    {
        _configuration = configuration;
        _Config = new Config();
        _configuration.GetSection(_Config.ConfigRoot).Bind(_Config);
    }
}

5. Use the config value in your controller method

string myConfigKey = _Config.SomeKey;