Lettura delle impostazioni da app.config o web.config in .NET

Sto lavorando su una libreria di classe C # che deve essere in grado di leggere le impostazioni dal file web.configo app.config(a seconda che si faccia riferimento alla DLL da un'applicazione Web ASP.NET o da un'applicazione Windows Form).

L'ho trovato

ConfigurationSettings.AppSettings.Get("MySetting")

funziona, ma quel codice è stato contrassegnato come deprecato da Microsoft.

Ho letto che dovrei usare:

ConfigurationManager.AppSettings["MySetting"]

Tuttavia, la System.Configuration.ConfigurationManagerclasse non sembra essere disponibile da un progetto Libreria di classi C #.

Qual è il modo migliore per farlo?

Dovrai aggiungere un riferimento a System.Configurationnella cartella dei riferimenti del tuo progetto .

Dovresti assolutamente usare ConfigurationManageril obsoleto ConfigurationSettings.

Per un file app.config di esempio come di seguito:

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

Leggi le impostazioni dell'applicazione sopra usando il codice mostrato sotto:

using System.Configuration;

Potrebbe anche essere necessario aggiungere un riferimento al System.Configurationtuo progetto se non ce n'è già uno. È quindi possibile accedere ai valori in questo modo:

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

Aggiornamento per .NET Framework 4.5 e 4.6; il seguente non funzionerà più:

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

Ora accedi alla classe Setting tramite Proprietà:

string keyvalue = Properties.Settings.Default.keyname;

Vedere Gestione delle impostazioni dell'applicazione per ulteriori informazioni.

Fare clic con il tasto destro sulla libreria di classi e selezionare l'opzione "Aggiungi riferimenti" dal menu.

E dalla scheda .NET, selezionare System.Configuration. Ciò includerebbe il file DLL System.Configuration nel progetto.

Lo sto usando e funziona bene per me:

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

Leggi da Config:

Dovrai aggiungere un riferimento alla configurazione:

1. Apri "Proprietà" sul tuo progetto
2. Vai alla scheda "Impostazioni"
3. Aggiungi "Nome" e "Valore"

4. Ottieni valore utilizzando il seguente codice:

   string value = Properties.Settings.Default.keyname;

Salva nella configurazione:

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

È necessario aggiungere un riferimento all'assembly System.Configuration al progetto.

È possibile che si stia aggiungendo il file App.config in un file DLL. App.Config funziona solo per progetti eseguibili, poiché tutti i file DLL prendono la configurazione dal file di configurazione per il file EXE in esecuzione.

Diciamo che hai due progetti nella tua soluzione:

• SomeDll
• SomeExe

Il tuo problema potrebbe essere correlato al fatto che stai includendo il file app.config in SomeDLL e non in SomeExe. SomeDll è in grado di leggere la configurazione dal progetto SomeExe.

Prova questo:

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

Nel file web.config questa dovrebbe essere la struttura successiva:

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

Ho avuto lo stesso problema. Leggili in questo modo: System.Configuration.ConfigurationSettings.AppSettings ["MySetting"]

web.configviene utilizzato con applicazioni Web. web.configper impostazione predefinita sono necessarie diverse configurazioni per l'applicazione Web. Puoi avere un web.configper ogni cartella nella tua applicazione web.

app.configè usato per applicazioni Windows. Quando si crea l'applicazione in Visual Studio, questa verrà automaticamente rinominata <appname>.exe.confige questo file deve essere recapitato insieme all'applicazione.

È possibile utilizzare lo stesso metodo per chiamare i app settingsvalori da entrambi i file di configurazione: System.Configuration.ConfigurationSettings.AppSettings ["Key"]

Come ho trovato l'approccio migliore per accedere alle variabili delle impostazioni dell'applicazione in modo sistematico creando una classe wrapper su System.Configuration come di seguito

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

Ora possiamo accedere alle variabili delle impostazioni necessarie con nomi codificati utilizzando un'altra classe come di seguito:

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
}

