Come posso salvare le impostazioni dell'applicazione in un'applicazione Windows Form?


582

Quello che voglio ottenere è molto semplice: ho un'applicazione Windows Forms (.NET 3.5) che utilizza un percorso per leggere le informazioni. Questo percorso può essere modificato dall'utente, utilizzando il modulo opzioni che fornisco.

Ora, voglio salvare il valore del percorso in un file per un uso successivo. Questa sarebbe una delle molte impostazioni salvate in questo file. Questo file dovrebbe trovarsi direttamente nella cartella dell'applicazione.

Comprendo che sono disponibili tre opzioni:

  • File ConfigurationSettings (appname.exe.config)
  • Registro
  • File XML personalizzato

Ho letto che il file di configurazione .NET non è previsto per il salvataggio dei valori su di esso. Per quanto riguarda il registro, vorrei allontanarmi il più possibile.

Questo significa che dovrei usare un file XML personalizzato per salvare le impostazioni di configurazione?

In tal caso, vorrei vedere un esempio di codice (C #).

Ho visto altre discussioni su questo argomento, ma non mi è ancora chiaro.


È un'applicazione .NET WinForms? In tal caso, su quale versione di .NET stai sviluppando?
Portman,

1
Sì, è un'applicazione WinForms .NET Framework versione 3.5.
Alimentato il

1
hai bisogno di salvare password o valori segreti ? Forse richiede una crittografia
Kiquenet,

Risposte:


593

Se lavori con Visual Studio, è abbastanza facile ottenere impostazioni permanenti. Fare clic con il tasto destro sul progetto in Esplora soluzioni e selezionare Proprietà. Seleziona la scheda Impostazioni e fai clic sul collegamento ipertestuale se le impostazioni non esistono.

Utilizzare la scheda Impostazioni per creare le impostazioni dell'applicazione. Visual Studio crea i file Settings.settingse Settings.Designer.settingsche contengono la classe Singleton Settingsereditata da ApplicationSettingsBase . Puoi accedere a questa classe dal tuo codice per leggere / scrivere le impostazioni dell'applicazione:

Properties.Settings.Default["SomeProperty"] = "Some Value";
Properties.Settings.Default.Save(); // Saves settings in application configuration file

Questa tecnica è applicabile sia per console, Windows Form e altri tipi di progetti.

Nota che devi impostare la proprietà scope delle tue impostazioni. Se si seleziona Ambito applicazione, Impostazioni.Default. <Proprietà> sarà di sola lettura.

Riferimento: Procedura: scrivere le impostazioni utente in fase di esecuzione con C # - Microsoft Docs


2
se ho una soluzione, questo vale per l'intera soluzione o per ciascun progetto?
franko_camron,

8
@Four: ho un progetto WinApp .NET 4.0 qui e il mio SomeProperty non è di sola lettura. Settings.Default.SomeProperty = 'value'; Settings.Default.Save();funziona come un fascino. O è perché ho le impostazioni utente?
doekman,

4
@Four: quando ho modificato un'impostazione da Utente a Ambito applicazione e ho salvato il file, ho visto che il setter è scomparso. Questo succede anche con il profilo del cliente 4.0 ...
doekman,

3
@Four: ottimo collegamento, anche se la tua affermazione che il Settings.Default.Save()non fa nulla non è corretta. Come afferma @aku nella risposta, le impostazioni dell'ambito dell'app sono di sola lettura: il salvataggio è inefficace per loro. Utilizzare quel PortableSettingsProvider personalizzato per salvare le impostazioni dell'ambito utente nel file app.config situato dove si trova l'exe anziché quello nella cartella AppData dell'utente. No, generalmente non va bene, ma lo uso durante lo sviluppo per utilizzare le stesse impostazioni da compilazione a compilazione (senza, passano nuove cartelle utente uniche con ogni compilazione).
pesciolino

7
A partire da ora, con .NET 3.5 sembra che tu possa semplicemente usare Settings.Default.SomeProperty per assegnare un valore e ottenere una forte tipografia. Inoltre, per risparmiare altro tempo (mi ci è voluto un po 'di tempo per capirlo), è necessario digitare Properties.Settings.Default o aggiungere utilizzando YourProjectNameSpace.Settings nella parte superiore del file. Le "impostazioni" da sole non sono definite / trovate.
eselk,

95

Se stai pensando di salvare in un file all'interno della stessa directory del tuo eseguibile, ecco una bella soluzione che utilizza il formato JSON :

using System;
using System.IO;
using System.Web.Script.Serialization;

namespace MiscConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            MySettings settings = MySettings.Load();
            Console.WriteLine("Current value of 'myInteger': " + settings.myInteger);
            Console.WriteLine("Incrementing 'myInteger'...");
            settings.myInteger++;
            Console.WriteLine("Saving settings...");
            settings.Save();
            Console.WriteLine("Done.");
            Console.ReadKey();
        }

        class MySettings : AppSettings<MySettings>
        {
            public string myString = "Hello World";
            public int myInteger = 1;
        }
    }

    public class AppSettings<T> where T : new()
    {
        private const string DEFAULT_FILENAME = "settings.json";

        public void Save(string fileName = DEFAULT_FILENAME)
        {
            File.WriteAllText(fileName, (new JavaScriptSerializer()).Serialize(this));
        }

        public static void Save(T pSettings, string fileName = DEFAULT_FILENAME)
        {
            File.WriteAllText(fileName, (new JavaScriptSerializer()).Serialize(pSettings));
        }

        public static T Load(string fileName = DEFAULT_FILENAME)
        {
            T t = new T();
            if(File.Exists(fileName))
                t = (new JavaScriptSerializer()).Deserialize<T>(File.ReadAllText(fileName));
            return t;
        }
    }
}

Sì, cambiare DEFAULT_FILENAME in un percorso assoluto se si desidera salvare in un'altra directory. Penso che sia più comune salvare il file nella stessa directory dell'applicazione o in una sottodirectory, se non li si salva nel registro.
Trevor,

Oh, forse l'opzione migliore sarebbe quella di archiviare il file delle impostazioni nella cartella appdata dell'utente.
Trevor,

1
Non c'è bisogno di cambiare DEFAULT_FILENAME, basta chiamare settings.Save(theFileToSaveTo); Essendo tutto maiuscolo, DEFAULT_FILENAMEdovrebbe essere una costante . Se si desidera una proprietà di lettura-scrittura, crearne una e impostare il costruttore su DEFAULT_FILENAME. Quindi impostare il valore dell'argomento predefinito null, verificarlo e utilizzare la proprietà come valore predefinito. È un po 'più di battitura, ma ti dà un'interfaccia più standard.
Jesse Chisholm,

10
Dovrai fare riferimento System.Web.Extensions.dllse non l'hai già fatto.
TEK

9
Ho creato un'intera libreria basata su questa risposta con molti miglioramenti e l'ho resa disponibile in nuget: github.com/Nucs/JsonSettings
NucS

67

Il registro è un no-go. Non sei sicuro che l'utente che utilizza l'applicazione disponga di diritti sufficienti per scrivere nel registro.

È possibile utilizzare il app.configfile per salvare le impostazioni a livello di applicazione (che sono le stesse per ogni utente che utilizza l'applicazione).

Memorizzerei le impostazioni specifiche dell'utente in un file XML, che verrebbe salvato nella memoria isolata o nella directory SpecialFolder.ApplicationData .

Inoltre, a partire da .NET 2.0, è possibile memorizzare i valori nel app.configfile.


8
Utilizzare il registro, tuttavia, se si desidera le impostazioni per accesso / utente.
thenonhacker,

19
Il registro non è portabile
Kb.

10
@thenonhacker: Oppure usa Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData)
Kenny Mann,

4
È possibile scrivere nel registro utenti (molti programmi scrivono informazioni lì e le autorizzazioni utente non sono mai un problema). Il vantaggio dell'uso del registro rispetto all'utilizzo delle impostazioni è che se si hanno più applicazioni che condividono la stessa cartella (ad esempio un programma di installazione e un programma applicativo), non condivideranno le stesse impostazioni.
Kesty,

3
Il principale svantaggio del Registro di sistema è il modo difficile di esportare / copiare le impostazioni su altri PC. Ma non sono d'accordo con "Non sei sicuro che l'utente che utilizza la tua applicazione abbia i diritti sufficienti per scrivere nel registro" - In HKEY_CURRENT_USER hai sempre i diritti per scrivere. Può essere negato ma il filesystem può anche essere inaccessibile per l'utente corrente (tutte le possibili cartelle TEMP, ecc.).
i486,

