Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese
Questa documentazione è stata archiviata e non viene gestita.

Classe ConfigurationManager

Fornisce l'accesso ai file di configurazione per le applicazioni client. Questa classe non può essere ereditata.

System.Object
  System.Configuration.ConfigurationManager

Spazio dei nomi:  System.Configuration
Assembly:  System.Configuration (in System.Configuration.dll)

public static class ConfigurationManager

Il tipo ConfigurationManager espone i seguenti membri.

  NomeDescrizione
Proprietà pubblicaMembro staticoAppSettingsOttiene i dati di AppSettingsSection per la configurazione predefinita dell'applicazione corrente.
Proprietà pubblicaMembro staticoConnectionStringsOttiene i dati di ConnectionStringsSection per la configurazione predefinita dell'applicazione corrente.
In alto

  NomeDescrizione
Metodo pubblicoMembro staticoGetSectionRecupera una sezione di configurazione specificata per la configurazione predefinita dell'applicazione corrente.
Metodo pubblicoMembro staticoOpenExeConfiguration(ConfigurationUserLevel)Apre il file di configurazione per l'applicazione corrente come oggetto Configuration.
Metodo pubblicoMembro staticoOpenExeConfiguration(String)Apre il file di configurazione client specificato come oggetto Configuration.
Metodo pubblicoMembro staticoOpenMachineConfigurationApre il file di configurazione del computer in uso come oggetto Configuration.
Metodo pubblicoMembro staticoOpenMappedExeConfigurationApre il file di configurazione client specificato come un oggetto Configuration che utilizza il mapping del file e il livello utente specificati.
Metodo pubblicoMembro staticoOpenMappedMachineConfigurationApre il file di configurazione del computer come un oggetto Configuration che utilizza il mapping del file specificato.
Metodo pubblicoMembro staticoRefreshSectionAggiorna la sezione denominata in modo che al successivo recupero venga riletta dal disco.
In alto

La classe ConfigurationManager consente di accedere alle informazioni sulla configurazione del computer, dell'applicazione e dell'utente. Questa classe sostituisce la classe ConfigurationSettings che è diventata obsoleta.

NotaNota

Il nome e il percorso del file di configurazione dell'applicazione dipendono dall'host dell'applicazione. Per ulteriori informazioni, vedere Application Configuration Files.

Per gestire le informazioni sulla configurazione, è possibile utilizzare i tipi System.Configuration incorporati o derivare da essi. Impiegando questi tipi, è possibile utilizzare direttamente le informazioni sulla configurazione ed estendere i file di configurazione in modo da includere informazioni personalizzate.

La classe ConfigurationManager include membri che consentono di eseguire le attività seguenti:

  • Leggere una sezione da un file di configurazione. Per accedere alle informazioni sulla configurazione, chiamare il metodo GetSection. Per alcune sezioni, ad esempio appSettings e connectionStrings, utilizzare le classi AppSettings e ConnectionStrings. Questi membri eseguono operazioni in sola lettura, utilizzano una singola istanza memorizzata nella cache e riconoscono il multithreading.

  • Leggere e scrivere interi file di configurazione. L'applicazione consente di leggere e scrivere le impostazioni di configurazione a qualsiasi livello, per se stessa o per altre applicazioni o computer, in modalità locale o remota. Utilizzare uno dei metodi forniti dalla classe ConfigurationManager per aprire un file di configurazione quale SampleApp.exe.config. Questi metodi restituiscono un oggetto Configuration che a sua volta espone metodi e proprietà utilizzabili per lavorare con i file di configurazione associati. I metodi eseguono operazioni in lettura o in scrittura e creano i dati di configurazione ogni volta che viene scritto un file.

  • Supportare le attività di configurazione. I tipi seguenti vengono utilizzati per supportare svariate attività di configurazione:

    Oltre a utilizzare le informazioni sulla configurazione esistenti, è possibile creare e utilizzare elementi di configurazione personalizzati estendendo i tipi di configurazione incorporati, quali le classi ConfigurationElement, ConfigurationElementCollection, ConfigurationProperty e ConfigurationSection. Per un esempio di come estendere un tipo di configurazione incorporato a livello di codice, vedere ConfigurationSection. Per un esempio su come estendere un tipo di configurazione incorporato che utilizza il modello basato su attributi, vedere ConfigurationElement.

