Configuration Clase

Definición

Espacio de nombres:

System.Configuration

Ensamblado:

System.Configuration.ConfigurationManager.dll

Source:

Configuration.cs

Representa un archivo de configuración aplicable a un equipo, aplicación o recurso en concreto. Esta clase no puede heredarse.

C#

public sealed class Configuration

Herencia

Object

Configuration

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar la Configuration clase para tener acceso a los elementos del archivo de configuración.

C#

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Globalization;
using System.ComponentModel;
using System.Collections.Specialized;

// Before compiling this application, 
// remember to reference the System.Configuration assembly in your project. 
#region CustomSection class

// Define a custom section. This class is used to
// populate the configuration file.
// It creates the following custom section:
//  <CustomSection name="Contoso" url="http://www.contoso.com" port="8080" />.
public sealed class CustomSection : ConfigurationSection
{

    public CustomSection()
    {
    }

    [ConfigurationProperty("name",
     DefaultValue = "Contoso",
     IsRequired = true,
     IsKey = true)]
    public string Name
    {
        get
        {
            return (string)this["name"];
        }
        set
        {
            this["name"] = value;
        }
    }

    [ConfigurationProperty("url",
        DefaultValue = "http://www.contoso.com",
        IsRequired = true)]
    [RegexStringValidator(@"\w+:\/\/[\w.]+\S*")]
    public string Url
    {
        get
        {
            return (string)this["url"];
        }
        set
        {
            this["url"] = value;
        }
    }

    [ConfigurationProperty("port",
        DefaultValue = (int)8080,
        IsRequired = false)]
    [IntegerValidator(MinValue = 0,
        MaxValue = 8080, ExcludeRange = false)]
    public int Port
    {
        get
        {
            return (int)this["port"];
        }
        set
        {
            this["port"] = value;
        }
    }
}

#endregion

#region Using Configuration Class
class UsingConfigurationClass
{


    // Show how to create an instance of the Configuration class
    // that represents this application configuration file.  
    static void CreateConfigurationFile()
    {
        try
        {

            // Create a custom configuration section.
            CustomSection customSection = new CustomSection();

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

            // Create the custom section entry  
            // in <configSections> group and the 
            // related target section in <configuration>.
            if (config.Sections["CustomSection"] == null)
            {
                config.Sections.Add("CustomSection", customSection);
            }

            // Create and add an entry to appSettings section.
            
            string conStringname="LocalSqlServer";
            string conString = @"data source=.\SQLEXPRESS;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|aspnetdb.mdf;User Instance=true";
            string providerName="System.Data.SqlClient";

            ConnectionStringSettings connStrSettings = new ConnectionStringSettings();
            connStrSettings.Name = conStringname;
            connStrSettings.ConnectionString= conString;
            connStrSettings.ProviderName = providerName;

            config.ConnectionStrings.ConnectionStrings.Add(connStrSettings);
            
            // Add an entry to appSettings section.
            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.
            customSection.SectionInformation.ForceSave = true;
            config.Save(ConfigurationSaveMode.Full);

            Console.WriteLine("Created configuration file: {0}",
                config.FilePath);
        }
        catch (ConfigurationErrorsException err)
        {
            Console.WriteLine("CreateConfigurationFile: {0}", err.ToString());
        }
    }

    // Show how to use the GetSection(string) method.
    static void GetCustomSection()
    {
        try
        {

            CustomSection customSection;

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

            customSection =
                config.GetSection("CustomSection") as CustomSection;

            Console.WriteLine("Section name: {0}", customSection.Name);
            Console.WriteLine("Url: {0}", customSection.Url);
            Console.WriteLine("Port: {0}", customSection.Port);
        }
        catch (ConfigurationErrorsException err)
        {
            Console.WriteLine("Using GetSection(string): {0}", err.ToString());
        }
    }


    // Show how to use different modalities to save 
    // a configuration file.
    static void SaveConfigurationFile()
    {
        try
        {

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

            // Save the full configuration file and force save even if the file was not modified.
            config.SaveAs("MyConfigFull.config", ConfigurationSaveMode.Full, true);
            Console.WriteLine("Saved config file as MyConfigFull.config using the mode: {0}",
                ConfigurationSaveMode.Full.ToString());

            config =
                    ConfigurationManager.OpenExeConfiguration(
                    ConfigurationUserLevel.None) as Configuration;

            // Save only the part of the configuration file that was modified. 
            config.SaveAs("MyConfigModified.config", ConfigurationSaveMode.Modified, true);
            Console.WriteLine("Saved config file as MyConfigModified.config using the mode: {0}",
                ConfigurationSaveMode.Modified.ToString());

            config =
                    ConfigurationManager.OpenExeConfiguration(
                    ConfigurationUserLevel.None) as Configuration;

            // Save the full configuration file.
            config.SaveAs("MyConfigMinimal.config");
            Console.WriteLine("Saved config file as MyConfigMinimal.config using the mode: {0}",
                ConfigurationSaveMode.Minimal.ToString());
        }
        catch (ConfigurationErrorsException err)
        {
            Console.WriteLine("SaveConfigurationFile: {0}", err.ToString());
        }
    }

    // Show how use the AppSettings and ConnectionStrings 
    // properties.
    static void GetSections(string section)
    {
        try
        {

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

            // Get the selected section.
            switch (section)
            {
                case "appSettings":
                    try
                    {
                        AppSettingsSection appSettings =
                            config.AppSettings as AppSettingsSection;
                        Console.WriteLine("Section name: {0}",
                                appSettings.SectionInformation.SectionName);

                        // Get the AppSettings section elements.
                        Console.WriteLine();
                        Console.WriteLine("Using AppSettings property.");
                        Console.WriteLine("Application settings:");
                        // Get the KeyValueConfigurationCollection 
                        // from the configuration.
                        KeyValueConfigurationCollection settings =
                          config.AppSettings.Settings;

                        // Display each KeyValueConfigurationElement.
                        foreach (KeyValueConfigurationElement keyValueElement in settings)
                        {
                            Console.WriteLine("Key: {0}", keyValueElement.Key);
                            Console.WriteLine("Value: {0}", keyValueElement.Value);
                            Console.WriteLine();
                        }
                    }
                    catch (ConfigurationErrorsException e)
                    {
                        Console.WriteLine("Using AppSettings property: {0}",
                            e.ToString());
                    }
                    break;

                case "connectionStrings":
                    ConnectionStringsSection
                        conStrSection =
                        config.ConnectionStrings as ConnectionStringsSection;
                    Console.WriteLine("Section name: {0}",
                        conStrSection.SectionInformation.SectionName);

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

                            // Get the collection elements.
                            foreach (ConnectionStringSettings connection in
                              conStrSection.ConnectionStrings)
                            {
                                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);
                            }
                        }
                    }
                    catch (ConfigurationErrorsException e)
                    {
                        Console.WriteLine("Using ConnectionStrings property: {0}",
                            e.ToString());
                    }
                    break;

                default:
                    Console.WriteLine(
                        "GetSections: Unknown section (0)", section);
                    break;
            }
        }
        catch (ConfigurationErrorsException err)
        {
            Console.WriteLine("GetSections: (0)", err.ToString());
        }
    }

    // Show how to use the Configuration object properties 
    // to obtain configuration file information.
    static void GetConfigurationInformation()
    {
        try
        {

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

            Console.WriteLine("Reading configuration information:");

            ContextInformation evalContext =
                config.EvaluationContext as ContextInformation;
            Console.WriteLine("Machine level: {0}",
                evalContext.IsMachineLevel.ToString());
                    
            string filePath = config.FilePath;
            Console.WriteLine("File path: {0}", filePath);
             
            bool hasFile = config.HasFile;
            Console.WriteLine("Has file: {0}", hasFile.ToString());

            ConfigurationSectionGroupCollection
                groups = config.SectionGroups;
            Console.WriteLine("Groups: {0}", groups.Count.ToString());
            foreach (ConfigurationSectionGroup group in groups)
            {
                Console.WriteLine("Group Name: {0}", group.Name);
               // Console.WriteLine("Group Type: {0}", group.Type);
            }

            ConfigurationSectionCollection
                sections = config.Sections;
            Console.WriteLine("Sections: {0}", sections.Count.ToString());
        }
        catch (ConfigurationErrorsException err)
        {
            Console.WriteLine("GetConfigurationInformation: {0}",err.ToString());
        }
    }

#endregion 

#region Application Main
    //*** 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("Make your selection.");
            buffer.AppendLine("?    -- Display help.");
            buffer.AppendLine("Q,q  -- Exit the application.");
            
            buffer.Append("1    -- Instantiate the");
            buffer.AppendLine(" Configuration class.");

            buffer.Append("2    -- Use GetSection(string) to read ");
            buffer.AppendLine(" a custom section.");
            
            buffer.Append("3    -- Use SaveAs methods");
            buffer.AppendLine(" to save the configuration file.");

            buffer.Append("4    -- Use AppSettings property to read");
            buffer.AppendLine(" the appSettings section.");
            buffer.Append("5    -- Use ConnectionStrings property to read");
            buffer.AppendLine(" the connectionStrings section.");

            buffer.Append("6    -- Use Configuration class properties");
            buffer.AppendLine(" to obtain configuration information.");

            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 (!string.IsNullOrEmpty(selection))
                    break;
            }

            while (selection.ToLower() != "q")
            {
                // Process user's input.
                switch (selection)
                {
                    case "1":
                        // Show how to create an instance of the Configuration class.
                        CreateConfigurationFile();
                        break;

                    case "2":
                        // Show how to use GetSection(string) method.
                        GetCustomSection();
                        break;

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

                    case "4":
                        // Show how to use the AppSettings property.
                        GetSections("appSettings");
                        break;

                    case "5":
                        // Show how to use the ConnectionStrings property.
                        GetSections("connectionStrings");
                        break;

                    case "6":
                        // Show how to obtain configuration file information.
                        GetConfigurationInformation();
                        break;

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

}

Comentarios

Los valores de configuración se almacenan en una jerarquía de archivos de configuración. La Configuration instancia de clase representa la vista combinada de los valores de configuración de todos los archivos de configuración que se aplican a una entidad física específica, como un equipo o a una entidad lógica, como una aplicación o un sitio web. La entidad lógica puede existir en el equipo local o en un servidor remoto. Para obtener información sobre los archivos de configuración, vea Configuring Apps and ASP.NET Configuration Files.

Cuando no existe ningún archivo de configuración para una entidad especificada, el Configuration objeto representa los valores de configuración predeterminados definidos por el archivo Machine.config.

Puede obtener un Configuration objeto mediante las siguientes clases:

• La ConfigurationManager clase , si la entidad es una aplicación cliente.

• La WebConfigurationManager clase , si la entidad es una aplicación web.

Los nombres de los métodos que devuelven un Configuration objeto comienzan por "Open".

También puede generar un archivo de configuración que represente los valores de configuración de un Configuration objeto . Para ello, use uno de estos métodos:

• Llame al Save método para crear un nuevo archivo de configuración.

• Llame al SaveAs método para generar un nuevo archivo de configuración en otra ubicación.

Los nombres de los métodos que crean archivos de configuración comienzan por "Guardar".

Nota

Para habilitar el acceso a las opciones de configuración en un equipo remoto, use la herramienta de línea de comandos Aspnet_regiis. Para obtener más información sobre esta herramienta, consulte ASP.NET herramienta de registro de IIS (Aspnet_regiis.exe). Para obtener información sobre cómo crear y acceder a opciones de configuración personalizadas distintas de las secciones intrínsecas incluidas en .NET Framework, consulte ConfigurationSection.

Notas a los desarrolladores de herederos

La Configuration clase proporciona acceso mediante programación para editar archivos de configuración. Use uno de los métodos "Open" proporcionados por la WebConfigurationManager clase para aplicaciones web o por la ConfigurationManager clase para las aplicaciones cliente. Estos métodos devuelven un Configuration objeto , que a su vez proporciona los métodos y propiedades que controlan los archivos de configuración subyacentes. Puede acceder a estos archivos para leer o escribir información de configuración.

Use el GetSection(String) método o el GetSectionGroup(String) método para leer la información de configuración. Tenga en cuenta que el usuario o proceso que lee debe tener los permisos siguientes:

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

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

Si la aplicación necesita acceso de solo lectura a su propia configuración, se recomienda usar las GetSection sobrecargas de método para las aplicaciones web. Para la aplicación cliente, use el GetSection(String) método .

Estos métodos proporcionan acceso a los valores de configuración almacenados en caché para la aplicación actual, que tiene un mejor rendimiento que la Configuration clase .

Nota: Si usa un método estático GetSection que toma un parámetro path, el parámetro path debe hacer referencia a la aplicación en la que se ejecuta el código; de lo contrario, se omite el parámetro y se devuelve la información de configuración de la aplicación que se está ejecutando actualmente.

Use uno de los Save métodos para escribir información de configuración. Tenga en cuenta que el usuario o proceso que escribe debe tener los permisos siguientes:

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

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

Propiedades

AppSettings	Obtiene la sección de configuración del objeto AppSettingsSection que se aplica a este objeto Configuration.
AssemblyStringTransformer	Especifica un delegado de función que se usa para transformar las cadenas de ensamblado en archivos de configuración.
ConnectionStrings	Obtiene un objeto de sección de configuración ConnectionStringsSection que se aplica a este objeto Configuration.
EvaluationContext	Obtiene el objeto ContextInformation para el objeto Configuration.
FilePath	Obtiene la ruta de acceso física al archivo de configuración que representa este objeto Configuration.
HasFile	Obtiene un valor que indica si existe un archivo para el recurso representado por este objeto Configuration.
Locations	Obtiene las ubicaciones que hay definidas en este objeto Configuration.
NamespaceDeclared	Obtiene o establece un valor que indica si el archivo de configuración tiene un espacio de nombres XML.
RootSectionGroup	Obtiene el objeto raíz ConfigurationSectionGroup para este objeto Configuration.
SectionGroups	Obtiene una colección de los grupos de sección que define esta configuración.
Sections	Obtiene una colección de las secciones definidas por este objeto Configuration.
TargetFramework	Obtiene o establece la versión de destino de .NET cuando se destina una versión anterior a la actual.
TypeStringTransformer	Especifica un delegado de función que se usa para transformar las cadenas de tipo en archivos de configuración.

Métodos

GetSection(String)	Devuelve el objeto ConfigurationSection especificado.
GetSectionGroup(String)	Obtiene el objeto ConfigurationSectionGroup especificado.
Save()	Escribe en el archivo de configuración XML actual los valores de configuración que incluye este objeto Configuration.
Save(ConfigurationSaveMode, Boolean)	Escribe en el archivo de configuración XML actual los valores de configuración que incluye este objeto Configuration.
Save(ConfigurationSaveMode)	Escribe en el archivo de configuración XML actual los valores de configuración que incluye este objeto Configuration.
SaveAs(String, ConfigurationSaveMode, Boolean)	Escribe en el archivo de configuración XML especificado los valores de configuración que incluye este objeto Configuration.
SaveAs(String, ConfigurationSaveMode)	Escribe en el archivo de configuración XML especificado los valores de configuración que incluye este objeto Configuration.
SaveAs(String)	Escribe en el archivo de configuración XML especificado los valores de configuración que incluye este objeto Configuration.

Se aplica a

Consulte también

• ConfigurationSection
• ConfigurationManager
• WebConfigurationManager
• Administrar sitios web de ASP.NET
• Archivos de configuración
• Archivos de configuración de ASP.NET