Condividi tramite

Architettura delle impostazioni dell'applicazione

  • Articolo

Questo argomento descrive il funzionamento dell'architettura delle impostazioni dell'applicazione ed esplora le funzionalità avanzate dell'architettura, ad esempio le impostazioni raggruppate e le chiavi delle impostazioni.

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

Le interfacce vengono fornite che consentono ai componenti personalizzati di rendere persistenti le proprie impostazioni quando sono ospitate in un'applicazione. Usando le chiavi delle impostazioni, i componenti possono mantenere le impostazioni per più istanze del componente separate.

Definizione delle impostazioni

L'architettura delle impostazioni dell'applicazione viene usata sia in ASP.NET che in 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 l'ambiente stesso. In un'applicazione basata su Windows Form, tutte le impostazioni dell'applicazione devono essere definite in una classe derivata dalla classe ApplicationSettingsBase, che aggiunge le funzionalità seguenti alla classe base:

  • Operazioni di caricamento e salvataggio di livello superiore

  • Supporto per le impostazioni con ambito utente

  • Ripristino delle impostazioni predefinite di un utente

  • 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 spazio dei nomi System.Configuration; questi sono descritti in Attributi delle impostazioni dell'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.

Nell'esempio di codice seguente viene definita 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 classe ApplicationSettingsBase non mantiene o carica le impostazioni; questo processo rientra nel provider di impostazioni, una classe che deriva da SettingsProvider. Se una classe derivata di ApplicationSettingsBase non specifica un provider di impostazioni tramite il 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 di machine.config del computer locale o all'interno di un file app.exe.config distribuito con l'applicazione. La classe LocalFileSettingsProvider espande questo supporto nativo nei modi seguenti:

  • Le impostazioni con ambito applicazione possono essere archiviate nei file machine.config o app.exe.config. Machine.config è sempre di sola lettura, mentre l'accesso a app.exe.config è limitato a sola lettura per la maggior parte delle applicazioni a causa di considerazioni sulla sicurezza.

  • Le impostazioni con ambito utente possono essere archiviate in app.exe.config file, nel qual caso vengono considerate come impostazioni predefinite statiche.

  • 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 leggibile e scrivibile. Per ulteriori informazioni, vedere Dove sono memorizzate le impostazioni con ambito utente.

Tutti e tre i file di configurazione archivia le impostazioni in formato XML. L'elemento XML di primo livello per le impostazioni con ambito applicazione è <appSettings>, mentre <userSettings> viene usato per le impostazioni con ambito utente. Un file app.exe.config che contiene impostazioni con ambito applicazione e impostazioni predefinite per le impostazioni con ambito utente sarà simile al seguente:

<?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 delle impostazioni dell'applicazione di un file di configurazione, vedere schema delle impostazioni dell'applicazione.

Collegamenti delle impostazioni

Le impostazioni dell'applicazione usano l'architettura di associazione dati di Windows Form per fornire la comunicazione bidirezionale degli aggiornamenti delle impostazioni tra l'oggetto impostazioni e i componenti. 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 di Windows Form, ad esempio ToolStripItem, non supportano le associazioni di impostazioni.

Serializzazione delle impostazioni

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

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

  2. Serializza la proprietà su disco. Tenta dapprima di chiamare il ConvertToString o il ConvertFromString sul TypeConverterassociato al tipo. Se l'operazione non riesce, usa invece la serializzazione XML.

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

Se si implementa una classe di impostazioni personalizzata, è possibile usare il SettingsSerializeAsAttribute per contrassegnare un'impostazione per la serializzazione binaria o personalizzata usando l'enumerazione SettingsSerializeAs. Per altre informazioni sulla creazione di una classe di impostazioni personalizzata nel codice, vedere Procedura: Creare impostazioni applicazione.

Posizioni dei file di impostazioni

Il percorso dei file di app.exe.config e utente.config varia in base alla modalità di installazione dell'applicazione. Per un'applicazione basata su Windows Forms copiata nel computer locale, app.exe.config risiederà nella stessa directory della directory di base del file eseguibile principale dell'applicazione e l'utente .config risiederà nel percorso specificato dalla proprietà Application.LocalUserAppDataPath. Per un'applicazione installata tramite ClickOnce, entrambi questi file si trovano nella directory dei dati ClickOnce sotto %InstallRoot%\Documents and Settings\nome utente\Impostazioni locali.

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 questo caso, sia le applicazioni ClickOnce che le applicazioni non ClickOnce avranno i file utente app.exe.config e .config memorizzati in %InstallRoot%\Documents and Settings\nome utente\Application Data.

Per altre informazioni sul funzionamento della funzionalità Impostazioni applicazione con la nuova tecnologia di distribuzione, vedere ClickOnce e Impostazioni applicazione. Per ulteriori informazioni sulla Directory dei Dati di ClickOnce, consultare la sezione Accesso ai dati locali e remoti nelle applicazioni ClickOnce.

Impostazioni e sicurezza dell'applicazione

Le impostazioni dell'applicazione sono progettate per funzionare con attendibilità parziale, un ambiente con restrizioni che rappresenta l'impostazione predefinita per le applicazioni Windows Form ospitate su Internet o intranet. Non sono necessarie autorizzazioni speciali oltre l'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 file user.config viene archiviato nella directory dei dati ClickOnce. Le dimensioni del file user.config dell'applicazione non possono superare la quota della cartella dei dati impostata da ClickOnce. Per altre informazioni, vedere ClickOnce e Impostazioni dell'applicazione.

Provider di impostazioni personalizzate

Nell'architettura delle impostazioni dell'applicazione 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 dalla SettingsProviderAttribute applicata alla classe wrapper o alle relative singole proprietà. Se non viene specificato in modo esplicito un provider di impostazioni, viene usato il provider predefinito LocalFileSettingsProvider. Di conseguenza, questa architettura supporta la creazione e l'uso di provider di impostazioni personalizzati.

Si supponga, ad esempio, di voler sviluppare e usare SqlSettingsProvider, un provider che archivierà tutti i dati delle impostazioni in un database di Microsoft SQL Server. La classe derivata da SettingsProviderriceverà queste informazioni nel relativo metodo Initialize come parametro di tipo System.Collections.Specialized.NameValueCollection. Si implementerà quindi il metodo GetPropertyValues per recuperare le impostazioni dall'archivio dati e SetPropertyValues per salvarle. Il provider può usare il SettingsPropertyCollection fornito per GetPropertyValues per 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 potrebbero non essere ovvie. La proprietà ApplicationName è una proprietà astratta di SettingsProvider; è consigliabile programmarlo 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 anche implementare un metodo Initialize che non accetta argomenti e non restituisce alcun valore. Questo metodo non è definito da SettingsProvider.

Infine, si implementa IApplicationSettingsProvider nel tuo provider per fornire supporto nell'aggiornamento delle impostazioni, nel ripristino alle impostazioni predefinite e nell'upgrade delle impostazioni da una versione dell'applicazione a un'altra.

Dopo aver implementato e compilato il provider, è necessario indicare alla classe delle impostazioni di usare questo provider anziché il valore predefinito. Si ottiene questo tramite il 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 delle impostazioni dell'applicazione usa tale provider solo per tali impostazioni e usa LocalFileSettingsProvider per il resto. Nell'esempio di codice seguente viene illustrato come indicare alla classe settings di usare il 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 spazio di archiviazione; pertanto, l'architettura delle impostazioni dell'applicazione istanzierà sempre una sola istanza della classe del provider.

Importante

È necessario assicurarsi che il provider sia thread-safe e permetta l'accesso in scrittura ai file di configurazione a un solo thread alla volta.

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

Vedere anche