Ti consiglio vivamente di creare un wrapper per questa chiamata. Qualcosa di simile a ConfigurationReaderServicee usare l' iniezione di dipendenza per ottenere questa classe. In questo modo sarai in grado di isolare questi file di configurazione a scopo di test.

Quindi usa il ConfigurationManager.AppSettings["something"];suggerito e restituisci questo valore. Con questo metodo è possibile creare un tipo di ritorno predefinito se non è disponibile alcuna chiave nel file .config.

Inoltre, puoi usare Formo :

Configurazione:

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

Codice:

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

Per completezza, esiste un'altra opzione disponibile solo per progetti Web: System.Web.Configuration.WebConfigurationManager.AppSettings ["MySetting"]

Il vantaggio di ciò è che non richiede l'aggiunta di un riferimento aggiuntivo, quindi potrebbe essere preferibile per alcune persone.

Passaggio 1: fare clic con il pulsante destro del mouse sulla scheda Riferimenti per aggiungere riferimento.

Passaggio 2: fare clic sulla scheda Assiemi

Passaggio 3: cercare "System.Configuration"

Passaggio 4: fare clic su OK.

Quindi funzionerà.

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

Creo sempre un'interfaccia IConfig con proprietà typesafe dichiarate per tutti i valori di configurazione. Una classe di implementazione Config quindi avvolge le chiamate a System.Configuration. Tutte le chiamate di System.Configuration sono ora in un unico posto ed è molto più semplice e pulito mantenere e tenere traccia di quali campi vengono utilizzati e dichiararne i valori predefiniti. Scrivo una serie di metodi di supporto privati ​​per leggere e analizzare tipi di dati comuni.

Utilizzando un framework IoC è possibile accedere ai campi IConfig ovunque nell'applicazione semplicemente passando l'interfaccia a un costruttore di classi. Inoltre, puoi creare finte implementazioni dell'interfaccia IConfig nei test delle unità in modo da poter ora testare vari valori di configurazione e combinazioni di valori senza dover toccare il file App.config o Web.config.

Un'altra possibile soluzione:

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

Ho cercato di trovare una soluzione per questo stesso problema per un paio di giorni ormai. Sono stato in grado di risolvere questo problema aggiungendo una chiave all'interno del tag appsettings nel file web.config . Questo dovrebbe sovrascrivere il file DLL quando si utilizza l'helper.

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

Puoi usare la riga sotto. Nel mio caso funzionava: System.Configuration.ConfigurationSettings.AppSettings ["yourKeyName"]

È necessario assicurarsi che la riga di codice sopra sia anche la versione precedente ed è obsoleta nelle nuove librerie.

ConfigurationManager non è ciò di cui hai bisogno per accedere alle tue impostazioni.

Per fare questo dovresti usare

{YourAppName}.Properties.Settings.{settingName}

Sono stato in grado di far funzionare l'approccio seguente per i progetti .NET Core:

passi:

1. Crea un appsettings.json (formato indicato di seguito) nel tuo progetto.
2. Quindi creare una classe di configurazione. Il formato è fornito di seguito.

3. Ho creato un metodo Login () per mostrare l'utilizzo della classe di configurazione.

   Crea appsettings.json nel tuo progetto con contenuti:

   {
     "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 hai bisogno / vuoi usare la ConfigurationManagerclasse ...

Potrebbe essere necessario caricare System.Configuration.ConfigurationManagerda Microsoft tramite NuGet Package Manager

Strumenti-> Gestore pacchetti NuGet-> Gestisci pacchetti NuGet per soluzione ...

Microsoft Docs

Una cosa degna di nota dai documenti ...

Se l'applicazione richiede l'accesso in sola lettura alla propria configurazione, si consiglia di utilizzare il metodo GetSection (String). Questo metodo fornisce l'accesso ai valori di configurazione memorizzati nella cache per l'applicazione corrente, che offre prestazioni migliori rispetto alla classe Configuration.

Controlla la versione .NET su cui stai lavorando. Dovrebbe essere superiore a 4. E devi aggiungere la libreria di sistema System.Configuration alla tua applicazione.

Ecco un esempio: 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