Teilen über

ApplicationSettingsBase Klasse

  • Referenz

Definition

Namespace:
System.Configuration
Assembly:
System.Configuration.ConfigurationManager.dll
Assembly:
System.dll
Paket:
System.Configuration.ConfigurationManager v6.0.0
Paket:
System.Configuration.ConfigurationManager v7.0.0
Paket:
System.Configuration.ConfigurationManager v8.0.0
Paket:
System.Configuration.ConfigurationManager v9.0.0-preview.2.24128.5
Quelle:
ApplicationSettingsBase.cs
Quelle:
ApplicationSettingsBase.cs
Quelle:
ApplicationSettingsBase.cs

Fungiert als Basisklasse für das Ableiten konkreter Wrapperklassen, um das Anwendungseinstellungsfeature in Windows Forms-Anwendungen zu implementieren.

public ref class ApplicationSettingsBase abstract : System::Configuration::SettingsBase, System::ComponentModel::INotifyPropertyChanged
public abstract class ApplicationSettingsBase : System.Configuration.SettingsBase, System.ComponentModel.INotifyPropertyChanged
type ApplicationSettingsBase = class
    inherit SettingsBase
    interface INotifyPropertyChanged
Public MustInherit Class ApplicationSettingsBase
Inherits SettingsBase
Implements INotifyPropertyChanged
Vererbung
Object
SettingsBase
ApplicationSettingsBase
Implementiert
INotifyPropertyChanged

Beispiele

Im folgenden Codebeispiel wird die Verwendung von Anwendungseinstellungen veranschaulicht, um die folgenden Attribute des Standard Formulars beizubehalten: Position, Größe, Hintergrundfarbe und Titelleistentext. Alle diese Attribute werden als einzelne Anwendungseinstellungseigenschaften in der -Klasse mit den FormSettings Namen FormLocation, FormSizeFormBackColor bzwFormText. beibehalten. Alle Daten mit Ausnahme FormText von und Size sind an die zugehörigen Formulareigenschaften gebunden und verfügen über einen Standardeinstellungswert, der mit DefaultSettingValueAttributeangewendet wird.

Das Formular enthält vier untergeordnete Steuerelemente mit den folgenden Namen und Funktionen:

  • Eine Schaltfläche namens btnBackColor , die zum Anzeigen des allgemeinen Dialogfelds Farbe verwendet wird.

  • Eine Schaltfläche namens btnReload , die für Reload die Anwendungseinstellungen verwendet wird.

  • Eine Schaltfläche namens btnReset , die für Reset die Anwendungseinstellungen verwendet wird.

  • Ein Textfeld namenstbStatus, das zum Anzeigen status Informationen zum Programm verwendet wird.

Beachten Sie, dass nach jeder Ausführung der Anwendung ein zusätzliches Punktzeichen an den Titeltext des Formulars angefügt wird.

Dieses Codebeispiel erfordert ein Formular mit einer ColorDialog Klasse mit dem Namen colorDialog1und ein StatusStrip -Steuerelement mit dem ToolStripStatusLabel Namen tbStatus. Darüber hinaus sind drei Button Objekte mit den Namen btnReload, btnResetund btnBackColorerforderlich.


#using <System.dll>
#using <System.Drawing.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::ComponentModel;
using namespace System::Drawing;
using namespace System::Configuration;
using namespace System::Windows::Forms;

namespace AppSettingsSample
{
    //Application settings wrapper class
    ref class FormSettings sealed: public ApplicationSettingsBase
    {
    public:
        [UserScopedSettingAttribute()]
        property String^ FormText
        {
            String^ get()
            {
                return (String^)this["FormText"];
            }
            void set( String^ value )
            {
                this["FormText"] = value;
            }
        }

    public:
        [UserScopedSettingAttribute()]
        [DefaultSettingValueAttribute("0, 0")]
        property Point FormLocation
        {
            Point get()
            {
                return (Point)(this["FormLocation"]);
            }
            void set( Point value )
            {
                this["FormLocation"] = value;
            }
        }

    public:
        [UserScopedSettingAttribute()]
        [DefaultSettingValueAttribute("225, 200")]
        property Size FormSize
        {
            Size get()
            {
                return (Size)this["FormSize"];
            }
            void set( Size value )
            {
                this["FormSize"] = value;
            }
        }

    public:
        [UserScopedSettingAttribute()]
        [DefaultSettingValueAttribute("LightGray")]
        property Color FormBackColor
        {
            Color get()
            {
                return (Color)this["FormBackColor"];
            }
            void set(Color value)
            {
                this["FormBackColor"] = value;
            }
        }

    };

