¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original

ConfigurationManager (Clase)

Proporciona acceso a los archivos de configuración para las aplicaciones cliente. Esta clase no puede heredarse.

System.Object
  System.Configuration.ConfigurationManager

Espacio de nombres:  System.Configuration
Ensamblado:  System.Configuration (en System.Configuration.dll)

public static class ConfigurationManager

El tipo ConfigurationManager expone los siguientes miembros.

  NombreDescripción
Propiedad públicaMiembro estáticoAppSettingsObtiene los datos AppSettingsSection para la configuración predeterminada de la aplicación actual.
Propiedad públicaMiembro estáticoConnectionStringsObtiene los datos ConnectionStringsSection para la configuración predeterminada de la aplicación actual.
Arriba

  NombreDescripción
Método públicoMiembro estáticoGetSectionRecupera una sección de configuración especificada para la configuración predeterminada de la aplicación actual.
Método públicoMiembro estáticoOpenExeConfiguration(ConfigurationUserLevel)Abre el archivo de configuración para la aplicación actual como un objeto Configuration.
Método públicoMiembro estáticoOpenExeConfiguration(String)Abre el archivo de configuración de cliente especificado como un objeto Configuration.
Método públicoMiembro estáticoOpenMachineConfigurationAbre el archivo de configuración del equipo como un objeto Configuration en el equipo actual.
Método públicoMiembro estáticoOpenMappedExeConfigurationAbre el archivo de configuración de cliente especificado como un objeto Configuration que utiliza la asignación de archivos y el nivel de usuario indicados.
Método públicoMiembro estáticoOpenMappedMachineConfigurationAbre el archivo de configuración del equipo como un objeto Configuration que utiliza la asignación de archivos especificada.
Método públicoMiembro estáticoRefreshSectionActualiza la sección con nombre para que se vuelva a leer desde el disco la próxima vez que se recupere.
Arriba

La clase ConfigurationManager permite obtener acceso a la información de configuración de usuarios, aplicaciones y equipos. Esta clase reemplaza la clase ConfigurationSettings, que queda obsoleto.

NotaNota

El nombre y ubicación del archivo de configuración de la aplicación dependen del host de la aplicación. Para obtener más información, vea Application Configuration Files.

Para controlar la información de configuración, se pueden utilizar los tipos System.Configuration integrados o derivados de ellos. El uso de estos tipos permite trabajar directamente con la información de configuración y ampliar los archivos de configuración de modo que incluyan la información personalizada.

La clase ConfigurationManager incluye miembros que permiten llevar a cabo las tareas siguientes:

  • Leer una sección de un archivo de configuración. Para obtener acceso a la información de configuración, llame al método GetSection. Para algunas secciones como appSettings y connectionStrings, utilice las clases de AppSettings y ConnectionStrings. Estos miembros llevan a cabo operaciones de sólo lectura, utilizan una única instancia almacenada en memoria caché de la configuración y reconocen los multiprocesos.

  • Leer y escribir totalmente archivos de configuración. La aplicación puede leer y escribir las opciones de configuración en cualquier nivel, para sí o para otras aplicaciones o equipos, de forma local o remota. Utilice uno de los métodos proporcionados por la clase ConfigurationManager para abrir un archivo de configuración como SampleApp.exe.config. Estos métodos devuelven un objeto Configuration que expone a su vez métodos y propiedades que se pueden utilizar para trabajar con archivos de configuración asociados. Los métodos llevan a cabo operaciones de lectura o escritura y crean los datos de configuración cada vez que se escribe en un archivo.

  • Compatibilizar tareas de configuración. Para compatibilizar las diversas tareas de configuración, se utilizan los tipos siguientes:

    Además de trabajar con la información de configuración existente, se pueden crear elementos de configuración personalizados, y trabajar con ellos, extendiendo los tipos de configuración integrados como las clases ConfigurationElement, ConfigurationElementCollection, ConfigurationProperty y ConfigurationSection. Para obtener un ejemplo sobre la forma de extender mediante programación un tipo de configuración integrado, vea ConfigurationSection. Para obtener un ejemplo de cómo extender un tipo de configuración integrado que utilice el modelo basado en atributos, vea ConfigurationElement.

Notas para los implementadores

La clase Configuration permite el acceso mediante programación para modificar los archivos de configuración. Se utiliza uno de los métodos Open proporcionados por ConfigurationManager. Estos métodos devuelven un objeto Configuration que, a su vez, proporciona los métodos y propiedades necesarios para controlar los archivos de configuración subyacentes. Puede tener acceso de lectura o escritura a estos archivos.

Para leer los archivos de configuración, utilice GetSection o GetSectionGroup para leer la información de configuración. El usuario o el proceso que realice la lectura debe tener los permisos siguientes:

  • Permiso de lectura en el archivo de configuración en el nivel actual de jerarquía de configuración.

  • Permisos de lectura en todos los archivos de configuración primarios.

Si la aplicación necesita acceso de sólo lectura a su propia configuración, se recomienda utilizar el método GetSection. Este método proporciona acceso a los valores de configuración almacenados en memoria caché para la aplicación actual, lo que supone un rendimiento mejor que el de la clase Configuration.

Para escribir en los archivos de configuración, utilice uno de los métodos Save. El usuario o el proceso que realice la escritura debe tener los permisos siguientes:

  • Permiso de escritura en el archivo de configuración y el directorio del nivel actual de jerarquía de configuración.

  • Permisos de lectura en todos los archivos de configuración.

Hay un proyecto de sitio web de Visual Studio con código fuente disponible para acompañar este tema: Download.

En el ejemplo siguiente se muestra cómo utilizar la clase ConfigurationManager en una aplicación de consola. El código muestra lo siguiente:

  • Cómo tener acceso a la sección de configuración appSettings. Si la sección no existe, se crea y agrega al archivo de configuración. El ejemplo crea el archivo de configuración de la aplicación si no existe.

  • Cómo tener acceso al archivo Machine.config para obtener información como la cadena de conexión predeterminada, si se ha definido, y las secciones que están configuradas actualmente.

    NotaNota

    Al crear un proyecto, asegúrese de agregar una referencia al ensamblado System.Configuration. Este ensamblado contiene la clase 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



El ejemplo funciona con los elementos que son similares a los mostrados en el archivo de configuración siguiente. Estos elementos se generan la primera vez que se ejecuta el ejemplo.



<?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

Compatible con: 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft