Reading settings from app.config or web.config in .NET

You'll need to add a reference to System.Configuration in your project's references folder.

You should definitely be using the ConfigurationManager over the obsolete ConfigurationSettings.

Right click on your class library, and choose the "Add References" option from the Menu.

And from the .NET tab, select System.Configuration. This would include the System.Configuration DLL file into your project.

You must add a reference to the System.Configuration assembly to the project.

Step 1: Right-click on references tab to add reference.

Step 2: Click on Assemblies tab

Step 3: Search for 'System.Configuration'

Step 4: Click OK.

Then it will work.

 string value = System.Configuration.ConfigurationManager.AppSettings["keyname"];

As I found the best approach to access application settings variables in a systematic way by making a wrapper class over System.Configuration as below

public class BaseConfiguration
{
    protected static object GetAppSetting(Type expectedType, string key)
    {
        string value = ConfigurationManager.AppSettings.Get(key);
        try
        {
            if (expectedType == typeof(int))
                return int.Parse(value);
            if (expectedType == typeof(string))
                return value;

            throw new Exception("Type not supported.");
        }
        catch (Exception ex)
        {
            throw new Exception(string.Format("Config key:{0} was expected to be of type {1} but was not.",
                key, expectedType), ex);
        }
    }
}

Now we can access needed settings variables by hard coded names using another class as below:

public class ConfigurationSettings:BaseConfiguration
{
    #region App setting

    public static string ApplicationName
    {
        get { return (string)GetAppSetting(typeof(string), "ApplicationName"); }
    }

    public static string MailBccAddress
    {
        get { return (string)GetAppSetting(typeof(string), "MailBccAddress"); }
    }

    public static string DefaultConnection
    {
        get { return (string)GetAppSetting(typeof(string), "DefaultConnection"); }
    }

    #endregion App setting

    #region global setting


    #endregion global setting
}

If your needing/wanting to use the ConfigurationManager class...

You may need to load System.Configuration.ConfigurationManager by Microsoft via NuGet Package Manager

Tools->NuGet Package Manager->Manage NuGet Packages for Solution...

Microsoft Docs

One thing worth noting from the docs...

If your application needs read-only access to its own configuration, we recommend that you use the GetSection(String) method. This method provides access to the cached configuration values for the current application, which has better performance than the Configuration class.

Please check the .NET version you are working on. It should be higher than 4. And you have to add the System.Configuration system library to your application.

You can use the below line. In my case it was working: System.Configuration.ConfigurationSettings.AppSettings["yourKeyName"]

You must take care that the above line of code is also the old version and it's deprecated in new libraries.

The ConfigurationManager is not what you need to access your own settings.

To do this you should use

{YourAppName}.Properties.Settings.{settingName}

I was able to get the below approach working for .NET Core projects:

Steps:

1. Create an appsettings.json (format given below) in your project.
2. Next create a configuration class. The format is provided below.

3. I have created a Login() method to show the usage of the Configuration Class.

   Create appsettings.json in your project with content:

   {
     "Environments": {
       "QA": {
         "Url": "somevalue",
    "Username": "someuser",
         "Password": "somepwd"
     },
     "BrowserConfig": {
       "Browser": "Chrome",
       "Headless": "true"
     },
     "EnvironmentSelected": {
       "Environment": "QA"
     }
   }
   
   public static class Configuration
   {
       private static IConfiguration _configuration;
   
       static Configuration()
       {
           var builder = new ConfigurationBuilder()
               .AddJsonFile($"appsettings.json");
   
           _configuration = builder.Build();
   
       }
       public static Browser GetBrowser()
       {
   
           if (_configuration.GetSection("BrowserConfig:Browser").Value == "Firefox")
           {
               return Browser.Firefox;
           }
           if (_configuration.GetSection("BrowserConfig:Browser").Value == "Edge")
           {
               return Browser.Edge;
           }
           if (_configuration.GetSection("BrowserConfig:Browser").Value == "IE")
           {
               return Browser.InternetExplorer;
           }
           return Browser.Chrome;
       }
   
       public static bool IsHeadless()
       {
           return _configuration.GetSection("BrowserConfig:Headless").Value == "true";
       }
   
       public static string GetEnvironment()
       {
           return _configuration.GetSection("EnvironmentSelected")["Environment"];
       }
       public static IConfigurationSection EnvironmentInfo()
       {
           var env = GetEnvironment();
           return _configuration.GetSection($@"Environments:{env}");
       }
   
   }
   
   
   public void Login()
   {
       var environment = Configuration.EnvironmentInfo();
       Email.SendKeys(environment["username"]);
       Password.SendKeys(environment["password"]);
       WaitForElementToBeClickableAndClick(_driver, SignIn);
   }
   

extra : if you are working on a Class Library project you have to embed the settings.json file.

A class library shouldn't really be directly referencing anything in app.config - the class doesn't have an app.config, because it's not an application, it's a class.

1. Go to the JSON file's properties.
2. Change Build Action -> Embedded resource.
3. Use the following code to read it.

var assembly = Assembly.GetExecutingAssembly();

var resourceStream = assembly.GetManifestResourceStream("Assembly.file.json");

string myString = reader.ReadToEnd();

now we have a JSON string we can Deserialize it using JsonConvert

if you didn't embed the file inside the assembly you can't use only the DLL file without the file

I'm using Visual Studio for Mac version 17.0.6.

As you can see on this screenshot it is not possible to add a reference to System.Configuration.

Solution:

1. install NuGet Package - System.Configuration.ConfigurationManager.
2. Create app.config file and set "Build action" to "EmbeddedResource"

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <appSettings>
        <add key="name" value="Joe"/>
    </appSettings>
</configuration>

3. using System.Configuration;
4. enjoy)

string name = ConfigurationManager.AppSettings["name"];

BTW: Do not add an app.config for a library