(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Configuration-Klasse

Stellt eine Konfigurationsdatei dar, die auf einen bestimmten Computer, eine bestimmte Anwendung oder Ressource anwendbar ist. Die Klasse erlaubt keine Vererbung.

System.Object
  System.Configuration.Configuration

Namespace:  System.Configuration
Assembly:  System.Configuration (in System.Configuration.dll)

public sealed class Configuration

Der Configuration-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche EigenschaftAppSettingsRuft den Konfigurationsabschnitt des AppSettingsSection-Objekts ab, der auf dieses Configuration-Objekt angewendet wird.
Öffentliche EigenschaftAssemblyStringTransformerGibt einen Funktionsdelegaten an, der verwendet wird, um Assemblyzeichenfolgen in Konfigurationsdateien zu transformieren.
Öffentliche EigenschaftConnectionStringsRuft ein ConnectionStringsSection-Konfigurationsabschnittsobjekt ab, das auf dieses Configuration-Objekt angewendet wird.
Öffentliche EigenschaftEvaluationContextRuft das ContextInformation-Objekt für das Configuration-Objekt ab.
Öffentliche EigenschaftFilePathRuft den physischen Pfad zu der Konfigurationsdatei ab, die dieses Configuration-Objekt darstellt.
Öffentliche EigenschaftHasFileRuft einen Wert ab, der angibt, ob eine Datei für die von diesem Configuration-Objekt dargestellte Ressource vorhanden ist.
Öffentliche EigenschaftLocationsRuft die in diesem Configuration-Objekts definierten Speicherorte ab.
Öffentliche EigenschaftNamespaceDeclaredRuft einen Wert ab, der angibt, ob die Konfigurationsdatei über einen XML-Namespace verfügt, oder legt diesen fest.
Öffentliche EigenschaftRootSectionGroupRuft die Stamm-ConfigurationSectionGroup für dieses Configuration-Objekt ab.
Öffentliche EigenschaftSectionGroupsRuft eine Auflistung der von dieser Konfiguration definierten Abschnittsgruppen ab.
Öffentliche EigenschaftSectionsRuft eine Auflistung der von diesem Configuration-Objekt definierten Abschnitte ab.
Öffentliche EigenschaftTargetFrameworkGibt die verwendete Zielversion von .NET Framework an, wenn eine frühere als die aktuelle Version verwendet werden soll.
Öffentliche EigenschaftTypeStringTransformerGibt einen Funktionsdelegaten an, der verwendet wird, um Typzeichenfolgen in Konfigurationsdateien zu transformieren.
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeEquals(Object)Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. (Von Object geerbt.)
Öffentliche MethodeGetHashCodeFungiert als die Standardhashfunktion. (Von Object geerbt.)
Öffentliche MethodeGetSectionGibt das angegebene ConfigurationSection-Objekt zurück.
Öffentliche MethodeGetSectionGroupRuft das angegebene ConfigurationSectionGroup-Objekt ab.
Öffentliche MethodeGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeSave()Schreibt die in diesem Configuration-Objekt enthaltenen Konfigurationseinstellungen in die aktuelle XML-Konfigurationsdatei.
Öffentliche MethodeSave(ConfigurationSaveMode)Schreibt die in diesem Configuration-Objekt enthaltenen Konfigurationseinstellungen in die aktuelle XML-Konfigurationsdatei.
Öffentliche MethodeSave(ConfigurationSaveMode, Boolean)Schreibt die in diesem Configuration-Objekt enthaltenen Konfigurationseinstellungen in die aktuelle XML-Konfigurationsdatei.
Öffentliche MethodeSaveAs(String)Schreibt die in diesem Configuration-Objekt enthaltenen Konfigurationseinstellungen in die angegebene XML-Konfigurationsdatei.
Öffentliche MethodeSaveAs(String, ConfigurationSaveMode)Schreibt die in diesem Configuration-Objekt enthaltenen Konfigurationseinstellungen in die angegebene XML-Konfigurationsdatei.
Öffentliche MethodeSaveAs(String, ConfigurationSaveMode, Boolean)Schreibt die in diesem Configuration-Objekt enthaltenen Konfigurationseinstellungen in die angegebene XML-Konfigurationsdatei.
Öffentliche MethodeToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Zum Seitenanfang

Konfigurationseinstellungen werden in einer Hierarchie von Konfigurationsdateien gespeichert. Die Configuration-Klasseninstanz stellt die zusammengeführte Ansicht der Konfigurationseinstellungen aller Konfigurationsdateien dar, die auf eine bestimmte physische Einheit, z. B. einen Computer, oder auf eine logische Einheit, z. B. eine Anwendung oder eine Website, angewendet werden. Die logische Entität kann sich auf dem lokalen Computer oder auf einem Remoteserver befinden. Weitere Informationen zu den Konfigurationsdateien finden Sie unter Konfigurationsdateien und ASP.NET Configuration Files.

Wenn zur angegebenen Entität keine Konfigurationsdatei vorhanden ist, stellt das Configuration-Objekt die mit der Datei Machine.config definierten Standardkonfigurationseinstellungen dar.

Sie können mit den folgenden Klassen ein Configuration-Objekt abrufen:

Die Namen der Methoden, die ein Configuration-Objekt zurückgeben, beginnen mit "Open".

Sie können auch eine Konfigurationsdatei generieren, die die Konfigurationseinstellungen in einem Configuration-Objekt darstellt. Verwenden Sie hierzu eine der folgenden Methoden:

  • Rufen Sie die Save-Methode auf, um eine neue Konfigurationsdatei zu erstellen.

  • Rufen Sie die SaveAs-Methode auf, um eine neue Konfigurationsdatei an einem anderen Speicherort zu generieren.

Die Namen der Methoden, die Konfigurationsdateien erstellen, beginnen mit "Save".

HinweisHinweis

Um den Zugriff auf Konfigurationseinstellungen auf einem Remotecomputer zu ermöglichen, verwenden Sie das Befehlszeilentool Aspnet_regiis. Weitere Informationen zu diesem Tool finden Sie unter ASP.NET IIS Registration Tool (Aspnet_regiis.exe). Weitere Informationen über das Erstellen von und Zugreifen auf benutzerdefinierte Konfigurationseinstellungen, bei denen es sich nicht um die in .NET Framework enthaltenen systeminternen Abschnitte handelt, finden Sie unter ConfigurationSection.

Hinweise zur Implementierung

Die Configuration-Klasse ermöglicht den programmgesteuerten Zugriff für das Bearbeiten von Konfigurationsdateien. Sie verwenden eine der Open-Methoden, die von der WebConfigurationManager-Klasse für Webanwendungen oder von der ConfigurationManager-Klasse für Clientanwendungen bereitgestellt werden. Diese Methoden geben ein Configuration-Objekt zurück, das wiederum die zum Behandeln der zugrunde liegenden Konfigurationsdateien erforderlichen Methoden und Eigenschaften bereitstellt. Sie können auf diese Dateien zum Lesen oder Schreiben von Konfigurationsinformationen zugreifen.

Sie verwenden die GetSection-Methode oder GetSectionGroup-Methode, wenn Sie die Konfigurationsinformationen lesen möchten. Beachten Sie, dass der lesende Benutzer oder Prozess über die folgenden Berechtigungen verfügen muss:

  • Leseberechtigung für die Konfigurationsdatei auf der aktuellen Ebene der Konfigurationshierarchie.

  • Leseberechtigungen für alle übergeordneten Konfigurationsdateien.

Wenn für die Anwendung der schreibgeschützte Zugriff auf die eigene Konfiguration erforderlich ist, wird empfohlen, im Falle von Webanwendungen die überladenen GetSection-Methoden zu verwenden. Bei Clientanwendungen verwenden Sie die GetSection-Methode.

Diese Methoden stellen den Zugriff auf die zwischengespeicherten Konfigurationswerte für die aktuelle Anwendung bereit. Die Leistung ist dabei besser als bei der Configuration-Klasse.

HinweisHinweis

Wenn Sie eine statische GetSection-Methode verwenden, die einen Pfadparameter annimmt, muss sich der Pfadparameter auf die Anwendung beziehen, in der der Code ausgeführt wird. Andernfalls wird der Parameter ignoriert, und es werden Konfigurationsinformationen für die derzeit ausgeführte Anwendung zurückgegeben.

Verwenden Sie eine der Save-Methoden, um Konfigurationsinformationen zu schreiben. Beachten Sie, dass der schreibende Benutzer oder Prozess über die folgenden Berechtigungen verfügen muss:

  • Schreibberechtigung für die Konfigurationsdatei und das Verzeichnis auf der aktuellen Ebene der Konfigurationshierarchie.

  • Leseberechtigungen für alle Konfigurationsdateien.

Im folgenden Codebeispiel wird veranschaulicht, wie die Configuration-Klasse verwendet wird, um auf Konfigurationsdateielemente zuzugreifen.


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

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft