Architettura di Impostazioni applicazione

  • Articolo

Questo argomento descrive il funzionamento dell'architettura Impostazioni applicazione e ne analizza le funzionalità avanzate, come i raggruppamenti e le chiavi delle impostazioni.

L'architettura di Impostazioni applicazione supporta la definizione delle impostazioni fortemente tipizzate con ambito di applicazione o utente e la persistenza delle impostazioni tra sessioni dell'applicazione. L'architettura fornisce un motore di persistenza predefinito per salvare le impostazioni e caricarle dal file system locale. L'architettura definisce inoltre le interfacce per offrire un motore di persistenza personalizzato.

Si tratta di interfacce che consentono ai componenti personalizzati di mantenere le proprie impostazioni quando sono ospitati in un'applicazione. Usando le chiavi delle impostazioni, i componenti possono mantenere le impostazioni per più istanze del componente separato.

Definizione delle impostazioni

L'architettura delle impostazioni dell'applicazione viene usata sia all'interno di ASP.NET che di Windows Form e contiene una serie di classi di base condivise in entrambi gli ambienti. L'aspetto più importante è SettingsBase, che fornisce l'accesso alle impostazioni tramite una raccolta e fornisce metodi di basso livello per il caricamento e il salvataggio delle impostazioni. Ogni ambiente implementa la propria classe derivata da SettingsBase per fornire funzionalità aggiuntive per tale ambiente. In un'applicazione basata su Windows Form, tutte le impostazioni dell'applicazione devono essere definite in una classe derivata dalla ApplicationSettingsBase classe , che aggiunge le funzionalità seguenti alla classe base:

  • Caricamento e salvataggio delle operazioni di livello superiore

  • Supporto per le impostazioni con ambito utente

  • Ripristino delle impostazioni dell'utente alle impostazioni predefinite

  • Aggiornamento delle impostazioni da una versione precedente dell'applicazione

  • Convalida delle impostazioni, prima che vengano modificate o prima che vengano salvate

Le impostazioni possono essere descritte usando una serie di attributi definiti all'interno dello System.Configuration spazio dei nomi. Tali attributi sono descritti in Attributi Impostazioni applicazione. Quando si definisce un'impostazione, è necessario applicarla con ApplicationScopedSettingAttribute o UserScopedSettingAttribute, che descrive se l'impostazione si applica all'intera applicazione o solo all'utente corrente.

L'esempio di codice seguente definisce una classe di impostazioni personalizzate con una singola impostazione, BackgroundColor.

using System;
using System.Configuration;
using System.Drawing;

public class MyUserSettings : ApplicationSettingsBase
{
    [UserScopedSetting()]
    [DefaultSettingValue("white")]
    public Color BackgroundColor
    {
        get
        {
            return ((Color)this["BackgroundColor"]);
        }
        set
        {
            this["BackgroundColor"] = (Color)value;
        }
    }
}

Imports System.Configuration

Public Class MyUserSettings
    Inherits ApplicationSettingsBase
    <UserScopedSetting()> _
    <DefaultSettingValue("white")> _
    Public Property BackgroundColor() As Color
        Get
            BackgroundColor = Me("BackgroundColor")
        End Get

        Set(ByVal value As Color)
            Me("BackgroundColor") = value
        End Set
    End Property
End Class

Persistenza delle impostazioni

La ApplicationSettingsBase classe non mantiene o carica le impostazioni. Questo processo rientra nel provider di impostazioni, una classe che deriva da SettingsProvider. Se una classe derivata di non specifica un provider di ApplicationSettingsBase impostazioni tramite SettingsProviderAttribute, viene usato il provider predefinito , LocalFileSettingsProvider.

Il sistema di configurazione rilasciato originariamente con .NET Framework supporta la fornitura di dati di configurazione dell'applicazione statici tramite il file machine.config del computer locale o all'interno di un app.file exe.config distribuito con l'applicazione. La LocalFileSettingsProvider classe espande questo supporto nativo nei modi seguenti:

  • Le impostazioni con ambito applicazione possono essere archiviate in entrambi i file machine.config o app.exe.config. Il file machine.config è sempre di sola lettura, mentre app.exe.config è limitato dalle considerazioni sulla sicurezza alla sola lettura per la maggior parte delle applicazioni.

  • Le impostazioni con ambito di utente possono essere archiviate in app.exe.config, in questo caso vengono considerate come valori predefiniti statici.

  • Le impostazioni con ambito utente non predefinite vengono archiviate in un nuovo file, user.config. È possibile specificare un valore predefinito per un'impostazione con ambito utente con DefaultSettingValueAttribute. Poiché le impostazioni con ambito utente cambiano spesso durante l'esecuzione dell'applicazione, user.config è sempre di lettura/scrittura. Per altre informazioni, vedere Dove sono archiviate le impostazioni con ambito utente.

I tre file di configurazione archiviano le impostazioni in formato XML. L'elemento XML di livello superiore per le impostazioni con ambito di applicazione è <appSettings>, mentre <userSettings> viene usato per le impostazioni con ambito di utente. Un file app.exe.config che contiene sia le impostazioni con ambito di applicazione che quelle predefinite per le impostazioni con ambito utente si presenta come segue:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <sectionGroup name="applicationSettings" type="System.Configuration.ApplicationSettingsGroup, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
            <section name="WindowsApplication1.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
        </sectionGroup>
        <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
            <section name="WindowsApplication1.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" />
        </sectionGroup>
    </configSections>
    <applicationSettings>
        <WindowsApplication1.Properties.Settings>
            <setting name="Cursor" serializeAs="String">
                <value>Default</value>
            </setting>
            <setting name="DoubleBuffering" serializeAs="String">
                <value>False</value>
            </setting>
        </WindowsApplication1.Properties.Settings>
    </applicationSettings>
    <userSettings>
        <WindowsApplication1.Properties.Settings>
            <setting name="FormTitle" serializeAs="String">
                <value>Form1</value>
            </setting>
            <setting name="FormSize" serializeAs="String">
                <value>595, 536</value>
            </setting>
        </WindowsApplication1.Properties.Settings>
    </userSettings>
</configuration>

Per una definizione degli elementi all'interno della sezione di impostazioni applicazione di un file di configurazione, vedere Application Settings Schema (Schema di impostazioni applicazione).

Associazioni delle impostazioni

Le impostazioni applicazione usano l'architettura di associazione dati di Windows Form per consentire la comunicazione bidirezionale degli aggiornamenti delle impostazioni tra i componenti e l'oggetto impostazioni. Se si usa Visual Studio per creare le impostazioni dell'applicazione e assegnarle alle proprietà del componente, queste associazioni vengono generate automaticamente.

È possibile associare un'impostazione dell'applicazione solo a un componente che supporta l'interfaccia IBindableComponent . Inoltre, il componente deve implementare un evento di modifica per una proprietà associata specifica o notificare alle impostazioni dell'applicazione che la proprietà è stata modificata tramite l'interfaccia INotifyPropertyChanged . Se il componente non implementa IBindableComponent e si esegue l'associazione tramite Visual Studio, le proprietà associate verranno impostate la prima volta, ma non verranno aggiornate. Se il componente implementa IBindableComponent ma non supporta le notifiche di modifica delle proprietà, l'associazione non verrà aggiornata nel file di impostazioni quando la proprietà viene modificata.

Alcuni componenti Windows Form, ad esempio ToolStripItem, non supportano le associazioni di impostazioni.

Serializzazione delle impostazioni

Quando LocalFileSettingsProvider è necessario salvare le impostazioni su disco, esegue le azioni seguenti:

  1. Usa la reflection per esaminare tutte le proprietà definite nella ApplicationSettingsBase classe derivata, individuando quelle applicate con ApplicationScopedSettingAttribute o UserScopedSettingAttribute.

  2. Serializza la proprietà su disco. Tenta prima di tutto di chiamare o ConvertToStringConvertFromString sull'oggetto associato TypeConverteral tipo . Se il tentativo non riesce, usa la serializzazione XML.

  3. Determina quali impostazioni vanno inserite in ciascun file, in base all'attributo dell'impostazione.

Se si implementa una classe di impostazioni personalizzata, è possibile usare per contrassegnare un'impostazione SettingsSerializeAsAttribute per la serializzazione binaria o personalizzata usando l'enumerazione SettingsSerializeAs . Per altre informazioni sulla creazione della propria classe di impostazioni nel codice, vedere How to: Create Application Settings (Procedura: creare impostazioni applicazioni).

Percorsi del file delle installazioni

Il percorso dei file app.exe.config e user.config variano in base alle modalità di installazione dell'applicazione. Per un'applicazione basata su Windows Form copiata nel computer locale, app.exe.config si troverà nella stessa directory della directory di base del file eseguibile principale dell'applicazione e user.config risiederà nel percorso specificato dalla Application.LocalUserAppDataPath proprietà . Per un'applicazione installata tramite ClickOnce, entrambi questi file si troveranno nella directory dei dati ClickOnce sotto %InstallRoot%\Documents e Impostazioni\username\Local Impostazioni.

Il percorso di archiviazione di questi file è leggermente diverso se un utente ha abilitato i profili mobili, che consente a un utente di definire impostazioni diverse di Windows e dell'applicazione quando usano altri computer all'interno di un dominio. In tal caso, sia le applicazioni ClickOnce che le applicazioni non ClickOnce avranno i file appcon estensione exe.config e user.config archiviati in %InstallRoot%\Documents e Impostazioni\username\Application Data.

Per altre informazioni sul funzionamento delle funzioni di Impostazioni applicazione con la nuova tecnologia di distribuzione, vedere Impostazioni dell'applicazione e ClickOnce. Per altre informazioni sulla directory dei dati ClickOnce, vedere Accesso ai dati locali e remoti nelle applicazioni ClickOnce.

Impostazioni e sicurezza dell'applicazione

Le impostazioni dell'applicazione sono progettate per funzionare in attendibilità parziale, un ambiente con restrizioni predefinito per le applicazioni di Windows Form ospitate in Internet o intranet. Non sono necessarie autorizzazioni speciali oltre all'attendibilità parziale per usare le impostazioni dell'applicazione con il provider di impostazioni predefinito.

Quando le impostazioni dell'applicazione vengono usate in un'applicazione ClickOnce, il userfile config viene archiviato nella directory dei dati ClickOnce. Le dimensioni del file config dell'applicazione usernon possono superare la quota di directory dati impostata da ClickOnce. Per altre informazioni, vedere Impostazioni dell'applicazione e ClickOnce.

Provider di impostazioni personalizzate

Nell'architettura application Impostazioni esiste un accoppiamento libero tra la classe wrapper delle impostazioni delle applicazioni, derivata da ApplicationSettingsBasee il provider o i provider di impostazioni associati, derivati da SettingsProvider. Questa associazione viene definita solo dall'oggetto SettingsProviderAttribute applicato alla classe wrapper o alle relative singole proprietà. Se un provider di impostazioni non viene specificato in modo esplicito, viene usato il provider predefinito , LocalFileSettingsProvider. Di conseguenza, questa architettura supporta la creazione e l'uso di provider di impostazioni personalizzate.

Si supponga, ad esempio, di voler sviluppare e usare SqlSettingsProvider, un provider che archivierà tutti i dati delle impostazioni in un database Microsoft SQL Server. La SettingsProviderclasse derivata da riceverà queste informazioni nel relativo Initialize metodo come parametro di tipo System.Collections.Specialized.NameValueCollection. Si implementerà quindi il GetPropertyValues metodo per recuperare le impostazioni dall'archivio dati e SetPropertyValues salvarle. Il provider può usare l'oggetto SettingsPropertyCollection fornito per GetPropertyValues determinare il nome, il tipo e l'ambito della proprietà, nonché qualsiasi altro attributo di impostazioni definito per tale proprietà.

Il provider dovrà implementare una proprietà e un metodo le cui implementazioni possono non essere evidenti. La ApplicationName proprietà è una proprietà astratta di SettingsProvider. È necessario programmarla per restituire quanto segue:

public override string ApplicationName
{
    get
    {
        return (System.Reflection.Assembly.GetExecutingAssembly().GetName().Name);
    }
    set
    {
        // Do nothing.
    }
}

Public Overrides Property ApplicationName() As String
    Get
        ApplicationName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
    End Get
    Set(ByVal value As String)
        ' Do nothing.
    End Set
End Property

La classe derivata deve implementare anche un metodo Initialize che non accetta argomenti e non restituisce alcun valore. Questo metodo non è definito da SettingsProvider.

Infine, si implementa IApplicationSettingsProvider nel provider per fornire supporto per aggiornare le impostazioni, ripristinare le impostazioni predefinite e aggiornare le impostazioni da una versione dell'applicazione a un'altra.

Dopo aver implementato e compilato il provider, è necessario istruire una classe di impostazioni affinché usi questo provider invece di quello predefinito. A tale scopo, eseguire questa operazione tramite .SettingsProviderAttribute Se applicato a un'intera classe di impostazioni, il provider viene usato per ogni impostazione definita dalla classe ; se applicato alle singole impostazioni, l'architettura Impostazioni dell'applicazione usa tale provider solo per tali impostazioni e usa LocalFileSettingsProvider per il resto. L'esempio di codice seguente illustra come indicare alla classe di impostazioni l'uso del provider personalizzato.

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;

namespace ApplicationSettingsArchitectureCS
{
    [SettingsProvider("SqlSettingsProvider")]
    class CustomSettings : ApplicationSettingsBase
    {
        // Implementation goes here.
    }
}

Imports System.Configuration

<SettingsProvider("SqlSettingsProvider")> _
Public Class CustomSettings
    Inherits ApplicationSettingsBase

    ' Implementation goes here.
End Class

Un provider può essere chiamato da più thread contemporaneamente, ma scriverà sempre nello stesso percorso di archiviazione; pertanto l'architettura di Impostazioni applicazione creerà sempre una sola istanza della classe del provider.

Importante

È necessario assicurarsi che il provider sia thread-safe e che consenta solo a un thread alla volta di scrivere i file di configurazione.

Il provider non deve supportare tutti gli attributi delle impostazioni definiti nello System.Configuration spazio dei nomi, anche se deve supportare almeno ApplicationScopedSettingAttribute e UserScopedSettingAttributee deve anche supportare DefaultSettingValueAttribute. Per gli attributi che non supporta, il provider deve semplicemente dare esito negativo senza notifica e non deve generare un'eccezione. Se la classe settings usa una combinazione non valida di attributi, ad esempio l'applicazione ApplicationScopedSettingAttribute e UserScopedSettingAttribute la stessa impostazione, il provider deve generare un'eccezione e interrompere l'operazione.

Vedi anche