Beibehalten von Anwendungseinstellungen in .NET Framework

Veröffentlicht: 06. Aug 2002 | Aktualisiert: 22. Jun 2004
Von Jeff Danner

Speichern der Anwendungseinstellungen zur Laufzeit in Microsoft .NET Framework in der Registrierung oder Serialisieren der Einstellungen in eine Konfigurationsdatei. Dieser Artikel enthält auch Links zu englischsprachigen Seiten.

Auf dieser Seite

Einführung Einführung
Voraussetzungen für das Speichern von Anwendungseinstellungen Voraussetzungen für das Speichern von Anwendungseinstellungen
Verwenden der Registrierung zum Speichern von Daten Verwenden der Registrierung zum Speichern von Daten
Speichern von Daten in der Registrierung Speichern von Daten in der Registrierung
Abrufen von Daten aus der Registrierung Abrufen von Daten aus der Registrierung
Erstellen einer benutzerdefinierten Anwendungskonfigurationsklasse Erstellen einer benutzerdefinierten Anwendungskonfigurationsklasse
Verwenden der Anwendungseinstellungsklasse mit der Anwendung Verwenden der Anwendungseinstellungsklasse mit der Anwendung
Laden gespeicherter Anwendungseinstellungen Laden gespeicherter Anwendungseinstellungen
Speichern von Anwendungseinstellungen Speichern von Anwendungseinstellungen
Schlussfolgerung  Schlussfolgerung

Einführung

Das Speichern von Anwendungseinstellungen ist eine häufig benötigte Aufgabe. In der Vergangenheit wurden die Einstellungen in einer INI-Datei oder in der Registrierung abgelegt. Mit Microsoft® .NET Framework haben Sie darüber hinaus die Möglichkeit, die Anwendungseinstellungen in eine XML-Datei zu serialisieren und diese Einstellungen problemlos zu aktualisieren und abzurufen.

Microsoft Visual Studio® .NET verwendet die System.Configuration.AppSettingsReader-Klasse zum Lesen der DynamicProperties, die in einer Konfigurationsdatei gespeichert sind. Die dynamischen Eigenschaften sind jedoch zur Laufzeit schreibgeschützt, sodass die vom Benutzer vorgenommenen Änderungen nicht beibehalten werden können.

Dieses Dokument beschreibt, wie Daten serialisiert und in eine Datei geschrieben werden und wie Daten gelesen und deserialisiert werden. Wie und wo die Daten abgelegt werden, hängt davon ab, was gespeichert werden soll. Mein Ziel ist es zu beschreiben, wie die Daten je nach Typ an den entsprechenden Speicherorten gesichert werden.

Voraussetzungen für das Speichern von Anwendungseinstellungen

Die Application-Klasse von Windows Forms enthält mehrere Eigenschaften, die die bequeme Navigation zum entsprechenden Teil der Registrierung oder des Benutzerdatenordners ermöglichen. Das richtige Verwenden dieser Eigenschaften erfordert das Festlegen der Attribute AssemblyCompany, AssemblyProduct und AssemblyVersion.

Diese Attribute legen Werte fest, die von der Control-Klasse über die Eigenschaften CompanyName, ProductName und ProductVersion angezeigt werden.

Nachfolgend finden Sie ein einfaches Windows-Formular, das die Assemblyattribute festlegt und in einem Label anzeigt:

' Visual Basic
Imports System
Imports System.Windows.Forms
Imports System.Reflection
' Assemblyattribute festlegen.
<Assembly: AssemblyCompany("Microsoft")>
<Assembly: AssemblyProduct("MyApplication")>
<Assembly: AssemblyVersion("1.0.1")>
Public Class AboutDialogBox
   Inherits Form
   Public Sub New()
      ' Assemblyinformationen in einem Label anzeigen.
      Dim label1 As New Label()
      label1.Text = _
        Me.CompanyName + " " + _
        Me.ProductName + " Version: " + _
        Me.ProductVersion
      label1.AutoSize = True
      Me.Controls.Add(label1)
   End Sub
