Lendo configurações de app.config ou web.config no .NET

Estou trabalhando em uma biblioteca de classes C # que precisa ser capaz de ler as configurações do arquivo web.configou app.config(dependendo se a DLL é referenciada em um aplicativo Web do ASP.NET ou em um aplicativo do Windows Forms).

Eu descobri isso

ConfigurationSettings.AppSettings.Get("MySetting")

funciona, mas esse código foi marcado como reprovado pela Microsoft.

Eu li que eu deveria estar usando:

ConfigurationManager.AppSettings["MySetting"]

No entanto, a System.Configuration.ConfigurationManagerclasse não parece estar disponível em um projeto da Biblioteca de Classes em C #.

Qual é a melhor maneira de fazer isso?

Você precisará adicionar uma referência ao System.Configurationno de seu projeto pasta referências .

Você definitivamente deveria estar usando ConfigurationManagero obsoleto ConfigurationSettings.

Para um arquivo app.config de exemplo, como abaixo:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="countoffiles" value="7" />
    <add key="logfilelocation" value="abc.txt" />
  </appSettings>
</configuration>

Você leu as configurações do aplicativo acima usando o código mostrado abaixo:

using System.Configuration;

Você também pode precisar adicionar uma referência ao System.Configurationseu projeto, se ainda não houver uma. Você pode acessar os valores da seguinte maneira:

string configvalue1 = ConfigurationManager.AppSettings["countoffiles"];
string configvalue2 = ConfigurationManager.AppSettings["logfilelocation"];

Atualização para o .NET Framework 4.5 e 4.6; o seguinte não funcionará mais:

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

Agora acesse a classe Setting via Properties:

string keyvalue = Properties.Settings.Default.keyname;

Consulte Gerenciando configurações do aplicativo para obter mais informações.

Clique com o botão direito na sua biblioteca de classes e escolha a opção "Adicionar referências" no menu.

E na guia .NET, selecione System.Configuration. Isso incluiria o arquivo DLL System.Configuration em seu projeto.

Estou usando isso e funciona bem para mim:

textBox1.Text = ConfigurationManager.AppSettings["Name"];

Read From Config:

Você precisará adicionar uma referência à configuração:

1. Abra "Propriedades" no seu projeto
2. Vá para a guia "Configurações"
3. Adicione "Nome" e "Valor"

4. Obtenha valor usando o seguinte código:

   string value = Properties.Settings.Default.keyname;

Salve na configuração:

   Properties.Settings.Default.keyName = value;
   Properties.Settings.Default.Save();

Você deve adicionar uma referência ao assembly System.Configuration ao projeto.

Você pode estar adicionando o arquivo App.config a um arquivo DLL. App.Config funciona apenas para projetos executáveis, pois todos os arquivos DLL retiram a configuração do arquivo de configuração para o arquivo EXE que está sendo executado.

Digamos que você tenha dois projetos em sua solução:

• SomeDll
• SomeExe

Seu problema pode estar relacionado ao fato de você estar incluindo o arquivo app.config no SomeDLL e não no SomeExe. SomeDll é capaz de ler a configuração do projeto SomeExe.

Tente o seguinte:

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

No arquivo web.config, essa deve ser a próxima estrutura:

<configuration>
<appSettings>
<add key="keyname" value="keyvalue" />
</appSettings>
</configuration>

Eu tive o mesmo problema. Apenas leia-os desta maneira: System.Configuration.ConfigurationSettings.AppSettings ["MySetting"]

web.configé usado com aplicativos da web. web.configpor padrão, possui várias configurações necessárias para o aplicativo da web. Você pode ter um web.configpara cada pasta em seu aplicativo da web.

app.configé usado para aplicativos do Windows. Quando você cria o aplicativo no Visual Studio, ele é automaticamente renomeado <appname>.exe.confige esse arquivo deve ser entregue junto com o aplicativo.

Você pode usar o mesmo método para chamar os app settingsvalores dos dois arquivos de configuração: System.Configuration.ConfigurationSettings.AppSettings ["Key"]

Como eu encontrei a melhor abordagem para acessar variáveis ​​de configurações de aplicativos de maneira sistemática, criando uma classe de wrapper sobre System.Configuration como abaixo

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);
        }
    }
}

Agora podemos acessar as variáveis ​​de configuração necessárias por nomes codificados usando outra classe, como abaixo:

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
}

Eu recomendo fortemente que você crie um wrapper para esta chamada. Algo como ae ConfigurationReaderServiceuse injeção de dependência para obter essa classe. Dessa forma, você poderá isolar esses arquivos de configuração para fins de teste.