20

La ApplicationSettingsclasse non supporta il salvataggio delle impostazioni nel file app.config . Questo è molto di progettazione; le applicazioni eseguite con un account utente adeguatamente protetto (pensa a Vista UAC) non hanno accesso in scrittura alla cartella di installazione del programma.

Puoi combattere il sistema con la ConfigurationManagerclasse. Ma la banale soluzione alternativa è accedere alla finestra di progettazione Impostazioni e modificare l'ambito dell'impostazione su Utente. Se ciò causa difficoltà (ad esempio, l'impostazione è pertinente per ogni utente), è necessario inserire la funzione Opzioni in un programma separato in modo da poter richiedere il prompt di elevazione dei privilegi. O rinunciare usando un'impostazione.


Potresti per favore espandere la tua ultima frase? Chiedere elevazione per scrivere app.config o per scrivere un'applicazione separata che passi attraverso tutti gli utenti domestici di utenti, cercare user.config e modificarli?
CannibalSmith,

2
Il programma separato richiede un manifest per chiedere l'elevazione. Google "asinvoker requireadministrator" per trovare la sintassi corretta. La modifica di user.config non è pratica, né necessaria.
Hans Passant,

18

L'argomento register / configurationSettings / XML sembra ancora molto attivo. Li ho usati tutti, poiché la tecnologia è progredita, ma il mio preferito è basato sul sistema di Threed combinato con Storage isolato .

L'esempio seguente consente l'archiviazione di un oggetto denominato properties in un file in un archivio isolato. Ad esempio:

AppSettings.Save(myobject, "Prop1,Prop2", "myFile.jsn");

Le proprietà possono essere recuperate usando:

AppSettings.Load(myobject, "myFile.jsn");

È solo un esempio, non suggestivo delle migliori pratiche.

internal static class AppSettings
{
    internal static void Save(object src, string targ, string fileName)
    {
        Dictionary<string, object> items = new Dictionary<string, object>();
        Type type = src.GetType();

        string[] paramList = targ.Split(new char[] { ',' });
        foreach (string paramName in paramList)
            items.Add(paramName, type.GetProperty(paramName.Trim()).GetValue(src, null));

        try
        {
            // GetUserStoreForApplication doesn't work - can't identify.
            // application unless published by ClickOnce or Silverlight
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForAssembly();
            using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(fileName, FileMode.Create, storage))
            using (StreamWriter writer = new StreamWriter(stream))
            {
                writer.Write((new JavaScriptSerializer()).Serialize(items));
            }

        }
        catch (Exception) { }   // If fails - just don't use preferences
    }

    internal static void Load(object tar, string fileName)
    {
        Dictionary<string, object> items = new Dictionary<string, object>();
        Type type = tar.GetType();

        try
        {
            // GetUserStoreForApplication doesn't work - can't identify
            // application unless published by ClickOnce or Silverlight
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForAssembly();
            using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(fileName, FileMode.Open, storage))
            using (StreamReader reader = new StreamReader(stream))
            {
                items = (new JavaScriptSerializer()).Deserialize<Dictionary<string, object>>(reader.ReadToEnd());
            }
        }
        catch (Exception) { return; }   // If fails - just don't use preferences.

        foreach (KeyValuePair<string, object> obj in items)
        {
            try
            {
                tar.GetType().GetProperty(obj.Key).SetValue(tar, obj.Value, null);
            }
            catch (Exception) { }
        }
    }
}

1
O meglio ancora; utilizzare DataContractJsonSerializer
Boczek

16

Volevo condividere una biblioteca che ho creato per questo. È una piccola libreria, ma un grande miglioramento (IMHO) rispetto ai file .settings.

La libreria si chiama Jot (GitHub) . Ecco un vecchio articolo di The Code Project ho scritto al riguardo.

Ecco come lo useresti per tenere traccia delle dimensioni e della posizione di una finestra:

public MainWindow()
{
    InitializeComponent();

    _stateTracker.Configure(this)
        .IdentifyAs("MyMainWindow")
        .AddProperties(nameof(Height), nameof(Width), nameof(Left), nameof(Top), nameof(WindowState))
        .RegisterPersistTrigger(nameof(Closed))
        .Apply();
}

Il vantaggio rispetto ai file .settings: c'è molto meno codice ed è molto meno soggetto ad errori poiché è necessario menzionare ogni proprietà una sola volta .

Con un file di impostazioni è necessario menzionare ogni proprietà cinque volte: una volta quando si crea esplicitamente la proprietà e altre quattro volte nel codice che copia i valori avanti e indietro.

Archiviazione, serializzazione, ecc. Sono completamente configurabili. Quando gli oggetti target vengono creati da un IoC contenitore , è possibile [collegarlo] [] in modo che applichi automaticamente il tracciamento a tutti gli oggetti che risolve, in modo che tutto ciò che è necessario fare per rendere persistente una proprietà sia uno schiaffo [Tracciabile] attributo su di esso.

È altamente configurabile e puoi configurare: - quando i dati sono persistenti e applicati a livello globale o per ogni oggetto monitorato - come sono serializzati - dove sono archiviati (ad esempio file, database, online, archiviazione isolata, registro) - regole che possono annullare l'applicazione / dati persistenti per una proprietà

Fidati di me, la biblioteca è di prim'ordine!


14

Un modo semplice è utilizzare un oggetto dati di configurazione, salvarlo come file XML con il nome dell'applicazione nella cartella locale e, all'avvio, rileggerlo.

Ecco un esempio per memorizzare la posizione e le dimensioni di un modulo.

L'oggetto dati di configurazione è fortemente tipizzato e facile da usare:

[Serializable()]
public class CConfigDO
{
    private System.Drawing.Point m_oStartPos;
    private System.Drawing.Size m_oStartSize;

    public System.Drawing.Point StartPos
    {
        get { return m_oStartPos; }
        set { m_oStartPos = value; }
    }

    public System.Drawing.Size StartSize
    {
        get { return m_oStartSize; }
        set { m_oStartSize = value; }
    }
}

Una classe manager per il salvataggio e il caricamento:

public class CConfigMng
{
    private string m_sConfigFileName = System.IO.Path.GetFileNameWithoutExtension(System.Windows.Forms.Application.ExecutablePath) + ".xml";
    private CConfigDO m_oConfig = new CConfigDO();

    public CConfigDO Config
    {
        get { return m_oConfig; }
        set { m_oConfig = value; }
    }

    // Load configuration file
    public void LoadConfig()
    {
        if (System.IO.File.Exists(m_sConfigFileName))
        {
            System.IO.StreamReader srReader = System.IO.File.OpenText(m_sConfigFileName);
            Type tType = m_oConfig.GetType();
            System.Xml.Serialization.XmlSerializer xsSerializer = new System.Xml.Serialization.XmlSerializer(tType);
            object oData = xsSerializer.Deserialize(srReader);
            m_oConfig = (CConfigDO)oData;
            srReader.Close();
        }
    }

    // Save configuration file
    public void SaveConfig()
    {
        System.IO.StreamWriter swWriter = System.IO.File.CreateText(m_sConfigFileName);
        Type tType = m_oConfig.GetType();
        if (tType.IsSerializable)
        {
            System.Xml.Serialization.XmlSerializer xsSerializer = new System.Xml.Serialization.XmlSerializer(tType);
            xsSerializer.Serialize(swWriter, m_oConfig);
            swWriter.Close();
        }
    }
}

Ora puoi creare un'istanza e utilizzare nel caricamento del modulo e chiudere gli eventi:

    private CConfigMng oConfigMng = new CConfigMng();

    private void Form1_Load(object sender, EventArgs e)
    {
        // Load configuration
        oConfigMng.LoadConfig();
        if (oConfigMng.Config.StartPos.X != 0 || oConfigMng.Config.StartPos.Y != 0)
        {
            Location = oConfigMng.Config.StartPos;
            Size = oConfigMng.Config.StartSize;
        }
    }

    private void Form1_FormClosed(object sender, FormClosedEventArgs e)
    {
        // Save configuration
        oConfigMng.Config.StartPos = Location;
        oConfigMng.Config.StartSize = Size;
        oConfigMng.SaveConfig();
    }

E anche il file XML prodotto è leggibile:

<?xml version="1.0" encoding="utf-8"?>
<CConfigDO xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <StartPos>
    <X>70</X>
    <Y>278</Y>
  </StartPos>
  <StartSize>
    <Width>253</Width>
    <Height>229</Height>
  </StartSize>
</CConfigDO>

1
Ho un ottimo funzionamento nello sviluppo, ma quando distribuisco l'applicazione l'utente medio non ha accesso alla c:\program files\my applicationcartella, quindi il salvataggio delle impostazioni genera un errore. Sto invece cercando di salvare il file xml in AppData, ma mi chiedevo solo se ci fosse un modo ovvio per ovviare a questo problema, poiché questo approccio sembra aver funzionato per te.
Philip Stratford,

@PhilipStratford Dato che è solo un file normale, puoi salvarlo ovunque. Basta trovare un posto con accesso in scrittura.
Dieter Meemken,

@PhilipStratford Potrebbe essere la cartella AppData un'opzione per te, vedi C # ottenere il percorso di% AppData% , come indicato da kite .
Dieter Meemken,

Grazie, l'ho già implementato, salvando il file xml nella cartella AppDate. Mi chiedevo solo se esistesse un modo semplice per salvarlo nella cartella dell'applicazione come nel tuo esempio, dato che pensavo che l'avessi fatto funzionare. Non preoccuparti, la cartella AppData è probabilmente comunque una posizione migliore!
Philip Stratford,


5

Altre opzioni, invece di utilizzare un file XML personalizzato, possiamo utilizzare un formato di file più user friendly: file JSON o YAML.

  • Se si utilizza .NET 4.0 dinamico, questa libreria è davvero facile da usare (serializzare, deserializzare, supporto degli oggetti nidificati e ordinare l'output come si desidera + unire più impostazioni a una) JsonConfig (l'utilizzo è equivalente a ApplicationSettingsBase)
  • Per la libreria di configurazione .NET YAML ... Non ne ho trovato uno facile da usare come JsonConfig

È possibile archiviare il file delle impostazioni in più cartelle speciali (per tutti gli utenti e per utente) come elencato qui Environment.SpecialFolder Enumeration e più file (sola lettura predefinita, per ruolo, per utente, ecc.)

Se si sceglie di utilizzare più impostazioni, è possibile unire tali impostazioni: Ad esempio, unendo le impostazioni per impostazione predefinita + Utente di base + Utente di amministrazione. Puoi usare le tue regole: l'ultima ha la precedenza sul valore, ecc.


4

"Questo significa che dovrei usare un file XML personalizzato per salvare le impostazioni di configurazione?" No, non necessariamente. Usiamo SharpConfig per tali operazioni.

Ad esempio, se un file di configurazione è così

[General]
# a comment
SomeString = Hello World!
SomeInteger = 10 # an inline comment

Possiamo recuperare valori come questo

var config = Configuration.LoadFromFile("sample.cfg");
var section = config["General"];

string someString = section["SomeString"].StringValue;
int someInteger = section["SomeInteger"].IntValue;

È compatibile con .NET 2.0 e versioni successive. Siamo in grado di creare file di configurazione al volo e possiamo salvarli in un secondo momento.

Fonte: http://sharpconfig.net/
GitHub: https://github.com/cemdervis/SharpConfig


3

Per quanto ne so, .NET supporta le impostazioni persistenti utilizzando la funzione di impostazioni dell'applicazione integrata:

La funzionalità Impostazioni applicazione di Windows Form semplifica la creazione, l'archiviazione e la gestione delle preferenze personalizzate dell'utente e dell'applicazione sul computer client. Con le impostazioni dell'applicazione Windows Form, è possibile archiviare non solo i dati dell'applicazione come stringhe di connessione al database, ma anche dati specifici dell'utente, come le preferenze dell'applicazione utente. Utilizzando Visual Studio o codice gestito personalizzato, è possibile creare nuove impostazioni, leggerle e scriverle su disco, associarle alle proprietà dei moduli e convalidare i dati delle impostazioni prima di caricare e salvare. - http://msdn.microsoft.com/en-us/library/k4s6c3a0.aspx


2
Non è vero .. vedi la risposta di Aku sopra. è possibile utilizzando Settings and ApplicationSettingsBase
Gishu

2

A volte si desidera eliminare quelle impostazioni conservate nel file web.config o app.config tradizionale. Volete un controllo più preciso sulla distribuzione delle voci delle impostazioni e sulla progettazione separata dei dati. O il requisito è abilitare l'aggiunta di nuove voci in fase di esecuzione.

Posso immaginare due buone opzioni:

  • La versione fortemente tipizzata e
  • La versione orientata agli oggetti.

Il vantaggio della versione fortemente tipizzata sono i nomi e i valori delle impostazioni fortemente tipizzati. Non vi è alcun rischio di mescolare nomi o tipi di dati. Lo svantaggio è che devono essere codificate più impostazioni, che non possono essere aggiunte in fase di esecuzione.

Con la versione orientata agli oggetti il ​​vantaggio è che è possibile aggiungere nuove impostazioni in fase di esecuzione. Ma non hai nomi e valori fortemente tipizzati. Deve stare attento con gli identificatori di stringa. È necessario conoscere il tipo di dati salvato in precedenza quando si ottiene un valore.

È possibile trovare il codice di entrambe le implementazioni completamente funzionali QUI .


2

Sì, è possibile salvare la configurazione, ma dipende in gran parte dal modo in cui si sceglie di farlo. Lasciami descrivere le differenze tecniche in modo da poter capire le opzioni che hai:

Innanzitutto, è necessario distinguere se si desidera utilizzare applicationSettings o AppSettings nel file *.exe.config(aka App.configin Visual Studio) - ci sono differenze fondamentali, descritte qui .

Entrambi forniscono diversi modi per salvare le modifiche:

  • Le AppSettings ti consentono di leggere e scrivere direttamente nel file di configurazione (tramite config.Save(ConfigurationSaveMode.Modified);, dove config è definito come config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);).

  • Le impostazioni dell'applicazione consentono di leggere, ma se si scrivono modifiche (tramite Properties.Settings.Default.Save();) verranno scritte su una base per utente, memorizzate in un posto speciale (ad es C:\Documents and Settings\USERID\Local Settings\Application Data\FIRMNAME\WindowsFormsTestApplicati_Url_tdq2oylz33rzq00sxhvxucu5edw2oghw\1.0.0.0.). Come accennato da Hans Passant nella sua risposta, ciò è dovuto al fatto che un utente in genere ha diritti limitati su Program Files e non può scrivere su di esso senza invocare il prompt UAC. Uno svantaggio è che se in futuro si aggiungono chiavi di configurazione, è necessario sincronizzarle con ogni profilo utente.

Nota: come menzionato nella domanda, esiste una terza opzione: se si considera il file di configurazione come documento XML, è possibile caricarlo, modificarlo e salvarlo utilizzando la System.Xml.Linq.XDocumentclasse. Non è necessario utilizzare un file XML personalizzato, è possibile leggere il file di configurazione esistente; per eseguire query sugli elementi, puoi persino usare le query Linq. Ho dato un esempio qui , controlla la funzione GetApplicationSettinglì nella risposta.

Se hai bisogno della crittografia per proteggere i tuoi valori, dai un'occhiata a questa risposta.


Grazie per questa eccellente risposta.
NoChance,

2
@NoChance - Prego, felice di poterti aiutare!
Matt,

Bello! Alla fine ho capito tutto Mom
Momoro

1
@Momoro - bello sentire! ;-)
Matt

1
public static class SettingsExtensions
{
    public static bool TryGetValue<T>(this Settings settings, string key, out T value)
    {
        if (settings.Properties[key] != null)
        {
            value = (T) settings[key];
            return true;
        }

        value = default(T);
        return false;
    }

    public static bool ContainsKey(this Settings settings, string key)
    {
        return settings.Properties[key] != null;
    }

    public static void SetValue<T>(this Settings settings, string key, T value)
    {
        if (settings.Properties[key] == null)
        {
            var p = new SettingsProperty(key)
            {
                PropertyType = typeof(T),
                Provider = settings.Providers["LocalFileSettingsProvider"],
                SerializeAs = SettingsSerializeAs.Xml
            };
            p.Attributes.Add(typeof(UserScopedSettingAttribute), new UserScopedSettingAttribute());
            var v = new SettingsPropertyValue(p);
            settings.Properties.Add(p);
            settings.Reload();
        }
        settings[key] = value;
        settings.Save();
    }
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.