    ref class AppSettingsForm : Form
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
    private:
        System::ComponentModel::IContainer^ components;

        /// <summary>
        /// Clean up any resources being used. The Dispose(true) 
        /// pattern for embedded objects is implemented with this
        /// code that just contains a destructor 
        /// </summary>
    public:
        ~AppSettingsForm()
        {
            if (components != nullptr)
            {
                delete components;
            }
        }

#pragma region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
    private:
        void InitializeComponent()
        {
            this->components = nullptr;
            this->colorDialog = gcnew System::Windows::Forms::ColorDialog();
            this->backColorButton = gcnew System::Windows::Forms::Button();
            this->resetButton = gcnew System::Windows::Forms::Button();
            this->statusDisplay = gcnew System::Windows::Forms::TextBox();
            this->reloadButton = gcnew System::Windows::Forms::Button();
            this->SuspendLayout();
            //
            // backColorButton
            //
            this->backColorButton->Location = System::Drawing::Point(26, 24);
            this->backColorButton->Name = "backColorButton";
            this->backColorButton->Size = System::Drawing::Size(159, 23);
            this->backColorButton->TabIndex = 0;
            this->backColorButton->Text = "Change Background Color";
            this->backColorButton->Click += gcnew System::EventHandler
                (this,&AppSettingsForm::BackColorButton_Click);
            //
            // resetButton
            //
            this->resetButton->Location = System::Drawing::Point(26, 90);
            this->resetButton->Name = "resetButton";
            this->resetButton->Size = System::Drawing::Size(159, 23);
            this->resetButton->TabIndex = 1;
            this->resetButton->Text = "Reset to Defaults";
            this->resetButton->Click += gcnew System::EventHandler
                (this,&AppSettingsForm::ResetButton_Click);
            //
            // statusDisplay
            //
            this->statusDisplay->Location = System::Drawing::Point(26, 123);
            this->statusDisplay->Name = "statusDisplay";
            this->statusDisplay->Size = System::Drawing::Size(159, 20);
            this->statusDisplay->TabIndex = 2;
            //
            // reloadButton
            //
            this->reloadButton->Location = System::Drawing::Point(26, 57);
            this->reloadButton->Name = "reloadButton";
            this->reloadButton->Size = System::Drawing::Size(159, 23);
            this->reloadButton->TabIndex = 3;
            this->reloadButton->Text = "Reload from Storage";
            this->reloadButton->Click += gcnew System::EventHandler
                (this,&AppSettingsForm::ReloadButton_Click);
            //
            // AppSettingsForm
            //
            this->ClientSize = System::Drawing::Size(217, 166);
            this->Controls->Add(this->reloadButton);
            this->Controls->Add(this->statusDisplay);
            this->Controls->Add(this->resetButton);
            this->Controls->Add(this->backColorButton);
            this->Name = "AppSettingsForm";
            this->Text = "App Settings";
            this->FormClosing += gcnew
                System::Windows::Forms::FormClosingEventHandler
                (this,&AppSettingsForm::AppSettingsForm_FormClosing);
            this->Load += gcnew System::EventHandler(this,
                &AppSettingsForm::AppSettingsForm_Load);
            this->ResumeLayout(false);
            this->PerformLayout();

        }

#pragma endregion

    private:
        System::Windows::Forms::ColorDialog^ colorDialog;

        System::Windows::Forms::Button^ backColorButton;

        System::Windows::Forms::Button^ resetButton;

        System::Windows::Forms::TextBox^ statusDisplay;

        System::Windows::Forms::Button^ reloadButton;



        FormSettings ^ formSettings;

    public:
        AppSettingsForm()
        {
            formSettings = gcnew FormSettings;
            InitializeComponent();
        }

    private:
        void AppSettingsForm_Load(Object^ sender, EventArgs^ e)
        {
            //Associate settings property event handlers.
            formSettings->SettingChanging += gcnew SettingChangingEventHandler(
                this, &AppSettingsForm::FormSettings_SettingChanging);
            formSettings->SettingsSaving += gcnew SettingsSavingEventHandler(
                this,&AppSettingsForm::FormSettings_SettingsSaving);

            //Data bind settings properties with straightforward associations.
            Binding^ backColorBinding = gcnew Binding("BackColor", 
                formSettings, "FormBackColor", true, 
                DataSourceUpdateMode::OnPropertyChanged);
            this->DataBindings->Add(backColorBinding);
            Binding^ sizeBinding = gcnew Binding("Size", formSettings,
                "FormSize", true, DataSourceUpdateMode::OnPropertyChanged);
            this->DataBindings->Add(sizeBinding);
            Binding^ locationBinding = gcnew Binding("Location", formSettings,
                "FormLocation", true, DataSourceUpdateMode::OnPropertyChanged);
            this->DataBindings->Add(locationBinding);

            //For more complex associations, manually assign associations.
            String^ savedText = formSettings->FormText;
            //Since there is no default value for FormText.
            if (savedText != nullptr)
            {
                this->Text = savedText;
            }
        }

    private:
        void AppSettingsForm_FormClosing(Object^ sender,
            FormClosingEventArgs^ e)
        {
            //Synchronize manual associations first.
            formSettings->FormText = this->Text + '.';
            formSettings->Save();
        }

    private:
        void BackColorButton_Click(Object^ sender, EventArgs^ e)
        {
            if (::DialogResult::OK == colorDialog->ShowDialog())
            {
                Color color = colorDialog->Color;
                this->BackColor = color;
            }
        }

    private:
        void ResetButton_Click(Object^ sender, EventArgs^ e)
        {
            formSettings->Reset();
            this->BackColor = SystemColors::Control;
        }

    private:
        void ReloadButton_Click(Object^ sender, EventArgs^ e)
        {
            formSettings->Reload();
        }

    private:
        void FormSettings_SettingChanging(Object^ sender,
            SettingChangingEventArgs^ e)
        {
            statusDisplay->Text = e->SettingName + ": " + e->NewValue;
        }

    private:
        void FormSettings_SettingsSaving(Object^ sender,
            CancelEventArgs^ e)
        {
            //Should check for settings changes first.
            ::DialogResult^ dialogResult = MessageBox::Show(
                "Save current values for application settings?",
                "Save Settings", MessageBoxButtons::YesNo);
            if (::DialogResult::No == dialogResult)
            {
                e->Cancel = true;
            }
        }
    };

partial class Form1 : Form
{
    private FormSettings frmSettings1 = new FormSettings();

    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        this.FormClosing += new FormClosingEventHandler(Form1_FormClosing);

        //Associate settings property event handlers.
        frmSettings1.SettingChanging += new SettingChangingEventHandler(
                                            frmSettings1_SettingChanging);
        frmSettings1.SettingsSaving += new SettingsSavingEventHandler(
                                            frmSettings1_SettingsSaving);

        //Data bind settings properties with straightforward associations.
        Binding bndBackColor = new Binding("BackColor", frmSettings1,
            "FormBackColor", true, DataSourceUpdateMode.OnPropertyChanged);
        this.DataBindings.Add(bndBackColor);
        Binding bndLocation = new Binding("Location", frmSettings1,
            "FormLocation", true, DataSourceUpdateMode.OnPropertyChanged);
        this.DataBindings.Add(bndLocation);

        // Assign Size property, since databinding to Size doesn't work well.
         this.Size = frmSettings1.FormSize;

        //For more complex associations, manually assign associations.
        String savedText = frmSettings1.FormText;
        //Since there is no default value for FormText.
        if (savedText != null)
            this.Text = savedText;
    }

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        //Synchronize manual associations first.
        frmSettings1.FormText = this.Text + '.';
        frmSettings1.FormSize = this.Size;
        frmSettings1.Save();
    }

    private void btnBackColor_Click(object sender, EventArgs e)
    {
        if (DialogResult.OK == colorDialog1.ShowDialog())
        {
            Color c = colorDialog1.Color;
            this.BackColor = c;
        }
    }

    private void btnReset_Click(object sender, EventArgs e)
    {
        frmSettings1.Reset();
        this.BackColor = SystemColors.Control;
    }

    private void btnReload_Click(object sender, EventArgs e)
    {
        frmSettings1.Reload();
    }

    void frmSettings1_SettingChanging(object sender, SettingChangingEventArgs e)
    {
        tbStatus.Text = e.SettingName + ": " + e.NewValue;
    }

    void frmSettings1_SettingsSaving(object sender, CancelEventArgs e)
    {
        //Should check for settings changes first.
        DialogResult dr = MessageBox.Show(
                        "Save current values for application settings?",
                        "Save Settings", MessageBoxButtons.YesNo);
        if (DialogResult.No == dr)
        {
            e.Cancel = true;
        }
    }
}

//Application settings wrapper class
sealed class FormSettings : ApplicationSettingsBase
{
    [UserScopedSettingAttribute()]
    public String FormText
    {
        get { return (String)this["FormText"]; }
        set { this["FormText"] = value; }
    }

    [UserScopedSettingAttribute()]
    [DefaultSettingValueAttribute("0, 0")]
    public Point FormLocation
    {
        get { return (Point)(this["FormLocation"]); }
        set { this["FormLocation"] = value; }
    }

    [UserScopedSettingAttribute()]
    [DefaultSettingValueAttribute("225, 200")]
    public Size FormSize
    {
        get { return (Size)this["FormSize"]; }
        set { this["FormSize"] = value; }
    }

    [UserScopedSettingAttribute()]
    [DefaultSettingValueAttribute("LightGray")]
    public Color FormBackColor
    {
        get { return (Color)this["FormBackColor"]; }
        set { this["FormBackColor"] = value; }
    }
}

Imports System.Configuration
Imports System.ComponentModel

Public Class Form1

    Private WithEvents frmSettings1 As New FormSettings

    Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs) _
            Handles MyBase.Load
        'Settings property event handlers are associated through WithEvents 
        '  and Handles combination.

        'Data bind settings properties with straightforward associations.
        Dim bndBackColor As New Binding("BackColor", frmSettings1, "FormBackColor", _
                True, DataSourceUpdateMode.OnPropertyChanged)
        Me.DataBindings.Add(bndBackColor)
        Dim bndLocation As New Binding("Location", frmSettings1, "FormLocation", _
                True, DataSourceUpdateMode.OnPropertyChanged)
        Me.DataBindings.Add(bndLocation)

        ' Assign Size property, since databinding to Size doesn't work well.
        Me.Size = frmSettings1.FormSize

        'For more complex associations, manually assign associations.
        Dim savedText As String = frmSettings1.FormText
        'Since there is no default value for FormText.
        If (savedText IsNot Nothing) Then
            Me.Text = savedText
        End If
    End Sub

    Private Sub Form1_FormClosing_1(ByVal sender As Object, ByVal e As _
            FormClosingEventArgs) Handles MyBase.FormClosing
        'Synchronize manual associations first.
        frmSettings1.FormText = Me.Text + "."c

        ' Save size settings manually.
        frmSettings1.FormSize = Me.Size

        frmSettings1.Save()
    End Sub

    Private Sub btnBackColor_Click(ByVal sender As Object, ByVal e As EventArgs) _
            Handles btnBackColor.Click
        If System.Windows.Forms.DialogResult.OK = colorDialog1.ShowDialog() Then
            Dim c As Color = colorDialog1.Color
            Me.BackColor = c
        End If
    End Sub

    Private Sub btnReset_Click(ByVal sender As Object, ByVal e As EventArgs) _
            Handles btnReset.Click
        frmSettings1.Reset()
        Me.BackColor = SystemColors.Control
    End Sub

    Private Sub btnReload_Click(ByVal sender As Object, ByVal e As EventArgs) _
            Handles btnReload.Click
        frmSettings1.Reload()
    End Sub

    Private Sub frmSettings1_SettingChanging(ByVal sender As Object, ByVal e As _
            SettingChangingEventArgs) Handles frmSettings1.SettingChanging
        tbStatus.Text = e.SettingName & ": " & e.NewValue.ToString
    End Sub

    Private Sub frmSettings1_SettingsSaving(ByVal sender As Object, ByVal e As _
            CancelEventArgs) Handles frmSettings1.SettingsSaving
        'Should check for settings changes first.
        Dim dr As DialogResult = MessageBox.Show( _
            "Save current values for application settings?", "Save Settings", _
            MessageBoxButtons.YesNo)
        If (System.Windows.Forms.DialogResult.No = dr) Then
            e.Cancel = True
        End If
    End Sub
End Class

'Application settings wrapper class. This class defines the settings we intend to use in our application.
NotInheritable Class FormSettings
    Inherits ApplicationSettingsBase

    <UserScopedSettingAttribute()> _
    Public Property FormText() As String
        Get
            Return CStr(Me("FormText"))
        End Get
        Set(ByVal value As String)
            Me("FormText") = value
        End Set
    End Property

    <UserScopedSettingAttribute(), DefaultSettingValueAttribute("0, 0")> _
    Public Property FormLocation() As Point
        Get
            Return CType(Me("FormLocation"), Point)
        End Get
        Set(ByVal value As Point)
            Me("FormLocation") = value
        End Set
    End Property

    <UserScopedSettingAttribute(), DefaultSettingValueAttribute("225, 200")> _
    Public Property FormSize() As Size
        Get
            Return CType(Me("FormSize"), Size)
        End Get
        Set(ByVal value As Size)
            Me("FormSize") = value
        End Set
    End Property

    <UserScopedSettingAttribute(), DefaultSettingValueAttribute("LightGray")> _
    Public Property FormBackColor() As Color
        Get
            Return CType(Me("FormBackColor"), Color)
        End Get
        Set(ByVal value As Color)
            Me("FormBackColor") = value
        End Set
    End Property
End Class

Hinweise

ApplicationSettingsBase fügt der Klasse, die von webbasierten Anwendungen verwendet wird, die SettingsBase folgende Funktionalität hinzu:

  • Die Möglichkeit, Attribute für eine abgeleitete Einstellungswrapperklasse zu erkennen. ApplicationSettingsBase unterstützt das deklarative Modell, das für Wrapperklasseneigenschaften verwendet wird, wie weiter unten beschrieben.

  • Übergeordnete Methoden Save und Reload .

  • Zusätzliche Validierungsereignisse, die Sie behandeln können, um die Richtigkeit einzelner Einstellungen sicherzustellen.

In der Anwendungseinstellungsarchitektur müssen Sie eine konkrete Wrapperklasse von ApplicationSettingsBaseableiten, um auf eine Gruppe von Einstellungseigenschaften zuzugreifen. Die Wrapperklasse wird auf folgende Weise angepasst ApplicationSettingsBase :

  • Für jede Einstellungseigenschaft, auf die zugegriffen werden soll, wird der Wrapperklasse eine entsprechende stark typisierte öffentliche Eigenschaft hinzugefügt. Diese Eigenschaft verfügt get über - und set -Accessoren für Anwendungseinstellungen mit Lese-/Schreibzugriff, aber nur einen get Accessor für schreibgeschützte Einstellungen.

  • Geeignete Attribute müssen auf die öffentlichen Eigenschaften der Wrapperklasse angewendet werden, um Merkmale der Einstellungseigenschaft anzugeben, z. B. den Bereich der Einstellung (Anwendung oder Benutzer), ob die Einstellung Roaming unterstützen soll, der Standardwert für die Einstellung, der zu verwendende Einstellungsanbieter usw. Jede Eigenschaft ist erforderlich, um ihren Bereich mit ApplicationScopedSettingAttribute oder UserScopedSettingAttributeanzugeben. Anwendungsspezifische Einstellungen sind schreibgeschützt, wenn die Standardeinstellung LocalFileSettingsProvider verwendet wird.

Die ApplicationSettingsBase -Klasse verwendet Reflektion, um diese Attribute zur Laufzeit zu erkennen. Die meisten dieser Informationen werden an die Einstellungsanbieterebene übergeben, die für Speicher, Persistenzformat usw. zuständig ist.

Wenn eine Anwendung über mehrere Einstellungswrapperklassen verfügt, definiert jede Klasse eine Einstellungsgruppe. Jede Gruppe weist die folgenden Merkmale auf:

  • Eine Gruppe kann eine beliebige Anzahl oder einen beliebigen Typ von Eigenschafteneinstellungen enthalten.

  • Wenn der Gruppenname nicht explizit von der Wrapperklasse mit festgelegt SettingsGroupNameAttributewird, wird automatisch ein Name generiert.

Standardmäßig verwenden alle clientbasierten Anwendungen die LocalFileSettingsProvider , um Speicher bereitzustellen. Wenn ein alternativer Einstellungsanbieter gewünscht wird, muss die Wrapperklasse oder -Eigenschaft mit einem entsprechenden SettingsProviderAttributeergänzt werden.

Weitere Informationen zur Verwendung von Anwendungseinstellungen finden Sie unter Anwendungseinstellungen für Windows Forms.

Konstruktoren

ApplicationSettingsBase()

Initialisiert eine Instanz der ApplicationSettingsBase-Klasse mit ihrem Standardzustand.
ApplicationSettingsBase(IComponent)

Initialisiert mithilfe der angegebenen Besitzerkomponente eine Instanz der ApplicationSettingsBase-Klasse.
ApplicationSettingsBase(IComponent, String)

Initialisiert mithilfe der angegebenen Besitzerkomponente und des Einstellungsschlüssels eine Instanz der ApplicationSettingsBase-Klasse.
ApplicationSettingsBase(String)

Initialisiert mithilfe des angegebenen Einstellungsschlüssels eine Instanz der ApplicationSettingsBase-Klasse.

Eigenschaften

Context

Ruft den der Einstellungsgruppe zugeordneten Anwendungseinstellungskontext ab.
IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf das Objekt synchronisiert (threadsicher) ist.

(Geerbt von SettingsBase)
Item[String]

Ruft den Wert der angegebenen Anwendungseinstellungseigenschaft ab oder legt diesen fest.
Properties

Ruft die Auflistung der Einstellungseigenschaften im Wrapper ab.
PropertyValues

Ruft eine Auflistung von Eigenschaftswerten ab.
Providers

Ruft die Auflistung der vom Wrapper verwendeten Anwendungseinstellungsanbieter ab.
SettingsKey

Ruft den Einstellungsschlüssel für die Anwendungseinstellungsgruppe ab oder legt ihn fest.

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetPreviousVersion(String)

Gibt den Wert der benannten Einstellungseigenschaft für die vorherige Version derselben Anwendung zurück.
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
Initialize(SettingsContext, SettingsPropertyCollection, SettingsProviderCollection)

Initialisiert vom SettingsBase-Objekt verwendete interne Eigenschaften.

(Geerbt von SettingsBase)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
OnPropertyChanged(Object, PropertyChangedEventArgs)

Löst das PropertyChanged-Ereignis aus.
OnSettingChanging(Object, SettingChangingEventArgs)

Löst das SettingChanging-Ereignis aus.
OnSettingsLoaded(Object, SettingsLoadedEventArgs)

Löst das SettingsLoaded-Ereignis aus.
OnSettingsSaving(Object, CancelEventArgs)

Löst das SettingsSaving-Ereignis aus.
Reload()

Aktualisiert die Werte der Anwendungseinstellungseigenschaft aus dem permanenten Speicher.
Reset()

Stellt die beibehaltenen Anwendungseinstellungswerte mit den entsprechenden Standardeigenschaften wieder her.
Save()

Speichert die aktuellen Werte der Anwendungseinstellungseigenschaften.
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
Upgrade()

Aktualisiert Anwendungseinstellungen, um eine aktuellere Installation der Anwendung wiederzugeben.

Ereignisse

PropertyChanged

Tritt ein, nachdem der Wert einer Anwendungseinstellungseigenschaft geändert wurde.
SettingChanging

Tritt ein, bevor der Wert einer Anwendungseinstellungseigenschaft geändert wurde.
SettingsLoaded

Tritt ein, nachdem die Anwendungseinstellungen vom Speicher abgerufen worden sind.
SettingsSaving

Tritt ein, bevor Werte im Datenspeicher gespeichert werden.

Gilt für:

Weitere Informationen