Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Configuration classe

 

Date de publication : novembre 2016

Représente un fichier de configuration qui s’applique à un ordinateur particulier, une application ou une ressource. Cette classe ne peut pas être héritée.

Espace de noms:   System.Configuration
Assembly:  System.Configuration (dans System.Configuration.dll)

System.Object
  System.Configuration.Configuration

public sealed class Configuration

NomDescription
System_CAPS_pubpropertyAppSettings

Obtient la AppSettingsSection section configuration de l’objet qui s’applique à ce Configuration objet.

System_CAPS_pubpropertyAssemblyStringTransformer

Spécifie un délégué de fonction utilisé pour transformer des chaînes d’assembly dans les fichiers de configuration.

System_CAPS_pubpropertyConnectionStrings

Obtient un ConnectionStringsSection objet de section de configuration qui s’applique à ce Configuration objet.

System_CAPS_pubpropertyEvaluationContext

Obtient l'objet ContextInformation pour l'objet Configuration.

System_CAPS_pubpropertyFilePath

Obtient le chemin d’accès physique au fichier de configuration représenté par cet Configuration objet.

System_CAPS_pubpropertyHasFile

Obtient une valeur qui indique si un fichier existe pour la ressource représentée par cet Configuration objet.

System_CAPS_pubpropertyLocations

Obtient les emplacements définis dans cette Configuration objet.

System_CAPS_pubpropertyNamespaceDeclared

Obtient ou définit une valeur qui indique si le fichier de configuration a un espace de noms XML.

System_CAPS_pubpropertyRootSectionGroup

Obtient la racine ConfigurationSectionGroup pour ce Configuration objet.

System_CAPS_pubpropertySectionGroups

Obtient une collection des groupes de sections définis par cette configuration.

System_CAPS_pubpropertySections

Obtient une collection des sections définies par cet Configuration objet.

System_CAPS_pubpropertyTargetFramework

Spécifie la version ciblée du .NET Framework est une version précédemment que celle en cours est ciblée.

System_CAPS_pubpropertyTypeStringTransformer

Spécifie un délégué de fonction utilisé pour transformer des chaînes de type dans les fichiers de configuration.

NomDescription
System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetSection(String)

Retourne l'objet ConfigurationSection spécifié.

System_CAPS_pubmethodGetSectionGroup(String)

Obtient le texte spécifié ConfigurationSectionGroup objet.

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodSave()

Écrit les paramètres de configuration contenus dans cette Configuration objet dans le fichier de configuration XML actuel.

System_CAPS_pubmethodSave(ConfigurationSaveMode)

Écrit les paramètres de configuration contenus dans cette Configuration objet dans le fichier de configuration XML actuel.

System_CAPS_pubmethodSave(ConfigurationSaveMode, Boolean)

Écrit les paramètres de configuration contenus dans cette Configuration objet dans le fichier de configuration XML actuel.

System_CAPS_pubmethodSaveAs(String)

Écrit les paramètres de configuration contenus dans cette Configuration objet dans le fichier de configuration XML spécifié.

System_CAPS_pubmethodSaveAs(String, ConfigurationSaveMode)

Écrit les paramètres de configuration contenus dans cette Configuration objet dans le fichier de configuration XML spécifié.

System_CAPS_pubmethodSaveAs(String, ConfigurationSaveMode, Boolean)

Écrit les paramètres de configuration contenus dans cette Configuration objet dans le fichier de configuration XML spécifié.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

Paramètres de configuration sont stockés dans une hiérarchie de fichiers de configuration. Le Configuration instance de classe représente l’affichage fusionné des paramètres de configuration à partir de tous les fichiers de configuration qui s’appliquent à une entité physique spécifique, tel qu’un ordinateur, ou à une entité logique, telle qu’une application ou un site Web. L’entité logique peut exister sur l’ordinateur local ou sur un serveur distant. Pour plus d’informations sur les fichiers de configuration, consultez Configuration des applications à l'aide de fichiers de configuration et ASP.NET Configuration Files.

Lorsque aucun fichier de configuration n’existe pour une entité spécifiée, le Configuration objet représente les paramètres de configuration par défaut, tel que défini dans le fichier Machine.config.

Vous pouvez obtenir un Configuration à l’aide des classes suivantes :

Les noms des méthodes qui retournent un Configuration objet commence par « Ouverte ».

Vous pouvez également générer un fichier de configuration qui représente les paramètres de configuration dans un Configuration objet. Pour ce faire, utilisez l'une des méthodes suivantes :

  • Appelez le Save pour créer un nouveau fichier de configuration.

  • Appelez le SaveAs méthode permettant de générer un nouveau fichier de configuration à un autre emplacement.

Les noms des méthodes qui créent des fichiers de configuration commencent par « Enregistrer ».

System_CAPS_noteRemarque

Pour activer l’accès aux paramètres de configuration sur un ordinateur distant, utilisez l’outil de ligne de commande Aspnet_regiis. Pour plus d’informations sur cet outil, consultez ASP.NET IIS Registration Tool (Aspnet_regiis.exe). Pour plus d’informations sur la création et l’accès aux paramètres de configuration personnalisés autres que les sections intrinsèques incluses dans le .NET Framework, consultez ConfigurationSection.

Remarques à l’attention des implémenteurs :

La Configuration classe fournit un accès par programme pour modifier les fichiers de configuration. Vous utilisez une des méthodes « Open » fournies par la WebConfigurationManager classe pour les applications Web ou par la ConfigurationManager classe pour les applications clientes. Ces méthodes retournent un Configuration objet, qui à son tour fournit les méthodes et propriétés qui gèrent les fichiers de configuration sous-jacents. Vous pouvez accéder à ces fichiers pour lire ou écrire des informations de configuration.

Vous utilisez la GetSection méthode ou GetSectionGroup méthode pour lire les informations de configuration. Notez que l’utilisateur ou le processus qui lit doit avoir les autorisations suivantes :

  • Autorisation de lecture sur le fichier de configuration au niveau de la hiérarchie de configuration en cours.

  • Autorisations de lecture sur tous les fichiers de configuration.

Si votre application requiert un accès en lecture seule à sa propre configuration, il est recommandé d’utiliser la GetSection des surcharges de méthode pour les applications Web. Pour l’application cliente, utilisez la GetSection méthode.

Ces méthodes donnent accès aux valeurs de configuration mises en cache pour l’application actuelle, qui offre de meilleures performances que la Configuration classe.

System_CAPS_noteRemarque

Si vous utilisez statique GetSection méthode qui accepte un paramètre de chemin d’accès, le paramètre de chemin d’accès doit faire référence à l’application dans laquelle le code s’exécute, le paramètre est ignoré et les informations de configuration de l’application en cours d’exécution sont renvoyées.

Vous utilisez une de le Save méthodes pour écrire les informations de configuration. Notez que l’utilisateur ou le processus qui écrit doit avoir les autorisations suivantes :

  • Autorisation d’écriture sur le fichier de configuration et le répertoire au niveau de la hiérarchie de configuration en cours.

  • Autorisations de lecture sur tous les fichiers de configuration.

L’exemple de code suivant montre comment utiliser la Configuration classe pour accéder aux éléments de fichier de configuration.

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 (selection != string.Empty)
                    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

}

.NET Framework
Disponible depuis 2.0

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: