Condividi tramite


ApplicationSettingsBase Classe

Definizione

Funge da classe base da cui derivare le classi wrapper concrete per l'implementazione della funzionalità relativa alle impostazioni dell'applicazione nelle applicazioni Windows Form.

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
Ereditarietà
ApplicationSettingsBase
Implementazioni

Esempio

Nell'esempio di codice seguente viene illustrato l'uso delle impostazioni dell'applicazione per rendere persistenti gli attributi seguenti del modulo principale: posizione, dimensioni, colore di sfondo e testo della barra del titolo. Tutti questi attributi vengono mantenuti come proprietà delle singole impostazioni dell'applicazione nella FormSettings classe, denominata FormLocation, FormBackColorFormSizee FormText, rispettivamente. Tutti ad eccezione FormText di e Size sono dati associati alle proprietà del modulo associate e hanno un valore di impostazione predefinito applicato usando DefaultSettingValueAttribute.

Il modulo contiene quattro controlli figlio con i nomi e le funzioni seguenti:

  • Pulsante denominato btnBackColor utilizzato per visualizzare la finestra di dialogo Colore comune.

  • Pulsante denominato btnReload usato per Reload le impostazioni dell'applicazione.

  • Pulsante denominato btnReset usato per Reset le impostazioni dell'applicazione.

  • Casella di testo denominata tbStatus utilizzata per visualizzare le informazioni sullo stato del programma.

Si noti che dopo ogni esecuzione dell'applicazione, viene aggiunto un carattere di periodo aggiuntivo al testo del titolo del modulo.

Questo esempio di codice richiede un modulo con una ColorDialog classe denominata colorDialog1e un StatusStrip controllo con un ToolStripStatusLabel oggetto denominato tbStatus. Inoltre, richiede tre Button oggetti denominati btnReload, btnResete 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

Commenti

ApplicationSettingsBase aggiunge la funzionalità seguente alla SettingsBase classe, usata dalle applicazioni basate sul Web:

  • Possibilità di rilevare gli attributi in una classe wrapper derivata e di impostazioni. ApplicationSettingsBase supporta il modello dichiarativo usato per le proprietà della classe wrapper, come descritto più avanti.

  • Metodi e Reload di livello Save superiore.

  • Eventi di convalida aggiuntivi che è possibile gestire per garantire la correttezza delle singole impostazioni.

Nell'architettura delle impostazioni dell'applicazione per accedere a un gruppo di proprietà delle impostazioni è necessario derivare una classe wrapper concreta da ApplicationSettingsBase. La classe wrapper personalizza ApplicationSettingsBase nei modi seguenti:

  • Per accedere a ogni proprietà delle impostazioni, viene aggiunta una proprietà pubblica fortemente tipizzata corrispondente alla classe wrapper. Questa proprietà include get e set funzioni di accesso per le impostazioni dell'applicazione di lettura/scrittura, ma solo una get funzione di accesso per le impostazioni di sola lettura.

  • Gli attributi appropriati devono essere applicati alle proprietà pubbliche della classe wrapper per indicare le caratteristiche della proprietà delle impostazioni, ad esempio l'ambito dell'impostazione (applicazione o utente), se l'impostazione deve supportare il roaming, il valore predefinito per l'impostazione, il provider di impostazioni da usare e così via. Ogni proprietà è necessaria per specificare l'ambito, usando ApplicationScopedSettingAttribute o UserScopedSettingAttribute. Le impostazioni con ambito applicazione sono di sola lettura se viene usato il valore predefinito LocalFileSettingsProvider .

La ApplicationSettingsBase classe usa la reflection per rilevare questi attributi in fase di esecuzione. La maggior parte di queste informazioni viene passata al livello del provider di impostazioni, responsabile dell'archiviazione, del formato di persistenza e così via.

Quando un'applicazione dispone di più classi wrapper delle impostazioni, ogni classe definisce un gruppo di impostazioni. Ogni gruppo presenta le caratteristiche seguenti:

  • Un gruppo può contenere qualsiasi numero o tipo di impostazioni delle proprietà.

  • Se il nome del gruppo non è impostato in modo esplicito dalla classe wrapper con un SettingsGroupNameAttributeoggetto , viene generato automaticamente un nome.

Per impostazione predefinita, tutte le applicazioni basate su client usano per fornire l'archiviazione LocalFileSettingsProvider . Se si desidera un provider di impostazioni alternativo, la classe o la proprietà wrapper devono essere decorati con un oggetto corrispondente SettingsProviderAttribute.

Per altre informazioni sull'uso delle impostazioni dell'applicazione, vedere Impostazioni applicazione per Windows Forms.

Costruttori

ApplicationSettingsBase()

Inizializza un'istanza della classe ApplicationSettingsBase sullo stato predefinito.

ApplicationSettingsBase(IComponent)

Inizializza un'istanza della classe ApplicationSettingsBase mediante il componente proprietario specificato.

ApplicationSettingsBase(IComponent, String)

Inizializza un'istanza della classe ApplicationSettingsBase mediante il componente proprietario e la chiave delle impostazioni specificati.

ApplicationSettingsBase(String)

Inizializza un'istanza della classe ApplicationSettingsBase mediante la chiave delle impostazioni specificata.

Proprietà

Context

Ottiene il contesto delle impostazioni dell'applicazione associato al gruppo di impostazioni.

IsSynchronized

Ottiene un valore che indica se l'accesso all'oggetto è sincronizzato (thread-safe).

(Ereditato da SettingsBase)
Item[String]

Ottiene o imposta il valore della proprietà delle impostazioni dell'applicazione specificata.

Properties

Ottiene l'insieme di proprietà delle impostazioni nel wrapper.

PropertyValues

Ottiene un insieme di valori di proprietà.

Providers

Ottiene l'insieme di provider di impostazioni dell'applicazione utilizzati dal wrapper.

SettingsKey

Ottiene o imposta la chiave delle impostazioni per il gruppo di impostazioni dell'applicazione.

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetPreviousVersion(String)

Restituisce il valore della proprietà delle impostazioni denominata relativa alla versione precedente della stessa applicazione.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
Initialize(SettingsContext, SettingsPropertyCollection, SettingsProviderCollection)

Inizializza le proprietà interne utilizzate dall'oggetto SettingsBase.

(Ereditato da SettingsBase)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
OnPropertyChanged(Object, PropertyChangedEventArgs)

Genera l'evento PropertyChanged.

OnSettingChanging(Object, SettingChangingEventArgs)

Genera l'evento SettingChanging.

OnSettingsLoaded(Object, SettingsLoadedEventArgs)

Genera l'evento SettingsLoaded.

OnSettingsSaving(Object, CancelEventArgs)

Genera l'evento SettingsSaving.

Reload()

Aggiorna i valori della proprietà delle impostazioni dell'applicazione dall'archivio permanente.

Reset()

Ripristina le corrispondenti proprietà predefinite dei valori delle impostazioni dell'applicazione resi permanenti.

Save()

Memorizza i valori correnti delle proprietà delle impostazioni dell'applicazione.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
Upgrade()

Aggiorna le impostazioni dell'applicazione in modo da riflettere un'installazione più recente dell'applicazione.

Eventi

PropertyChanged

Si verifica dopo la modifica del valore di una proprietà delle impostazioni dell'applicazione.

SettingChanging

Si verifica prima della modifica del valore di una proprietà delle impostazioni dell'applicazione.

SettingsLoaded

Si verifica dopo il recupero delle impostazioni dell'applicazione dall'archivio.

SettingsSaving

Si verifica prima del salvataggio dei valori nell'archivio dati.

Si applica a

Vedi anche