Portanto, use o ConfigurationManager.AppSettings["something"];sugerido e retorne esse valor. Com esse método, você pode criar algum tipo de retorno padrão se não houver nenhuma chave disponível no arquivo .config.

Além disso, você pode usar o Formo :

Configuração:

<appSettings>
    <add key="RetryAttempts" value="5" />
    <add key="ApplicationBuildDate" value="11/4/1999 6:23 AM" />
</appSettings>

Código:

dynamic config = new Configuration();
var retryAttempts1 = config.RetryAttempts;                 // Returns 5 as a string
var retryAttempts2 = config.RetryAttempts(10);             // Returns 5 if found in config, else 10
var retryAttempts3 = config.RetryAttempts(userInput, 10);  // Returns 5 if it exists in config, else userInput if not null, else 10
var appBuildDate = config.ApplicationBuildDate<DateTime>();

Apenas para completar, existe outra opção disponível apenas para projetos da web: System.Web.Configuration.WebConfigurationManager.AppSettings ["MySetting"]

O benefício disso é que ele não requer que uma referência extra seja adicionada, portanto pode ser preferível para algumas pessoas.

Etapa 1: Clique com o botão direito do mouse na guia referências para adicionar referência.

Etapa 2: clique na guia Assemblies

Etapa 3: procure por 'System.Configuration'

Etapa 4: Clique em OK.

Então vai funcionar.

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

Eu sempre crio uma interface IConfig com propriedades typesafe declaradas para todos os valores de configuração. Uma classe de implementação Config agrupa as chamadas para System.Configuration. Todas as suas chamadas System.Configuration agora estão em um só lugar, e é muito mais fácil e limpo manter e rastrear quais campos estão sendo usados ​​e declarar seus valores padrão. Escrevo um conjunto de métodos auxiliares particulares para ler e analisar tipos de dados comuns.

Usando uma estrutura de IoC , você pode acessar os campos IConfig em qualquer lugar do seu aplicativo simplesmente passando a interface para um construtor de classe. Você também poderá criar implementações simuladas da interface IConfig em seus testes de unidade, para que agora possa testar vários valores de configuração e combinações de valores sem precisar tocar no arquivo App.config ou Web.config.

Outra solução possível:

var MyReader = new System.Configuration.AppSettingsReader();
string keyvalue = MyReader.GetValue("keyalue",typeof(string)).ToString();

Estou tentando encontrar uma correção para esse mesmo problema há alguns dias. Consegui resolver isso adicionando uma chave na tag appsettings no arquivo web.config . Isso deve substituir o arquivo .dll ao usar o auxiliar.

<configuration>
    <appSettings>
        <add key="loginUrl" value="~/RedirectValue.cshtml" />
        <add key="autoFormsAuthentication" value="false"/>
    </appSettings>
</configuration>

Você pode usar a linha abaixo. No meu caso, estava funcionando: System.Configuration.ConfigurationSettings.AppSettings ["yourKeyName"]

Você deve ter cuidado para que a linha de código acima também seja a versão antiga e seja preterida em novas bibliotecas.

O ConfigurationManager não é o que você precisa para acessar suas próprias configurações.

Para fazer isso, você deve usar

{YourAppName}.Properties.Settings.{settingName}

Consegui obter a abordagem abaixo trabalhando para projetos do .NET Core:

Passos:

1. Crie um appsettings.json (formato fornecido abaixo) em seu projeto.
2. Em seguida, crie uma classe de configuração. O formato é fornecido abaixo.

3. Eu criei um método Login () para mostrar o uso da Classe de Configuração.

   Crie appsettings.json no seu projeto com o conteúdo:

   {
     "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);
   }

Se você precisa / deseja usar a ConfigurationManagerclasse ...

Pode ser necessário carregar System.Configuration.ConfigurationManagerpela Microsoft via NuGet Package Manager

Ferramentas-> Gerenciador de Pacotes NuGet-> Gerenciar Pacotes NuGet para Solução ...

Docs da Microsoft

Uma coisa que vale a pena notar nos documentos ...

Se seu aplicativo precisar de acesso somente leitura à sua própria configuração, recomendamos que você use o método GetSection (String). Este método fornece acesso aos valores de configuração em cache para o aplicativo atual, que possui melhor desempenho que a classe Configuration.

Verifique a versão do .NET em que você está trabalhando. Deve ser maior que 4. E você precisa adicionar a biblioteca do sistema System.Configuration ao seu aplicativo.

Aqui está um exemplo: App.config

<applicationSettings>
    <MyApp.My.MySettings>
        <setting name="Printer" serializeAs="String">
            <value>1234 </value>
        </setting>
    </MyApp.My.MySettings>
</applicationSettings>

Dim strPrinterName as string = My.settings.Printer