End Class 
//C#
using System;
using System.Windows.Forms;
using System.Reflection;
// Assemblyattribute festlegen 
[assembly: AssemblyCompany("Microsoft")]
[assembly: AssemblyProduct("MyApplication")]
[assembly: AssemblyVersion("1.0.1")]
public class AboutDialogBox : Form
{
   public AboutDialogBox()
   {
      // Assemblyinformationen in einem Label anzeigen.
      Label label1 = new Label();
      label1.Text = this.CompanyName + " "
         + this.ProductName + " Version: "
         + this.ProductVersion;
      label1.AutoSize = true;
      this.Controls.Add(label1);
   }
   [STAThread]
   static void Main() 
   {
      Application.Run(new AboutDialogBox());
   }
}

Verwenden der Registrierung zum Speichern von Daten

Es ist nicht ratsam, vertrauliche oder für die Anwendung wichtige Daten einfach zu serialisieren, da jeder die Daten in einem Text-Editor anzeigen oder bearbeiten kann. Die Registrierung macht Daten weniger leicht zugänglich. Sie stellt einen robusten Speicher für Anwendungs- und Benutzereinstellungen dar. Die meisten Sicherungsprogramme sichern die Registrierungseinstellungen automatisch.

Wenn Sie Informationen am richtigen Ort in der Registrierung ablegen, erfolgt beim Speichern von Einstellungen automatisch die Trennung der Benutzerdaten. Obwohl Benutzer die Registrierung bearbeiten können, tun sie das selten, was Ihre Einstellungen sicherer und stabiler macht. Wenn Microsoft Windows®-Logo-Richtlinien für das Verwenden der Registrierung befolgt werden, ist die Registrierung in der Regel ein geeigneter Ort zum Speichern von Anwendungseinstellungen.

Ihre Anwendung muss über die Berechtigungen Create und Write zum Schreiben in die Registrierung sowie über die Berechtigung Read zum Lesen der Registrierung verfügen. Weitere Informationen zum Arbeiten mit Registrierungsschlüsseln finden Sie in der Dokumentation für die Methoden GetValue und SetValue der Microsoft.Win32.RegistryKey-Klasse und der Dokumentation zur System.Security.Permissions.RegistryPermissionAccess-Enumeration in der .NET Framework SDK-Dokumentation.

Um Informationen in der Registrierung zu speichern, verwenden Sie die UserAppDataRegistry- oder CommonAppDataRegistry-Eigenschaft der Application-Klasse. Diese Eigenschaften geben ein RegistryKey-Objekt zurück, das zum Speichern von Anwendungsdaten je nach Benutzertyp verwendet werden kann:

  • Die UserAppDataRegistry-Eigenschaft gibt den Registrierungsschlüssel zurück, der zum Speichern von Roamingdaten (Einstellungen, die benutzerspezifisch, jedoch rechnerunabhängig sind) für jeden Benutzer verwendet wird. Der Registrierungsschlüssel hat das Format HKEY_CURRENT_USER\Software\[Control.CompanyName]\[Control.ProductName]\[Control.ProductVersion].

  • Die CommonAppDataRegistry-Eigenschaft gibt den Registrierungsschlüssel zurück, der zum Speichern von nicht benutzerspezifischen und Nicht-Roaming-Daten für den Rechner verwendet wird. Der Registrierungsschlüssel hat das Format HKEY_LOCAL_MACHINE\Software\[Control.CompanyName]\[Control.ProductName]\[Control.ProductVersion].

Diese zwei Eigenschaften sind schreibgeschützt. Das von ihnen zurückgegebene RegistryKey-Objekt verfügt jedoch über mehrere Methoden, mit denen Sie Registrierungsschlüssel und ihre Werte lesen, aktualisieren oder erstellen können.

Speichern von Daten in der Registrierung

Im folgenden Beispiel wird die Verbindungszeichenfolge beim Schließen des Formulars in der Registrierung gespeichert, wenn sie sich geändert hat:

' Visual Basic
Private appSettingsChanged As Boolean
Private connectionString As String
Private Sub Form1_Closing(sender As Object, 
  e As CancelEventArgs) Handles MyBase.Closing
   If appSettingsChanged Then
      Try
         ' Verbindungszeichenfolge in der Registrierung speichern, falls sie sich geändert hat.
         Application.UserAppDataRegistry.SetValue("ConnString", _
           connectionString)
      Catch ex As Exception
         MessageBox.Show(ex.Message )
      End Try
   End If
End Sub
// C#
private bool appSettingsChanged;
private string connectionString;
private void Form1_Closing(object sender, CancelEventArgs e)
{
   if(appSettingsChanged)
   {
      try
      {
         // Verbindungszeichenfolge in der Registrierung speichern, falls sie sich geändert hat.
         Application.UserAppDataRegistry.SetValue("ConnString",
           connectionString);
      }
      catch(Exception ex)
      {
         MessageBox.Show(ex.Message );
      }
   }
}

Abrufen von Daten aus der Registrierung

Im folgenden Beispiel wird beim Laden des Formulars eine Verbindungszeichenfolge aus der Registrierung geladen.

' Visual Basic
Private appSettingsChanged As Boolean
Private connectionString As String
Private Sub Form1_Load(sender As Object, 
  e As EventArgs) Handles MyBase.Load
   Try
      ' Verbindungszeichenfolge aus der Registrierung abrufen.
      If Not (Application.UserAppDataRegistry.GetValue("ConnString") _
        Is Nothing) Then
         connectionString = _
           Application.UserAppDataRegistry.GetValue( _
           "ConnString").ToString()
         statusBar1.Text = "Verbindungszeichenfolge: " + connectionString
      End If
   Catch ex As Exception
      MessageBox.Show(ex.Message)
   End Try
End Sub
// C#
private bool appSettingsChanged;
private string connectionString;
private void Form1_Load(object sender, EventArgs e)
{
   try
   {
      // Verbindungszeichenfolge aus der Registrierung abrufen.
      if(Application.UserAppDataRegistry.GetValue("ConnString") != null)
      {
         connectionString = 
           Application.UserAppDataRegistry.GetValue(
           "ConnString").ToString();
         statusBar1.Text = "Verbindungszeichenfolge: " +
           connectionString;
      }
   }
   catch(Exception ex)
   {
      MessageBox.Show(ex.Message);
   }
}

Erstellen einer benutzerdefinierten Anwendungskonfigurationsklasse

Die in diesem Dokument beschriebene Anwendungskonfigurationsklasse serialisiert eine Instanz ihrer selbst als XML. Serialisierung ist die Umwandlung eines Objekts oder Objektgraphen in eine lineare Bytesequenz, um es zu speichern oder einen andern Ort zu übertragen. Deserialisierung ist das Erzeugen von Objekten aus gespeicherten oder übertragenen Informationen.

Ein Objekt kann als Text (XML ist Text mit einer hierarchischen Struktur) oder in ein binäres Format serialisiert werden. Weitere Informationen zur Serialisierung finden Sie unter Serialisieren von Objekten im .NET Framework-Entwicklerhandbuch.

Von Control abgeleitete Windows-Forms-Klassen können nicht leicht als XML serialisiert werden, da sie Objekte enthalten, die einen dynamischen Zustand aufweisen, wie z.B. ein Fensterhandle (HWND). Da Steuerelemente nicht leicht komplett serialisiert werden können und da im Allgemeinen nicht jede vom Steuerelement angezeigte Eigenschaft beibehalten werden muss, sollten Sie eine kleine XML-serialisierbare Klasse zum Speichern der gewünschten Eigenschaftswerte schreiben.