Note per gli implementatori

La classe Configuration consente l'accesso a livello di codice per la modifica dei file di configurazione. Utilizzare uno dei metodi di apertura forniti da ConfigurationManager. Questi metodi restituiscono un oggetto Configuration, che a sua volta fornisce i metodi e le proprietà necessari per gestire i file di configurazione sottostanti. A questi file è possibile accedere per eseguire operazioni di lettura e scrittura.

Per leggere i file di configurazione, utilizzare GetSection o GetSectionGroup per leggere le informazioni di configurazione. L'utente o il processo che consente di leggere deve disporre delle seguenti autorizzazioni:

  • Autorizzazione di lettura per il file di configurazione al livello di gerarchia della configurazione corrente.

  • Autorizzazioni di lettura per tutti i file di configurazione padre.

Se l'applicazione necessita di accedere in sola lettura alla relativa configurazione, è consigliabile utilizzare il metodo GetSection. Questo metodo fornisce l'accesso ai valori di configurazione memorizzati nella cache per l'applicazione corrente, garantendo prestazioni migliori rispetto alla classe Configuration.

Per scrivere nei file di configurazione, utilizzare uno dei metodi Save. L'utente o il processo che consente di scrivere deve disporre delle seguenti autorizzazioni:

  • Autorizzazione di scrittura per il file e la directory di configurazione al livello di gerarchia della configurazione corrente.

  • Autorizzazioni di lettura per tutti i file di configurazione.

A complemento di questo argomento è disponibile un progetto di sito Web di Visual Studio con codice sorgente che è possibile scaricare.

Nell'esempio seguente viene illustrato come utilizzare la classe ConfigurationManager in un'applicazione console. Nel codice vengono illustrate le operazioni seguenti:

  • Accesso alla sezione di configurazione appSettings. Se la sezione non esiste, viene creata e aggiunta al file di configurazione. Se il file di configurazione dell'applicazione non esiste, nell'esempio ne viene creato uno.

  • Accesso al file Machine.config per ottenere informazioni quali la stringa di connessione predefinita, se definita, e le sezioni attualmente configurate.

    NotaNota

    Quando si crea un progetto, assicurarsi di aggiungere un riferimento all'assembly System.Configuration. Questo assembly contiene la classe ConfigurationManager.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

// The following example shows how to use the ConfigurationManager 
// class in a console application.
//
// IMPORTANT: To compile this example, you must add to the project 
// a reference to the System.Configuration assembly.
//
  #region
  //*** Auxiliary Classes ***//

  // Define a custom configuration element to be 
  // contained by the ConsoleSection. This element 
  // stores background and foreground colors that
  // the application applies to the console window.
  public class ConsoleConfigElement : ConfigurationElement
  {
    // Create the element.
    public ConsoleConfigElement()
    { }

    // Create the element.
    public ConsoleConfigElement(ConsoleColor fColor, 
        ConsoleColor bColor)
    {
      ForegroundColor = fColor;
      BackgroundColor = bColor;
    }

    // Get or set the console background color.
    [ConfigurationProperty("background",
      DefaultValue = ConsoleColor.Black,
      IsRequired = false)]
    public ConsoleColor BackgroundColor
    {
      get
      {
        return (ConsoleColor)this["background"];
      }
      set
      {
        this["background"] = value;
      }
    }

    // Get or set the console foreground color.
    [ConfigurationProperty("foreground",
       DefaultValue = ConsoleColor.White,
       IsRequired = false)]
    public ConsoleColor ForegroundColor
    {
      get
      {
        return (ConsoleColor)this["foreground"];
      }
      set
      {
        this["foreground"] = value;
      }
    }
  }

  // Define a custom section that is used by the application
  // to create custom configuration sections at the specified 
  // level in the configuration hierarchy that is in the 
  // proper configuration file.
  // This enables the user that has the proper access 
  // rights, to make changes to the configuration files.
  public class ConsoleSection : ConfigurationSection
  {
    // Create a configuration section.
    public ConsoleSection()
    { }

    // Set or get the ConsoleElement. 
    [ConfigurationProperty("consoleElement")]
    public ConsoleConfigElement ConsoleElement
    {
      get
      {
        return (
          (ConsoleConfigElement) this["consoleElement"]);
      }
      set
      {
        this["consoleElement"] = value;
      }
    }
  }
  #endregion

  #region
  //*** ConfigurationManager Interaction Class ***//

  // The following code uses the ConfigurationManager class to 
  // perform the following tasks:
  // 1) Get the application roaming configuration file.
  // 2) Get the application configuration file.
  // 3) Access a specified configuration file through mapping.
  // 4) Access the machine configuration file through mapping. 
  // 5) Read a specified configuration section.
  // 6) Read the connectionStrings section.
  // 7) Read or write the appSettings section.
  public static class UsingConfigurationManager
  {

    // Get the roaming configuration file associated 
    // with the application.
    // This function uses the OpenExeConfiguration(
    // ConfigurationUserLevel userLevel) method to 
    // get the configuration file.
    // It also creates a custom ConsoleSection and 
    // sets its ConsoleEment BackgroundColor and
    // ForegroundColor properties to blue and yellow
    // respectively. Then it uses these properties to
    // set the console colors.  
    public static void GetRoamingConfiguration()
    {
      // Define the custom section to add to the
      // configuration file.
      string sectionName = "consoleSection";
      ConsoleSection currentSection = null;

      // Get the roaming configuration 
      // that applies to the current user.
      Configuration roamingConfig =
        ConfigurationManager.OpenExeConfiguration(
         ConfigurationUserLevel.PerUserRoaming);

      // Map the roaming configuration file. This
      // enables the application to access 
      // the configuration file using the
      // System.Configuration.Configuration class
      ExeConfigurationFileMap configFileMap =
        new ExeConfigurationFileMap();
      configFileMap.ExeConfigFilename = 
        roamingConfig.FilePath;

      // Get the mapped configuration file.
      Configuration config =
        ConfigurationManager.OpenMappedExeConfiguration(
          configFileMap, ConfigurationUserLevel.None);

      try
        {
          currentSection =
               (ConsoleSection)config.GetSection(
                 sectionName);

          // Synchronize the application configuration
          // if needed. The following two steps seem
          // to solve some out of synch issues 
          // between roaming and default
          // configuration.
          config.Save(ConfigurationSaveMode.Modified);

          // Force a reload of the changed section, 
          // if needed. This makes the new values available 
          // for reading.
          ConfigurationManager.RefreshSection(sectionName);

          if (currentSection == null)
          {
            // Create a custom configuration section.
            currentSection = new ConsoleSection();

            // Define where in the configuration file 
            // hierarchy the associated 
            // configuration section can be declared.
            // The following assignment assures that 
            // the configuration information can be 
            // defined in the user.config file in the 
            // roaming user directory. 
            currentSection.SectionInformation.AllowExeDefinition =
              ConfigurationAllowExeDefinition.MachineToLocalUser;

            // Allow the configuration section to be 
            // overridden by lower-level configuration files.
            // This means that lower-level files can contain
            // the section (use the same name) and assign 
            // different values to it as done by the
            // function GetApplicationConfiguration() in this
            // example.
            currentSection.SectionInformation.AllowOverride =
              true;

            // Store console settings for roaming users.
            currentSection.ConsoleElement.BackgroundColor =
                ConsoleColor.Blue;
            currentSection.ConsoleElement.ForegroundColor =
                ConsoleColor.Yellow;

            // Add configuration information to 
            // the configuration file.
            config.Sections.Add(sectionName, currentSection);
            config.Save(ConfigurationSaveMode.Modified);
            // Force a reload of the changed section. This 
            // makes the new values available for reading.
            ConfigurationManager.RefreshSection(
              sectionName);
          }
      }
      catch (ConfigurationErrorsException e)
      {
          Console.WriteLine("[Exception error: {0}]",
              e.ToString());
      }

      // Set console properties using values
      // stored in the configuration file.
      Console.BackgroundColor =
        currentSection.ConsoleElement.BackgroundColor;
      Console.ForegroundColor =
        currentSection.ConsoleElement.ForegroundColor;
      // Apply the changes.
      Console.Clear();

      // Display feedback.
      Console.WriteLine();
      Console.WriteLine(
        "Using OpenExeConfiguration(ConfigurationUserLevel).");
      Console.WriteLine(
          "Configuration file is: {0}", config.FilePath);
    }

    // Get the application configuration file.
    // This function uses the 
    // OpenExeConfiguration(string)method 
    // to get the application configuration file. 
    // It also creates a custom ConsoleSection and 
    // sets its ConsoleEment BackgroundColor and
    // ForegroundColor properties to black and white
    // respectively. Then it uses these properties to
    // set the console colors.  
    public static void GetAppConfiguration()
    {

      // Get the application path needed to obtain
      // the application configuration file.
#if DEBUG
      string applicationName =
          Environment.GetCommandLineArgs()[0];
#else
           string applicationName =
          Environment.GetCommandLineArgs()[0]+ ".exe";
#endif

      string exePath = System.IO.Path.Combine(
          Environment.CurrentDirectory, applicationName);

      // Get the configuration file. The file name has
      // this format appname.exe.config.
      System.Configuration.Configuration config =
        ConfigurationManager.OpenExeConfiguration(exePath);

      try
      {

        // Create a custom configuration section
        // having the same name that is used in the 
        // roaming configuration file.
        // This is because the configuration section 
        // can be overridden by lower-level 
        // configuration files. 
        // See the GetRoamingConfiguration() function in 
        // this example.
        string sectionName = "consoleSection";
        ConsoleSection customSection = new ConsoleSection();

        if (config.Sections[sectionName] == null)
        {
          // Create a custom section if it does 
          // not exist yet.

          // Store console settings.
          customSection.ConsoleElement.BackgroundColor =
              ConsoleColor.Black;
          customSection.ConsoleElement.ForegroundColor =
              ConsoleColor.White;

          // Add configuration information to the
          // configuration file.
          config.Sections.Add(sectionName, customSection);
          config.Save(ConfigurationSaveMode.Modified);
          // Force a reload of the changed section.
          // This makes the new values available for reading.
          ConfigurationManager.RefreshSection(sectionName);
        }
        // Set console properties using values
        // stored in the configuration file.
        customSection =
            (ConsoleSection)config.GetSection(sectionName);
        Console.BackgroundColor =
            customSection.ConsoleElement.BackgroundColor;
        Console.ForegroundColor =
            customSection.ConsoleElement.ForegroundColor;
        // Apply the changes.
        Console.Clear();
      }
      catch (ConfigurationErrorsException e)
      {
        Console.WriteLine("[Error exception: {0}]",
            e.ToString());
      }

      // Display feedback.
      Console.WriteLine();
      Console.WriteLine("Using OpenExeConfiguration(string).");
      // Display the current configuration file path.
      Console.WriteLine("Configuration file is: {0}", 
        config.FilePath);
    }

    // Get the AppSettings section.        
    // This function uses the AppSettings property
    // to read the appSettings configuration 
    // section.
    public static void ReadAppSettings()
    {
      try
      {
        // Get the AppSettings section.
        NameValueCollection appSettings =
           ConfigurationManager.AppSettings;

        // Get the AppSettings section elements.
        Console.WriteLine();
        Console.WriteLine("Using AppSettings property.");
        Console.WriteLine("Application settings:");

        if (appSettings.Count == 0)
        {
          Console.WriteLine("[ReadAppSettings: {0}]",
          "AppSettings is empty Use GetSection command first.");
        }
        for (int i = 0; i < appSettings.Count; i++)
        {
          Console.WriteLine("#{0} Key: {1} Value: {2}",
            i, appSettings.GetKey(i), appSettings[i]);
        }
      }
      catch (ConfigurationErrorsException e)
      {
        Console.WriteLine("[ReadAppSettings: {0}]",
            e.ToString());
      }
    }

    // Get the ConnectionStrings section.        
    // This function uses the ConnectionStrings 
    // property to read the connectionStrings
    // configuration section.
    public static void ReadConnectionStrings()
    {

      // Get the ConnectionStrings collection.
      ConnectionStringSettingsCollection connections =
          ConfigurationManager.ConnectionStrings;

      if (connections.Count != 0)
      {
        Console.WriteLine();
        Console.WriteLine("Using ConnectionStrings property.");
        Console.WriteLine("Connection strings:");

        // Get the collection elements.
        foreach (ConnectionStringSettings connection in 
          connections)
        {
          string name = connection.Name;
          string provider = connection.ProviderName;
          string connectionString = connection.ConnectionString;

          Console.WriteLine("Name:               {0}", 
            name);
          Console.WriteLine("Connection string:  {0}", 
            connectionString);
         Console.WriteLine("Provider:            {0}", 
            provider);
        }
      }
      else
      {
        Console.WriteLine();
        Console.WriteLine("No connection string is defined.");
        Console.WriteLine();
      }
    }

    // Create the AppSettings section.
    // The function uses the GetSection(string)method 
    // to access the configuration section. 
    // It also adds a new element to the section collection.
    public static void CreateAppSettings()
    {
      // Get the application configuration file.
      System.Configuration.Configuration config =
        ConfigurationManager.OpenExeConfiguration(
              ConfigurationUserLevel.None);

      string sectionName = "appSettings";

      // Add an entry to appSettings.
      int appStgCnt =
          ConfigurationManager.AppSettings.Count;
      string newKey = "NewKey" + appStgCnt.ToString();

      string newValue = DateTime.Now.ToLongDateString() + 
        " " + DateTime.Now.ToLongTimeString();

      config.AppSettings.Settings.Add(newKey, newValue);

      // Save the configuration file.
      config.Save(ConfigurationSaveMode.Modified);

      // Force a reload of the changed section. This 
      // makes the new values available for reading.
      ConfigurationManager.RefreshSection(sectionName);

      // Get the AppSettings section.
      AppSettingsSection appSettingSection =
        (AppSettingsSection)config.GetSection(sectionName);

      Console.WriteLine();
      Console.WriteLine("Using GetSection(string).");
      Console.WriteLine("AppSettings section:");
      Console.WriteLine(
        appSettingSection.SectionInformation.GetRawXml());
    }

    // Access the machine configuration file using mapping.
    // The function uses the OpenMappedMachineConfiguration 
    // method to access the machine configuration. 
    public static void MapMachineConfiguration()
    {
      // Get the machine.config file.
      Configuration machineConfig =
        ConfigurationManager.OpenMachineConfiguration();
      // Get the machine.config file path.
      ConfigurationFileMap configFile =
        new ConfigurationFileMap(machineConfig.FilePath);

      // Map the application configuration file to the machine 
      // configuration file.
      Configuration config =
        ConfigurationManager.OpenMappedMachineConfiguration(
          configFile);

      // Get the AppSettings section.
      AppSettingsSection appSettingSection =
        (AppSettingsSection)config.GetSection("appSettings");
      appSettingSection.SectionInformation.AllowExeDefinition =
          ConfigurationAllowExeDefinition.MachineToRoamingUser;

      // Display the configuration file sections.
      ConfigurationSectionCollection sections = 
        config.Sections;

      Console.WriteLine();
      Console.WriteLine("Using OpenMappedMachineConfiguration.");
      Console.WriteLine("Sections in machine.config:");

      // Get the sections in the machine.config.
      foreach (ConfigurationSection section in sections)
      {
          string name = section.SectionInformation.Name;
          Console.WriteLine("Name: {0}", name);
      }

    }



    // Access a configuration file using mapping.
    // This function uses the OpenMappedExeConfiguration 
    // method to access a new configuration file.   
    // It also gets the custom ConsoleSection and 
    // sets its ConsoleEment BackgroundColor and
    // ForegroundColor properties to green and red
    // respectively. Then it uses these properties to
    // set the console colors.  
    public static void MapExeConfiguration()
    {

      // Get the application configuration file.
      System.Configuration.Configuration config =
        ConfigurationManager.OpenExeConfiguration(
              ConfigurationUserLevel.None);

      Console.WriteLine(config.FilePath);

      if (config == null)
      {
        Console.WriteLine(
          "The configuration file does not exist.");
        Console.WriteLine(
         "Use OpenExeConfiguration to create the file.");
      }

      // Create a new configuration file by saving 
      // the application configuration to a new file.
      string appName = 
        Environment.GetCommandLineArgs()[0];

      string configFile =  string.Concat(appName, 
        ".2.config");
      config.SaveAs(configFile, ConfigurationSaveMode.Full);

      // Map the new configuration file.
      ExeConfigurationFileMap configFileMap = 
          new ExeConfigurationFileMap();
      configFileMap.ExeConfigFilename = configFile;

      // Get the mapped configuration file
     config = 
        ConfigurationManager.OpenMappedExeConfiguration(
          configFileMap, ConfigurationUserLevel.None);

      // Make changes to the new configuration file. 
      // This is to show that this file is the 
      // one that is used.
      string sectionName = "consoleSection";

      ConsoleSection customSection =
        (ConsoleSection)config.GetSection(sectionName);

      if (customSection == null)
      {
          customSection = new ConsoleSection();
          config.Sections.Add(sectionName, customSection);
      }
      else
          // Change the section configuration values.
          customSection =
              (ConsoleSection)config.GetSection(sectionName);

      customSection.ConsoleElement.BackgroundColor =
          ConsoleColor.Green;
      customSection.ConsoleElement.ForegroundColor =
          ConsoleColor.Red;

      // Save the configuration file.
      config.Save(ConfigurationSaveMode.Modified);

      // Force a reload of the changed section. This 
      // makes the new values available for reading.
      ConfigurationManager.RefreshSection(sectionName);

      // Set console properties using the 
      // configuration values contained in the 
      // new configuration file.
      Console.BackgroundColor =
        customSection.ConsoleElement.BackgroundColor;
      Console.ForegroundColor =
        customSection.ConsoleElement.ForegroundColor;
      Console.Clear();

      Console.WriteLine();
      Console.WriteLine("Using OpenMappedExeConfiguration.");
      Console.WriteLine("Configuration file is: {0}", 
        config.FilePath);
    }


  }
  #endregion

  #region
  //*** User Interaction Class ***//

  // Obtain user's input and provide feedback.
  // This class contains the application Main() function.
  // It calls the ConfigurationManager methods based 
  // on the user's selection.
  class ApplicationMain
  {
    // Display user's menu.
    public static void UserMenu()
    {
      string applicationName =
         Environment.GetCommandLineArgs()[0] + ".exe";
      StringBuilder buffer = new StringBuilder();

      buffer.AppendLine("Application: " + applicationName);
      buffer.AppendLine("Please, make your selection.");
      buffer.AppendLine("?    -- Display help.");
      buffer.AppendLine("Q,q  -- Exit the application.");
      buffer.Append("1    -- Use OpenExeConfiguration to get");
      buffer.AppendLine(" the roaming configuration.");
      buffer.Append("        Set console window colors");
      buffer.AppendLine(" to blue and yellow.");
      buffer.Append("2    -- Use GetSection to read or write");
      buffer.AppendLine(" the specified section.");
      buffer.Append("3    -- Use ConnectionStrings property");
      buffer.AppendLine(" to read the section.");
      buffer.Append("4    -- Use OpenExeConfiguration to get");
      buffer.AppendLine(" the application configuration.");
      buffer.Append("        Set console window colors");
      buffer.AppendLine(" to black and white.");
      buffer.Append("5    -- Use AppSettings property");
      buffer.AppendLine(" to read the section.");
      buffer.Append("6    -- Use OpenMappedExeConfiguration");
      buffer.AppendLine(" to get the specified configuration.");
      buffer.Append("        Set console window colors");
      buffer.AppendLine(" to green and red.");
      buffer.Append("7    -- Use OpenMappedMachineConfiguration");
      buffer.AppendLine(" to get the machine configuration.");

      Console.Write(buffer.ToString());
    }

    // Obtain user's input and provide
    // feedback.
    static void Main(string[] args)
    {
      // Define user selection string.
      string selection;

      // Get the name of the application.
      string appName = 
        Environment.GetCommandLineArgs()[0];


      // Get user selection.
      while (true)
      {

        UserMenu();
        Console.Write("> ");
        selection = Console.ReadLine();
        if (selection != string.Empty)
          break;
      }

      while (selection.ToLower() != "q")
      { 
        // Process user's input.
        switch (selection)
        {
          case "1":
            // Show how to use OpenExeConfiguration
            // using the configuration user level.
            UsingConfigurationManager.GetRoamingConfiguration();
            break;

          case "2":
            // Show how to use GetSection.
            UsingConfigurationManager.CreateAppSettings();
            break;

          case "3":
            // Show how to use ConnectionStrings.
            UsingConfigurationManager.ReadConnectionStrings();
            break;

          case "4":
            // Show how to use OpenExeConfiguration
            // using the configuration file path.
            UsingConfigurationManager.GetAppConfiguration();
            break;

          case "5":
            // Show how to use AppSettings.
            UsingConfigurationManager.ReadAppSettings();
            break;

          case "6":
            // Show how to use OpenMappedExeConfiguration.
            UsingConfigurationManager.MapExeConfiguration();
            break;

          case "7":
            // Show how to use OpenMappedMachineConfiguration.
            UsingConfigurationManager.MapMachineConfiguration();
            break;

          default:
            UserMenu();
            break;
        }
          Console.Write("> ");
          selection = Console.ReadLine();
      } 
    }
  }
  #endregion



Nell'esempio vengono utilizzati elementi simili a quelli illustrati nel file di configurazione seguente. Questi elementi vengono generati alla prima esecuzione dell'esempio.



<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <configSections>
        <section name="consoleSection" type="Samples.Aspnet.ConsoleSection, 
             ConfigurationManager_CS, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
    </configSections>
  <appSettings>
        <add key="NewKey0" value="Monday, March 30, 
             2009 1:36:33 PM" />
        <add key="NewKey1" value="Monday, March 30, 
             2009 1:36:40 PM" />
    </appSettings>
  <consoleSection>
        <consoleElement background="Black" foreground="White" />
    </consoleSection>
</configuration>



.NET Framework

Supportato in: 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Windows 7, Windows Vista SP1 o versione successiva, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (componenti di base del server non supportati), Windows Server 2008 R2 (componenti di base del server supportati con SP1 o versione successiva), Windows Server 2003 SP2

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.
Mostra: