ApplicationSettingsBase Klasse

Definition

Fungiert als Basisklasse für das Ableiten konkreter Wrapperklassen, um das Anwendungseinstellungsfeature in Windows Forms-Anwendungen zu implementieren.Acts as a base class for deriving concrete wrapper classes to implement the application settings feature in Window Forms applications.

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
ApplicationSettingsBase
Implementiert

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung von Anwendungseinstellungen, um die folgenden Attribute des Haupt Formulars beizubehalten: Speicherort, Größe, Hintergrundfarbe und Titelleisten Text.The following code example demonstrates the use of application settings to persist the following attributes of the main form: location, size, background color, and title bar text. Alle diese Attribute werden als Eigenschaften der einzelnen Anwendungseinstellungen in der-Klasse gespeichert, mit dem FormSettings Namen FormLocation , FormSize FormBackColor FormText bzw.All of these attributes are persisted as single application settings properties in the FormSettings class, named FormLocation, FormSize, FormBackColor and FormText, respectively. Mit Ausnahme von FormText und Size sind Daten an die zugehörigen Formular Eigenschaften gebunden, und es wird ein Standard Einstellungs Wert verwendet, der mithilfe von angewendet wird DefaultSettingValueAttribute .All except for FormText and Size are data bound to their associated form properties and have a default setting value applied using DefaultSettingValueAttribute.

Das Formular enthält vier untergeordnete Steuerelemente, die die folgenden Namen und Funktionen aufweisen:The form contains four child controls that have the following names and functions:

  • Eine Schaltfläche btnBackColor mit dem Namen, die verwendet wird, um das Dialogfeld Farbe allgemein anzuzeigenA button named btnBackColor used to display the Color common dialog box.

  • Eine Schaltfläche btnReload mit dem Namen, Reload die den Anwendungseinstellungen verwendet wird.A button named btnReload used to Reload the application settings.

  • Eine Schaltfläche btnReset mit dem Namen, Reset die den Anwendungseinstellungen verwendet wird.A button named btnReset used to Reset the application settings.

  • Ein Textfeld tbStatus mit dem Namen, das verwendet wird, um Statusinformationen zum Programm anzuzeigen.A textbox named tbStatus used to display status information about the program.

Beachten Sie, dass nach jeder Ausführung der Anwendung ein zusätzliches Zeit Zeichen an den Titeltext des Formulars angehängt wird.Notice that after every execution of the application, an additional period character is appended to the title text of the form.

Dieses Codebeispiel erfordert ein Formular mit einer ColorDialog Klasse mit dem Namen colorDialog1 und ein- StatusStrip Steuerelement mit dem ToolStripStatusLabel Namen tbStatus .This code example requires a Form with a ColorDialog class named colorDialog1, and a StatusStrip control with a ToolStripStatusLabel named tbStatus. Außerdem sind drei Objekte mit den Button Namen btnReload , btnReset und erforderlich btnBackColor .Additionally, it requires three Button objects named btnReload, btnReset, and btnBackColor.


#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 der- SettingsBase Klasse, die von webbasierten Anwendungen verwendet wird, werden die folgenden Funktionen hinzugefügt:ApplicationSettingsBase adds the following functionality to the SettingsBase class, which is used by Web-based applications:

  • Die Fähigkeit, Attribute für eine abgeleitete Wrapper Klasse für Einstellungen zu erkennen.The ability to detect attributes on a derived, settings wrapper class. ApplicationSettingsBase unterstützt das deklarative Modell, das für Wrapper Klasseneigenschaften verwendet wird, wie später beschrieben.ApplicationSettingsBase supports the declarative model used for wrapper class properties, as described later.

  • Methoden der höheren Ebene Save und Reload .Higher-level Save and Reload methods.

  • Zusätzliche Validierungs Ereignisse, die Sie behandeln können, um die Richtigkeit einzelner Einstellungen sicherzustellen.Additional validation events that you can handle to ensure the correctness of individual settings.

Wenn Sie in der Architektur der Anwendungseinstellungen auf eine Gruppe von Einstellungs Eigenschaften zugreifen möchten, müssen Sie eine konkrete Wrapper Klasse von ableiten ApplicationSettingsBase .In the application settings architecture, to access a group of settings properties you need to derive a concrete wrapper class from ApplicationSettingsBase. Die Wrapper Klasse passt ApplicationSettingsBase wie folgt an:The wrapper class customizes ApplicationSettingsBase in the following ways:

  • Für jede Einstellungs Eigenschaft, auf die zugegriffen werden soll, wird der Wrapper Klasse eine entsprechende stark typisierte öffentliche Eigenschaft hinzugefügt.For every settings property to be accessed, a corresponding strongly typed public property is added to the wrapper class. Diese Eigenschaft verfügt über get -und- set Accessoren für Lese-/Schreib-Anwendungseinstellungen, aber nur einen- get Accessor für schreibgeschützte Einstellungen.This property has get and set accessors for read/write application settings, but only a get accessor for read-only settings.

  • Eingebundene Attribute müssen auf die öffentlichen Eigenschaften der Wrapper Klasse angewendet werden, um die Eigenschaften der Einstellungs Eigenschaft anzugeben, z. b. den Bereich der Einstellung (Anwendung oder Benutzer), ob die Einstellung Roaming unterstützen soll, den Standardwert für die Einstellung, den zu verwendenden Einstellungs Anbieter usw.Appropriated attributes must be applied to the wrapper class's public properties to indicate characteristics of the settings property, such as the setting's scope (application or user), whether the setting should support roaming, the default value for the setting, the settings provider to be used, and so on. Jede Eigenschaft ist erforderlich, um Ihren Bereich mithilfe von ApplicationScopedSettingAttribute oder anzugeben UserScopedSettingAttribute .Each property is required to specify its scope, using either ApplicationScopedSettingAttribute or UserScopedSettingAttribute. Anwendungsspezifische Einstellungen sind schreibgeschützt, wenn die Standardeinstellung LocalFileSettingsProvider verwendet wird.Application-scoped settings are read-only if the default LocalFileSettingsProvider is used.

Die- ApplicationSettingsBase Klasse verwendet Reflektion, um diese Attribute zur Laufzeit zu erkennen.The ApplicationSettingsBase class uses reflection to detect these attributes at run time. Die meisten dieser Informationen werden an die Einstellungs Anbieter Schicht weitergeleitet, die für die Speicherung, das Persistenzformat usw. zuständig ist.Most of this information gets passed to the settings provider layer, which is responsible for storage, persistence format, and so on.

Wenn eine Anwendung über mehrere Wrapper Klassen für Einstellungen verfügt, definiert jede Klasse eine Einstellungs Gruppe.When an application has multiple settings wrapper classes, each class defines a settings group. Jede Gruppe verfügt über die folgenden Eigenschaften:Each group has the following characteristics:

  • Eine Gruppe kann eine beliebige Anzahl oder einen beliebigen Typ von Eigenschafts Einstellungen enthalten.A group can contain any number or type of property settings.

  • Wenn der Gruppenname nicht explizit durch das Dekorieren der Wrapper Klasse mit einem festgelegt wird SettingsGroupNameAttribute , wird automatisch ein Name generiert.If the group name is not explicitly set by the decorating the wrapper class with a SettingsGroupNameAttribute, then a name is automatically generated.

Standardmäßig verwenden alle Client basierten Anwendungen den LocalFileSettingsProvider , um Speicher bereitzustellen.By default, all client-based applications use the LocalFileSettingsProvider to provide storage. Wenn ein alternativer Einstellungs Anbieter gewünscht ist, muss die Wrapper Klasse bzw.-Eigenschaft mit einem entsprechenden versehen werden SettingsProviderAttribute .If an alternate settings provider is desired, then the wrapper class or property must be decorated with a corresponding SettingsProviderAttribute.

Weitere Informationen zum Verwenden von Anwendungseinstellungen finden Sie unter Anwendungseinstellungen für Windows Forms.For more information about using application settings, see Application Settings for Windows Forms.

Konstruktoren

ApplicationSettingsBase()

Initialisiert eine Instanz der ApplicationSettingsBase-Klasse mit ihrem Standardzustand.Initializes an instance of the ApplicationSettingsBase class to its default state.

ApplicationSettingsBase(IComponent)

Initialisiert mithilfe der angegebenen Besitzerkomponente eine Instanz der ApplicationSettingsBase-Klasse.Initializes an instance of the ApplicationSettingsBase class using the supplied owner component.

ApplicationSettingsBase(IComponent, String)

Initialisiert mithilfe der angegebenen Besitzerkomponente und des Einstellungsschlüssels eine Instanz der ApplicationSettingsBase-Klasse.Initializes an instance of the ApplicationSettingsBase class using the supplied owner component and settings key.

ApplicationSettingsBase(String)

Initialisiert mithilfe des angegebenen Einstellungsschlüssels eine Instanz der ApplicationSettingsBase-Klasse.Initializes an instance of the ApplicationSettingsBase class using the supplied settings key.

Eigenschaften

Context

Ruft den der Einstellungsgruppe zugeordneten Anwendungseinstellungskontext ab.Gets the application settings context associated with the settings group.

IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf das Objekt synchronisiert (threadsicher) ist.Gets a value indicating whether access to the object is synchronized (thread safe).

(Geerbt von SettingsBase)
Item[String]

Ruft den Wert der angegebenen Anwendungseinstellungseigenschaft ab oder legt diesen fest.Gets or sets the value of the specified application settings property.

Properties

Ruft die Auflistung der Einstellungseigenschaften im Wrapper ab.Gets the collection of settings properties in the wrapper.

PropertyValues

Ruft eine Auflistung von Eigenschaftswerten ab.Gets a collection of property values.

Providers

Ruft die Auflistung der vom Wrapper verwendeten Anwendungseinstellungsanbieter ab.Gets the collection of application settings providers used by the wrapper.

SettingsKey

Ruft den Einstellungsschlüssel für die Anwendungseinstellungsgruppe ab oder legt ihn fest.Gets or sets the settings key for the application settings group.

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Geerbt von Object)
GetPreviousVersion(String)

Gibt den Wert der benannten Einstellungseigenschaft für die vorherige Version derselben Anwendung zurück.Returns the value of the named settings property for the previous version of the same application.

GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

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

Initialisiert vom SettingsBase-Objekt verwendete interne Eigenschaften.Initializes internal properties used by SettingsBase object.

(Geerbt von SettingsBase)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
OnPropertyChanged(Object, PropertyChangedEventArgs)

Löst das PropertyChanged-Ereignis aus.Raises the PropertyChanged event.

OnSettingChanging(Object, SettingChangingEventArgs)

Löst das SettingChanging-Ereignis aus.Raises the SettingChanging event.

OnSettingsLoaded(Object, SettingsLoadedEventArgs)

Löst das SettingsLoaded-Ereignis aus.Raises the SettingsLoaded event.

OnSettingsSaving(Object, CancelEventArgs)

Löst das SettingsSaving-Ereignis aus.Raises the SettingsSaving event.

Reload()

Aktualisiert die Werte der Anwendungseinstellungseigenschaft aus dem permanenten Speicher.Refreshes the application settings property values from persistent storage.

Reset()

Stellt die beibehaltenen Anwendungseinstellungswerte mit den entsprechenden Standardeigenschaften wieder her.Restores the persisted application settings values to their corresponding default properties.

Save()

Speichert die aktuellen Werte der Anwendungseinstellungseigenschaften.Stores the current values of the application settings properties.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Geerbt von Object)
Upgrade()

Aktualisiert Anwendungseinstellungen, um eine aktuellere Installation der Anwendung wiederzugeben.Updates application settings to reflect a more recent installation of the application.

Ereignisse

PropertyChanged

Tritt ein, nachdem der Wert einer Anwendungseinstellungseigenschaft geändert wurde.Occurs after the value of an application settings property is changed.

SettingChanging

Tritt ein, bevor der Wert einer Anwendungseinstellungseigenschaft geändert wurde.Occurs before the value of an application settings property is changed.

SettingsLoaded

Tritt ein, nachdem die Anwendungseinstellungen vom Speicher abgerufen worden sind.Occurs after the application settings are retrieved from storage.

SettingsSaving

Tritt ein, bevor Werte im Datenspeicher gespeichert werden.Occurs before values are saved to the data store.

Gilt für:

Weitere Informationen