Es kann z.B. vorkommen, dass Sie nur die BackColor-Eigenschaft, das letzte Verzeichnis, in dem der Benutzer eine Datei gespeichert hat, oder die Location-Eigenschaft des Formulars zum Zeitpunkt des letzten Schließens speichern müssen. Ihre Anwendung muss über die Berechtigung Write zum Schreiben oder Erzeugen der XML-Datei sowie über die Berechtigung Read zum Lesen der XML-Datei verfügen. Weitere Informationen finden Sie in der Dokumentation für den StreamWriter-Konstruktor und der Dokumentation zur System.Security.Permissions.FileIOPermissionAccess-Enumeration im .NET Framework SDK.

Einige Typen können erst dann als XML serialisiert werden, nachdem sie konvertiert wurden. So muss z.B. System.Drawing.Color mit der ToArgb-Methode in eine Ganzzahl konvertiert werden, um einen Wert zu erhalten, der als XML gespeichert werden kann. Typkonverter können ebenfalls zum Konvertieren von Typen in Zeichenfolgendarstellungen verwendet werden. Weitere Informationen zu Typkonvertern finden Sie in der Dokumentation zur TypeConverter-Klasse sowie unter Implementieren eines Typkonverters in der .NET Framework SDK-Dokumentation.

Verschiedene Eigenschaften der Application-Klasse stellen die Anwendungsspeicherpfade bereit, die zum Speichern von Anwendungsdaten verwendet werden können:

  • Die UserAppDataPath-Eigenschaft wird zum Speichern von Roamingdaten (Einstellungen, die benutzerspezifisch, jedoch rechnerunabhängig sind) für jeden Benutzer verwendet. Der Pfad hat das Format [UserName]\Anwendungsdaten\[Control.CompanyName]\[Control.ProductName]\[Control.ProductVersion].

  • Die LocalUserAppDataPath-Eigenschaft wird zum Speichern von Nicht-Roaming-Daten für jeden Benutzer verwendet. Der Pfad hat das Format [UserName]\Lokale Einstellungen\Anwendungsdaten\[Control.CompanyName]\[Control.ProductName]\[Control.ProductVersion].

  • Die CommonAppDataPath-Eigenschaft wird zum Speichern von nicht benutzerspezifischen, nicht servergespeicherten Daten für den Rechner verwendet. Der Pfad hat das Format All Users\Anwendungsdaten\[Control.CompanyName]\[Control.ProductName]\[Control.ProductVersion].
    Anmerkung Der in den Datenpfaden verwendete UserName-Wert wird von der UserName-Eigenschaft der System.Environment-Klasse abgerufen.

In der Regel enthält der Roamingspeicher kleinere Daten wie die Fenstereinstellungen, während der Nicht-Roaming-Speicher größere Daten, wie z.B. einen Cache großer Bitmaps, enthält.

Das folgende Beispiel enthält eine Klasse, die die Einstellungen für eine Anwendung speichert. Die Klasse enthält die Methoden SaveAppSettings und LoadAppSettings zum Laden (Deserialisieren) und Speichern (Serialisieren) der Anwendungseinstellungen.

Der Wert der BackColor-Eigenschaft wird als Ganzzahl gespeichert, sodass er serialisiert werden kann. In diesem Beispiel werden die serialisierten Daten in einer Datei namens MyApplication.config gespeichert. Beachten Sie, dass es sich dabei nicht um die von Visual Studio .NET verwendete Datei App.config handelt.

  1. Erzeugen Sie die Klasse und fügen Sie eine Boolesche Variable hinzu, die angibt, ob sich die Anwendungseinstellungen geändert haben. Fügen Sie in jedem Fall einen Verweis auf die Namespaces System.Xml.Serialization und System.IO hinzu sowie Verweise auf andere Namespaces, die Sie unter Umständen zum Speichern Ihrer Daten verwenden müssen.

    ' Visual Basic
    Imports System
    Imports System.Xml.Serialization
    Imports System.IO
    Imports System.Drawing
    Namespace Samples
       Public Class ApplicationSettings
          Private appSettingsChanged As Boolean
       End Class
    End Namespace
    // C#
    using System;
    using System.Xml.Serialization;
    using System.IO;
    using System.Drawing;
    namespace Samples
    {
       public class ApplicationSettings
       {
          private bool appSettingsChanged;
       }
    }
    
  2. Fügen Sie private Variablen hinzu, um die Anwendungseinstellungen zu speichern, und erstellen Sie öffentliche Eigenschaften, um darauf zuzugreifen.

    ' Visual Basic
          ' Zum Speichern der Anwendungseinstellungen verwendete Variablen.
          Private m_defaultDirectory As String
          Private m_backColor As Integer
          Private m_formLocation As Point
          ' Zum Zugreifen auf die Anwendungseinstellungsvariablen verwendete Eigenschaften.
          Public Property DefaultDirectory() As String
             Get
                Return m_defaultDirectory
             End Get
             Set
                If value <> m_defaultDirectory Then
                   m_defaultDirectory = value
                   appSettingsChanged = True
                End If
             End Set
          End Property
          Public Property BackColor() As Integer
             Get
                Return m_backColor
             End Get
             Set
                If value <> m_backColor Then
                   m_backColor = value
                   appSettingsChanged = True
                End If
             End Set
          End Property
          Public Property FormLocation() As Point
             Get
                Return m_formLocation
             End Get
             Set
                If Not value.Equals(m_formLocation) Then
                   m_formLocation = value
                   appSettingsChanged = True
                End If
             End Set
          End Property
    // C#
          // Zum Speichern der Anwendungseinstellungen verwendete Variablen.
          private string m_defaultDirectory;
          private int m_backColor;
          private Point m_formLocation;
          // Zum Zugreifen auf die Anwendungseinstellungsvariablen verwendete Eigenschaften.
          public string DefaultDirectory 
          {
             get{return m_defaultDirectory;}
             set
             {
                if(value != m_defaultDirectory)
                {
                   m_defaultDirectory = value;
                   appSettingsChanged = true;
                }
             }
          }
          public int BackColor 
          {
             get{return m_backColor;}
             set
             {
                if(value != m_backColor)
                {
                   m_backColor = value;
                   appSettingsChanged = true;
                }
             }
          }
          public Point FormLocation 
          {
             get{return m_formLocation;}
             set
             {
                if(value != m_formLocation)
                {
                   m_formLocation = value;
                   appSettingsChanged = true;
                }
             }
    }
    
  3. Fügen Sie eine Methode hinzu, um die Anwendungseinstellungen zu serialisieren und in der Konfigurationsdatei zu speichern.

    ' Visual Basic
          ' Serialisiert die Klasse in die Konfigurationsdatei, 
          ' wenn sich Einstellungen geändert haben. 
          Public Function SaveAppSettings() As Boolean
             If Me.appSettingsChanged Then
                Dim myWriter As StreamWriter = Nothing
                Dim mySerializer As XmlSerializer = Nothing
                Try
                   ' XmlSerializer für den
                   ' ApplicationSettings-Typ erstellen.
                   mySerializer = New XmlSerializer( _
                     GetType(ApplicationSettings))
                   myWriter = New StreamWriter( _
                     Application.LocalUserAppDataPath + _
                     "\myApplication.config", False)
                   ' Diese Instanz der ApplicationSettings- 
                   ' Klasse in die Konfigurationsdatei serialisieren. 
                   mySerializer.Serialize(myWriter, Me)
                Catch ex As Exception
                   MessageBox.Show(ex.Message)
                Finally
                   ' Wenn FileStream geöffnet ist, schließen.
                   If Not (myWriter Is Nothing) Then
                      myWriter.Close()
                   End If
                End Try
             End If
             Return appSettingsChanged
          End Function 
    // C#
          // Serialisiert die Klasse in die Konfigurationsdatei,
          // wenn sich Einstellungen geändert haben.
          public bool SaveAppSettings()
          {
             if(this.appSettingsChanged)
             {
                StreamWriter myWriter = null;
                XmlSerializer mySerializer = null;
                try
                {
                    // XmlSerializer für den
                    // ApplicationSettings-Typ erstellen.
                   mySerializer = new XmlSerializer( 
                     typeof(ApplicationSettings));
                   myWriter = 
                     new StreamWriter(Application.LocalUserAppDataPath
                     + @"\myApplication.config",false);
                   // Diese Instanz der ApplicationSettings- 
                   // Klasse in die Konfigurationsdatei serialisieren.
                   mySerializer.Serialize(myWriter, this);
                }
                catch(Exception ex)
                {
                   MessageBox.Show(ex.Message); 
                }
                finally
                {
                   // Wenn FileStream geöffnet ist, schließen.
                   if(myWriter != null)
                   {
                      myWriter.Close();
                   }
                }
             }
             return appSettingsChanged;
    }
    
  4. Fügen Sie eine Methode hinzu, um die Anwendungseinstellungen aus der Konfigurationsdatei zu deserialisieren.

    ' Visual Basic
          ' Deserialisiert die Klasse aus der Konfigurationsdatei.
          Public Function LoadAppSettings() As Boolean
             Dim mySerializer As XmlSerializer = Nothing
             Dim myFileStream As FileStream = Nothing
             Dim fileExists As Boolean = False
             Try
                ' XmlSerializer für den ApplicationSettings-Typ erstellen.
                mySerializer = New XmlSerializer(GetType(ApplicationSettings))
                Dim fi As New FileInfo(Application.LocalUserAppDataPath + _
                  "\myApplication.config")
                ' Falls die Konfigurationsdatei vorhanden ist, diese öffnen.
                If fi.Exists Then
                   myFileStream = fi.OpenRead()
                   ' Neue Instanz von ApplicationSettings durch
                   ' Deserialisieren der Konfigurationsdatei erstellen. 
                   Dim myAppSettings As ApplicationSettings = CType( _
                     mySerializer.Deserialize(myFileStream), _
                       ApplicationSettings)
                   ' Eigenschaftswerte dieser Instanz 
                   ' der ApplicationSettings-Klasse zuweisen. 
                   Me.m_backColor = myAppSettings.BackColor
                   Me.m_formLocation = myAppSettings.FormLocation
                   Me.m_defaultDirectory = myAppSettings.DefaultDirectory
                   fileExists = True
                End If
             Catch ex As Exception
                MessageBox.Show(ex.Message)
             Finally
                ' Wenn FileStream geöffnet ist, schließen.
                If Not (myFileStream Is Nothing) Then
                   myFileStream.Close()
                End If
             End Try
             ' Falls myDirectory nicht festgelegt ist, standardmäßig
             ' das Verzeichnis "Eigene Dateien" des Benutzers verwenden.
             If m_defaultDirectory Is Nothing Then
                m_defaultDirectory = Environment.GetFolderPath( _
                  System.Environment.SpecialFolder.Personal)
                Me.appSettingsChanged = True
             End If
             Return fileExists
          End Function
    // C#
          // Deserialisiert die Klasse aus der Konfigurationsdatei.
          public bool LoadAppSettings()
          {
             XmlSerializer mySerializer = null;
             FileStream myFileStream = null;
             bool fileExists = false;
             try
             {
                // XmlSerializer für den ApplicationSettings-Typ erstellen.
                mySerializer = new XmlSerializer(typeof(ApplicationSettings));
                FileInfo fi = new FileInfo(Application.LocalUserAppDataPath
                   + @"\myApplication.config");
                // Falls die Konfigurationsdatei vorhanden ist, diese öffnen.
                if(fi.Exists)
                {
                   myFileStream = fi.OpenRead();
                   // Neue Instanz von ApplicationSettings durch
                   // Deserialisieren der Konfigurationsdatei erstellen.
                   ApplicationSettings myAppSettings = 
                     (ApplicationSettings)mySerializer.Deserialize(
                      myFileStream);
                   // Eigenschaftswerte dieser Instanz
                   // der ApplicationSettings-Klasse zuweisen.
                   this.m_backColor = myAppSettings.BackColor;
                   this.m_formLocation = myAppSettings.FormLocation;
                   this.m_defaultDirectory = myAppSettings.DefaultDirectory;
                   fileExists = true;
                }
             }
             catch(Exception ex)
             {
                MessageBox.Show(ex.Message);
             }
             finally
             {
                // Falls FileStream geöffnet ist, schließen.
                if(myFileStream != null)
                {
                   myFileStream.Close();
                }
             }
             if(m_defaultDirectory == null)
             {
                // Falls myDirectory nicht festgelegt ist, standardmäßig
                // das Verzeichnis "Eigene Dateien" des Benutzers verwenden.
                m_defaultDirectory = Environment.GetFolderPath(
                   System.Environment.SpecialFolder.Personal);
                this.appSettingsChanged = true;
             }
             return fileExists;
          }
    

Verwenden der Anwendungseinstellungsklasse mit der Anwendung

Sie müssen nur wenige Codezeilen zu Ihrer Anwendung hinzufügen, um die Anwendungseinstellungsklasse zum Serialisieren und Deserialisieren von Werten zu verwenden, die beibehalten werden sollen.

Laden gespeicherter Anwendungseinstellungen

Es muss eine Variable vorhanden sein, die die Einstellung aufnimmt. In diesem Beispiel handelt es sich dabei um eine ApplicationSettings-Klasse namens applicationSettings. Rufen Sie an der entsprechenden Stelle im Code die Methode auf, mit der die Daten deserialisiert werden.

In diesem Beispiel heißt die Methode LoadAppSettings() und wird im Load-Ereignis des Formulars aufgerufen. Diese Methode kann auch im Konstruktor nach jedem anderen Initialisierungscode oder im Load-Ereignishandler aufgerufen werden. Anschließend weisen Sie die gespeicherten Werte den entsprechenden Eigenschaften Ihrer Anwendung zu.

Im folgenden Beispiel werden die Anwendungseinstellungen im Load-Ereignis des Formulars geladen und die Werte den entsprechenden Eigenschaften zugewiesen. Dieses Beispiel setzt voraus, dass Ihr Formular über eine Variable namens defaultDirectory verfügt.

' Visual Basic
' Wenn die LoadAppSettings-Methode erfolgreich ist, die
' ApplicationSettings-Eigenschaften den entsprechenden Formulareigenschaften zuweisen.
Private Sub Form1_Load(sender As Object, _
  e As EventArgs) Handles MyBase.Load
   If applicationSettings.LoadAppSettings() Then
      ' Farbe vom ganzzahligen (ARGB-)Wert erstellen.
      Me.BackColor = Color.FromArgb(applicationSettings.BackColor)
      Me.Location = applicationSettings.FormLocation
      Me.defaultDirectory = applicationSettings.DefaultDirectory
   End If
End Sub
// C#
 // Wenn die LoadAppSettings-Methode erfolgreich ist, die
 // ApplicationSettings-Eigenschaften den entsprechenden Formulareigenschaften zuweisen.
private void Form1_Load(object sender, EventArgs e)
{
   if(this.applicationSettings.LoadAppSettings() )
   {
      // Farbe vom ganzzahligen (ARGB-)Wert erstellen.
      this.BackColor = Color.FromArgb(applicationSettings.BackColor);
      this.Location = applicationSettings.FormLocation;
      this.defaultDirectory = applicationSettings.DefaultDirectory;
   }
}

Speichern von Anwendungseinstellungen

Es muss eine Variable vorhanden sein, die die die Anwendungseinstellung aufnimmt.. In diesem Beispiel handelt es sich dabei um eine ApplicationSettings-Klasse namens applicationSettings. Weisen Sie an der entsprechenden Stelle im Code die Eigenschaftswerte, die beibehalten werden sollen, den entsprechenden Eigenschaften in der Anwendungseinstellungsklasse zu.

