Arkitektur för programinställningar

Artikel
12/17/2024

Det här avsnittet beskriver hur arkitekturen Programinställningar fungerar och utforskar avancerade funktioner i arkitekturen, till exempel grupperade inställningar och inställningsnycklar.

Arkitekturen för programinställningar har stöd för att definiera starkt skrivna inställningar med program- eller användaromfång och spara inställningarna mellan programsessioner. Arkitekturen tillhandahåller en standardmotor för beständighet för att spara inställningar till och läsa in dem från det lokala filsystemet. Arkitekturen definierar även gränssnitt för att tillhandahålla en anpassad beständighetsmotor.

Gränssnitt tillhandahålls som gör det möjligt för anpassade komponenter att spara sina egna inställningar när de finns i ett program. Med hjälp av inställningsnycklar kan komponenterna hålla inställningarna för flera instanser av komponenten åtskilda.

Definiera inställningar

Arkitekturen för programinställningar används i både ASP.NET och Windows Forms och innehåller ett antal basklasser som delas i båda miljöerna. Det viktigaste är SettingsBase, som ger åtkomst till inställningar via en samling och tillhandahåller metoder på låg nivå för inläsning och sparande av inställningar. Varje miljö implementerar sin egen klass härledd från SettingsBase för att tillhandahålla ytterligare inställningsfunktioner för den miljön. I ett Windows Forms-baserat program måste alla programinställningar definieras på en klass som härleds från klassen ApplicationSettingsBase, vilket lägger till följande funktioner i basklassen:

Åtgärder för att läsa in och spara på högre nivå
Stöd för användarspecifika inställningar
Återställa en användares inställningar till de fördefinierade standardinställningarna
Uppgradera inställningar från en tidigare programversion
Verifiera inställningarna, antingen innan de ändras eller innan de sparas

Inställningarna kan beskrivas med hjälp av ett antal attribut som definierats i System.Configuration namnrymd, och dessa beskrivs i applikationsinställningsattribut. När du definierar en inställning måste du använda den med antingen ApplicationScopedSettingAttribute eller UserScopedSettingAttribute, som beskriver om inställningen gäller för hela programmet eller bara för den aktuella användaren.

I följande kodexempel definieras en anpassad inställningsklass med en enda inställning, 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

Beständighet för inställningar

Klassen ApplicationSettingsBase lagrar inte själv eller laddar in inställningar; detta jobb faller på inställningsleverantören, en klass som ärvd från SettingsProvider. Om en härledd klass av ApplicationSettingsBase inte anger någon inställningsprovider via SettingsProviderAttributeanvänds standardprovidern LocalFileSettingsProvider.

Konfigurationssystemet som ursprungligen släpptes med .NET Framework har stöd för att tillhandahålla statiska programkonfigurationsdata via antingen den lokala datorns machine.config-fil eller i en app.exe.config fil som du distribuerar med ditt program. Klassen LocalFileSettingsProvider utökar det här interna stödet på följande sätt:

Inställningar med programomfattning kan lagras i antingen machine.config- eller app.exe.config-filerna. Machine.config är alltid skrivskyddad, medan app.exe.config begränsas till skrivskyddade av säkerhetsskäl för de flesta applikationer.
Inställningar med användaromfattning kan lagras i app.exe.config filer, i vilket fall de behandlas som statiska standardvärden.
Inställningar som inte är standardinställningar för användaromfattning lagras i en ny fil, user.config. Du kan ange en standardinställning för en inställning med användaromfattning med DefaultSettingValueAttribute. Eftersom inställningar med användaromfattning ofta ändras under programkörningen är user.config alltid läs- och skrivbara. Mer information finns i Var lagras användarspecifika inställningar.

Alla tre konfigurationsfilerna lagrar inställningar i XML-format. XML-elementet på den översta nivån för programomfattningsinställningar är <appSettings>, medan <userSettings> används för inställningar med användaromfattning. En app.exe.config fil som innehåller både programomfattningsinställningar och standardinställningar för inställningar med användaromfattning skulle se ut så här:

<?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>

En definition av elementen i avsnittet programinställningar i en konfigurationsfil finns i Schema för programinställningar.

Bindningar för inställningar

Programinställningar använder databindningsarkitekturen för Windows Forms för att tillhandahålla tvåvägskommunikation av inställningsuppdateringar mellan inställningsobjektet och komponenterna. Om du använder Visual Studio för att skapa programinställningar och tilldela dem till komponentegenskaper genereras dessa bindningar automatiskt.

Du kan bara binda en programinställning till en komponent som stöder IBindableComponent-gränssnittet. Komponenten måste också implementera en ändringshändelse för en specifik bunden egenskap eller meddela programinställningarna om att egenskapen har ändrats via INotifyPropertyChanged-gränssnittet. Om komponenten inte implementerar IBindableComponent och du binds via Visual Studio anges de bundna egenskaperna första gången, men uppdateras inte. Om komponenten implementerar IBindableComponent men inte stöder meddelanden om egenskapsändring uppdateras inte bindningen i inställningsfilen när egenskapen ändras.

Vissa Windows Forms-komponenter, till exempel ToolStripItem, stöder inte inställningsbindningar.

Serialisering av inställningar

När LocalFileSettingsProvider måste spara inställningarna på disken utför den följande åtgärder:

Använder reflektion för att undersöka alla egenskaper som definierats i din ApplicationSettingsBase härledda klass och hitta de som tillämpas med antingen ApplicationScopedSettingAttribute eller UserScopedSettingAttribute.
Serialiserar egenskapen till disk. Den försöker först anropa ConvertToString eller ConvertFromString på den associerade typen TypeConverter. Om detta inte lyckas använder den XML-serialisering i stället.
Avgör vilka inställningar som ska användas i vilka filer, baserat på inställningens attribut.

Om du implementerar din egen inställningsklass kan du använda SettingsSerializeAsAttribute för att markera en inställning för binär eller anpassad serialisering med hjälp av SettingsSerializeAs uppräkning. Mer information om hur du skapar din egen inställningsklass i kod finns i Så här skapar du programinställningar.

Inställningar Filplatser

Platsen för app.exe.config och användare.config filer skiljer sig beroende på hur programmet installeras. För ett Windows Forms-baserat program som kopieras till den lokala datorn finns app.exe.config i samma katalog som baskatalogen för programmets huvudfil och användare.config finns på den plats som anges av egenskapen Application.LocalUserAppDataPath. För ett program som installeras med hjälp av ClickOnce finns båda dessa filer i ClickOnce-datakatalogen under %InstallRoot%\Dokument och inställningar\användarnamnet\Local Settings.

Lagringsplatsen för dessa filer skiljer sig något om en användare har aktiverat roamande profiler, vilket gör det möjligt för användaren att definiera olika Windows- och programinställningar när de använder andra datorer i en domän. I så fall kommer både ClickOnce-program och icke-ClickOnce-program att ha sina app.exe.config och användare.config filer som lagras under %InstallRoot%\Dokument och inställningar\användarnamnet\Application Data.

Mer information om hur funktionen Programinställningar fungerar med den nya distributionstekniken finns i ClickOnce och programinställningar. Mer information om ClickOnce Data Directory finns i Accessing Local and Remote Data in ClickOnce Applications.

Programinställningar och säkerhet

Programinställningarna är utformade för delvis förtroende, en begränsad miljö som är standard för Windows Forms-program som finns via Internet eller ett intranät. Inga särskilda behörigheter utöver partiellt förtroende krävs för att använda programinställningar med standardinställningsprovidern.

När programinställningar används i ett ClickOnce-program lagras den user.config filen i datakatalogen ClickOnce. Storleken på programmets user.config-fil får inte överskrida datakatalogkvoten som angetts av ClickOnce. Mer information finns i ClickOnce och programinställningar.

Leverantörer av anpassade inställningar

I arkitekturen för programinställningar finns det en lös koppling mellan programinställningarnas wrapper-klass, härledd från ApplicationSettingsBase, och den associerade inställningsprovidern eller -providrarna, härledd från SettingsProvider. Den här associationen definieras endast av den SettingsProviderAttribute som tillämpas på omslutningsklassen eller dess enskilda egenskaper. Om en inställningsprovider inte uttryckligen anges används standardprovidern LocalFileSettingsProvider. Därför har den här arkitekturen stöd för att skapa och använda anpassade inställningsproviders.

Anta till exempel att du vill utveckla och använda SqlSettingsProvider, en provider som lagrar alla inställningsdata i en Microsoft SQL Server-databas. Din SettingsProvider-härledda klass skulle få den här informationen i sin Initialize-metod som en parameter av typen System.Collections.Specialized.NameValueCollection. Du implementerar sedan metoden GetPropertyValues för att hämta inställningarna från datalagret och SetPropertyValues för att spara dem. Providern kan använda SettingsPropertyCollection som levererats till GetPropertyValues för att fastställa egenskapens namn, typ och omfång, samt andra inställningsattribut som är definierade för den egenskapen.

Leverantören måste implementera en egenskap och en metod vars implementeringar kanske inte är uppenbara. Egenskapen ApplicationName är en abstrakt egenskap för SettingsProvider; du bör programmera den för att returnera följande:

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

Din härledda klass måste också implementera en Initialize-metod som inte tar några argument och returnerar inget värde. Den här metoden definieras inte av SettingsProvider.

Slutligen implementerar du IApplicationSettingsProvider på leverantören för att ge stöd för att uppdatera inställningar, återställa inställningar till deras standardinställningar och uppgradera inställningar från en programversion till en annan.

När du har implementerat och kompilerat providern måste du instruera inställningsklassen att använda den här providern i stället för standardvärdet. Det gör du genom SettingsProviderAttribute. Om den tillämpas på en hel inställningsklass används providern för varje inställning som klassen definierar. Om den tillämpas på enskilda inställningar använder programinställningar endast den providern för dessa inställningar och använder LocalFileSettingsProvider för resten. I följande kodexempel visas hur du instruerar inställningsklassen att använda din anpassade provider.

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

En provider kan anropas från flera trådar samtidigt, men den skrivs alltid till samma lagringsplats. Därför instansierar arkitekturen Programinställningar bara en enda instans av din providerklass.

Viktig

Du bör se till att providern är trådsäker och endast tillåter en tråd i taget att skriva till konfigurationsfilerna.

Providern behöver inte ha stöd för alla inställningsattribut som definierats i System.Configuration namnrymd, även om den måste ha minst stöd för ApplicationScopedSettingAttribute och UserScopedSettingAttributeoch bör även stödja DefaultSettingValueAttribute. För de attribut som den inte stöder bör providern bara misslyckas utan meddelande. det bör inte utlösa ett undantag. Om inställningsklassen dock använder en ogiltig kombination av attribut — till exempel tillämpa ApplicationScopedSettingAttribute och UserScopedSettingAttribute på samma inställning — bör providern utlösa ett undantag och upphöra med operationen.

Dela via