Falls die beibehaltenen Eigenschaften ein geändertes Ereignis aufweisen, wie beispielsweise das BackColorChanged-Ereignis, können Sie die entsprechende Eigenschaft in der Anwendungseinstellungsklasse in diesem Ereignishandler aktualisieren. Dadurch wird die Instanz der Anwendungseinstellungsklasse immer dann aktualisiert, wenn der Benutzer oder die Anwendung die Eigenschaft ändert.

Rufen Sie vor dem Beenden der Anwendung die Methode auf, mit der die Daten serialisiert werden. In diesem Beispiel heißt die Methode SaveAppSettings() und wird im Closing-Ereignis des Formulars aufgerufen. Diese Methode kann auch im Closing-Ereignishandler aufgerufen werden oder die Close-Methode kann überladen werden und einen Booleschen Wert annehmen, mit dem angegeben wird, ob die Anwendungseinstellungen gespeichert werden.

Im folgenden Beispiel werden die Eigenschaften in der Anwendungseinstellungsklasse aktualisiert und die Anwendungseinstellungen im Closing-Ereignis des Formulars gespeichert.

' Visual Basic
' Neuen Speicherort im ApplicationSettings- 
' Objekt speichern, wenn er geändert wird.
Private Sub Form1_LocationChanged(sender As Object, _
  e As EventArgs) Handles MyBase.LocationChanged
   applicationSettings.FormLocation = Me.Location
End Sub
' Neuen BackColor-Wert im ApplicationSettings-
' Objekt speichern, wenn er geändert wird.
Private Sub Form1_BackColorChanged(sender As Object, _
  e As EventArgs) Handles MyBase.BackColorChanged
   applicationSettings.BackColor = Me.BackColor.ToArgb()
End Sub 
' Neues Standardverzeichnis vor dem Serialisieren der Klasseneinstellungen 
' und dem Schließen des Formulars im ApplicationSettings-Objekt speichern.
Private Sub Form1_Closing(sender As Object, _
  e As CancelEventArgs) Handles MyBase.Closing
   applicationSettings.DefaultDirectory = Me.defaultDirectory
   applicationSettings.SaveAppSettings()
End Sub
// C#
// Neuen Speicherort im ApplicationSettings- 
// Objekt speichern, wenn er geändert wird.
private void Form1_LocationChanged(object sender, EventArgs e)
{
   applictionSettings.FormLocation = this.Location;
}
// Neuen BackColor-Wert im ApplicationSettings- 
// Objekt speichern, wenn er geändert wird.
private void Form1_BackColorChanged(object sender, EventArgs e)
{
   applicationSettings.BackColor = this.BackColor.ToArgb();
}
// Neues Standardverzeichnis vor dem Serialisieren der Klasseneinstellungen 
// und dem Schließen des Formulars im ApplicationSettings-Objekt speichern.
private void Form1_Closing(object sender, CancelEventArgs e)
{
   applicationSettings.DefaultDirectory = this.defaultDirectory;
   applicationSettings.SaveAppSettings();
}

Schlussfolgerung

Wie bisher können Sie mit den entsprechenden Berechtigungen aus der Registrierung lesen und in die Registrierung schreiben. Sie sollten jedoch versuchen, die in der Registrierung gespeicherte Datenmenge zu beschränken.

.NET Framework ermöglicht es Ihnen, mit minimaler Implementierung und Anpassung Ihre Anwendungseinstellungen problemlos zu serialisieren und die Daten als XML zu speichern. Anders als bei dem von Visual Studio .NET bereitgestellten Anwendungskonfigurationsmodell können die serialisierten Daten gelesen und aktualisiert werden.

Die in diesem Dokument verwendeten Anwendungsdaten und Registrierungsdatenpfade halten sich an die Windows-Logo-Richtlinien. Um sicherzustellen, dass Ihre Anwendung alle Windows-Logo-Richtlinien erfüllt, lesen Sie den Abschnitt Designed for Microsoft Windows XP Application Specification unter Designed for Windows Logo Program in der Microsoft-Website.


Anzeigen: