¿Cómo puedo guardar la configuración de la aplicación en una aplicación de Windows Forms?

Lo que quiero lograr es muy simple: tengo una aplicación de Windows Forms (.NET 3.5) que usa una ruta para leer información. Esta ruta puede ser modificada por el usuario, usando el formulario de opciones que proporciono.

Ahora, quiero guardar el valor de la ruta en un archivo para su uso posterior. Esta sería una de las muchas configuraciones guardadas en este archivo. Este archivo se ubicaría directamente en la carpeta de la aplicación.

Entiendo que hay tres opciones disponibles:

  • Archivo ConfigurationSettings (appname.exe.config)
  • registro
  • Archivo XML personalizado

Leí que el archivo de configuración .NET no está previsto para guardar valores en él. En cuanto al registro, me gustaría alejarme lo más posible de él.

¿Significa esto que debo usar un archivo XML personalizado para guardar los ajustes de configuración?

Si es así, me gustaría ver un ejemplo de código de eso (C #).

He visto otras discusiones sobre este tema, pero todavía no me queda claro.

preguntado el 17 de enero de 09 a las 09:01

¿Es esta una aplicación .NET WinForms? Si es así, ¿en qué versión de .NET está desarrollando? -

Sí, es una aplicación WinForms de .NET Framework versión 3.5. -

necesitas salvar contraseñas o valores secretos ? Quizás requiera alguno cifrado -

14 Respuestas

Si trabaja con Visual Studio, es bastante fácil obtener configuraciones persistentes. Haga clic derecho en el proyecto en el Explorador de soluciones y elija Propiedades. Seleccione la pestaña Configuración y haga clic en el hipervínculo si la configuración no existe.

Utilice la pestaña Configuración para crear la configuración de la aplicación. Visual Studio crea los archivos Settings.settings y Settings.Designer.settings que contienen la clase singleton Settings heredado de AplicaciónConfiguraciónBase. Puede acceder a esta clase desde su código para leer / escribir la configuración de la aplicación:

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

Esta técnica es aplicable tanto para consola, Windows Forms y otros tipos de proyectos.

Tenga en cuenta que debe configurar el alcance propiedad de su configuración. Si selecciona Alcance de la aplicación, luego Configuración. será de solo lectura.

Referencia: Cómo: escribir la configuración del usuario en tiempo de ejecución con C #How To: Write User Settings at Run Time with C # - Documentos de Microsoft

Respondido 21 Feb 20, 23:02

si tengo una solución, ¿se aplicará a la solución completa o para cada proyecto? - franco_camron

@Four: Tengo un proyecto .NET 4.0 WinApp aquí, y mi SomeProperty no es de solo lectura. Settings.Default.SomeProperty = 'value'; Settings.Default.Save(); Funciona de maravilla. ¿O es porque tengo configuraciones de usuario? - doekman

@Four: Cuando cambié una configuración de User a Application-scope y guardé el archivo, vi en el código generado que el setter desaparecía. Esto también sucede con el perfil de cliente 4.0 ... - doekman

@Four: gran enlace, aunque su declaración de que el Settings.Default.Save() no hace nada es incorrecto. Como indica @aku en la respuesta, la configuración del alcance de la aplicación es de solo lectura: guardar no es efectivo para ellos. Usa esa costumbre Proveedor de configuración portátil para guardar la configuración del alcance del usuario en el archivo app.config ubicado donde está el exe en lugar del que está en la carpeta AppData del usuario. No, generalmente no es bueno, pero lo uso durante el desarrollo para usar la misma configuración de compilación a compilación (sin ella, van nuevas carpetas de usuario únicas con cada compilación). - pececillo

A partir de ahora, con .NET 3.5 parece que puede usar Settings.Default.SomeProperty para asignar un valor y obtener un encasillado fuerte. Además, para ahorrar tiempo a otros (me tomó un tiempo resolver esto), debe escribir Properties.Settings.Default, o agregar usando YourProjectNameSpace.Settings en la parte superior de su archivo. "Configuración" por sí sola no está definida / encontrada. - eselk

Si planea guardar en un archivo dentro del mismo directorio que su ejecutable, aquí hay una buena solución que usa el JSON formato:

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;
        }
    }
}

Respondido 02 ago 16, 23:08

Sí, cambie DEFAULT_FILENAME a una ruta absoluta si desea guardar en otro directorio. Creo que es más común guardar el archivo en el mismo directorio que la aplicación, o un subdirectorio, si no los está guardando en el registro. - Trevor

Oh, quizás la mejor opción sería almacenar el archivo de configuración en la carpeta de datos de la aplicación del usuario. - Trevor

No hay necesidad de cambiar DEFAULT_FILENAME, solo llama settings.Save(theFileToSaveTo); Siendo todo en mayúsculas, DEFAULT_FILENAME se supone que es un constante. Si desea una propiedad de lectura y escritura, cree una y haga que el constructor la establezca en DEFAULT_FILENAME. Luego haga que el valor del argumento predeterminado sea null, pruebe esto y use su propiedad como valor predeterminado. Es un poco más de escritura, pero le brinda una interfaz más estándar. - Jesse Chisholm

Necesitarás hacer referencia System.Web.Extensions.dll si aún no lo ha hecho. - TEK

Creé una biblioteca completa basada en esta respuesta con muchas mejoras y la hice disponible en nuget: github.com/Nucs/JsonSettings - Nucs

El registro está prohibido. No está seguro de si el usuario que utiliza su aplicación tiene derechos suficientes para escribir en el registro.

Puede utilizar el app.config para guardar la configuración a nivel de la aplicación (que es la misma para cada usuario que usa su aplicación).

Almacenaría configuraciones específicas del usuario en un archivo XML, que se guardaría en Almacenamiento aislado o en el SpecialFolder.ApplicationData directorio.

Además, a partir de .NET 2.0, es posible almacenar valores en el app.config archivo.

Respondido 01 Abr '20, 12:04

Sin embargo, use el registro si desea configuraciones por inicio de sesión / usuario. - entoncesonhacker

@thenonhacker: O use Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData) - kenny mann

@thenonhacker: el registro no es necesario y no debe usarse para almacenar la configuración de la aplicación, nunca. System.Environment.SpecialFolder.LocalApplicationData es la carpeta local por usuario. .ApplicationData es la carpeta de itinerancia por usuario. Ver msdn.microsoft.com/en-us/library/… - Deeee

Se puede escribir en el registro de usuarios (muchos programas escriben información allí y los permisos de usuario nunca son un problema). La ventaja de usar el registro sobre la configuración es que si tiene varias aplicaciones que comparten la misma carpeta (por ejemplo, un programa de instalación y un programa de aplicación), no compartirán la misma configuración. - Kesty

La principal desventaja de Registry es la forma difícil de exportar / copiar configuraciones a otra PC. Pero no estoy de acuerdo con "No estás seguro de si el usuario que usa tu aplicación tiene derechos suficientes para escribir en el registro". En HKEY_CURRENT_USER siempre tienes derechos para escribir. Se puede negar, pero el sistema de archivos también puede ser inaccesible para el usuario actual (todas las carpetas TEMP posibles, etc.). - i486

El ApplicationSettings la clase no admite guardar configuraciones en el aplicación.config expediente. Eso es muy por diseño; las aplicaciones que se ejecutan con una cuenta de usuario debidamente protegida (piense en Vista UAC) no tienen acceso de escritura a la carpeta de instalación del programa.

Puedes luchar contra el sistema con el ConfigurationManager clase. Pero la solución trivial es ir al diseñador de configuración y cambiar el alcance de la configuración a Usuario. Si eso causa dificultades (digamos, la configuración es relevante para todos los usuarios), debe poner su función de Opciones en un programa separado para que pueda solicitar el aviso de elevación de privilegios. O renuncie a usar una configuración.

Respondido el 17 de enero de 20 a las 14:01

¿Podría ampliar su última oración? Solicite la elevación para escribir app.config o para escribir una aplicación separada que pasaría por los folers domésticos de todos los usuarios, busque user.config y edítelos. - Caníbal Smith

El programa separado requiere un manifiesto para solicitar elevación. Google 'asinvoker requireadministrator' para encontrar la sintaxis adecuada. Editar user.config no es práctico ni necesario. - Hans Passant

El argumento registro / configurationSettings / XML todavía parece muy activo. Los he usado todos, a medida que la tecnología ha progresado, pero mi favorito se basa en Sistema de Threed combinado con Almacenamiento aislado.

El siguiente ejemplo permite el almacenamiento de un objeto denominado propiedades en un archivo en un almacenamiento aislado. Como:

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

Las propiedades se pueden recuperar usando:

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

Es solo una muestra, no sugiere las mejores prácticas.

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) { }
        }
    }
}

contestado el 23 de mayo de 17 a las 13:05

O mejor aún; utilizar DataContractJsonSerializer - Boczek

Quería compartir una biblioteca que he construido para esto. Es una biblioteca pequeña, pero una gran mejora (en mi humilde opinión) con respecto a los archivos .settings.

La biblioteca se llama Jota (GitHub). Aquí hay un viejo El artículo del proyecto de código Escribí sobre eso.

Así es como lo usaría para realizar un seguimiento del tamaño y la ubicación de una ventana:

public MainWindow()
{
    InitializeComponent();

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

El beneficio en comparación con los archivos .settings: Hay mucho menos código y es mucho menos propenso a errores, ya que solo necesita mencionar cada propiedad una vez.

Con archivos de configuración, debe mencionar cada propiedad Digital XNUMXk veces: una vez cuando crea explícitamente la propiedad y cuatro veces adicionales en el código que copia los valores de un lado a otro.

El almacenamiento, la serialización, etc. son completamente configurables. Cuando los objetos de destino son creados por un COI contenedor, puede [conectarlo] [] para que aplique el seguimiento automáticamente a todos los objetos que resuelve, de modo que todo lo que necesita hacer para que una propiedad sea persistente es colocarle un atributo [Trackable].

Es altamente configurable y puede configurar: - cuándo los datos persisten y se aplican globalmente o para cada objeto rastreado - cómo se serializan - dónde se almacenan (por ejemplo, archivo, base de datos, en línea, almacenamiento aislado, registro) - reglas que pueden cancelar la aplicación / datos persistentes para una propiedad

Créame, ¡la biblioteca es de primera!

Respondido el 17 de enero de 20 a las 14:01

Una forma sencilla es utilizar un objeto de datos de configuración, guardarlo como un archivo XML con el nombre de la aplicación en la carpeta local y, al iniciarlo, volver a leerlo.

A continuación, se muestra un ejemplo para almacenar la posición y el tamaño de un formulario.

El objeto de datos de configuración está fuertemente tipado y es fácil de usar:

[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 clase de administrador para guardar y cargar:

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();
        }
    }
}

Ahora puede crear una instancia y usarla en los eventos de carga y cierre de su formulario:

    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();
    }

Y el archivo XML producido también es legible:

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

Respondido el 25 de enero de 17 a las 13:01

Tengo esto funcionando muy bien en desarrollo, pero cuando implemento la aplicación, el usuario promedio no tiene acceso a la c:\program files\my application carpeta, por lo que guardar la configuración arroja un error. En su lugar, estoy buscando guardar el archivo xml en AppData, pero me preguntaba si había una forma obvia de solucionar este problema, ya que este enfoque parece haber funcionado para usted. - Felipe Stratford

@PhilipStratford Dado que es solo un archivo normal, puede guardarlo en cualquier lugar. Simplemente busque un lugar con acceso de escritura. - Dieter Meemken

@PhilipStratford Puede ser que la carpeta AppData sea una opción para usted, consulte C # obteniendo la ruta de% AppData%, como lo menciona Kitesurf. - Dieter Meemken

Gracias, ya implementé esto, guardando el archivo xml en la carpeta AppDate. Me preguntaba si había una manera fácil de guardarlo en la carpeta de la aplicación según su ejemplo, ya que asumí que lo había hecho funcionar. No se preocupe, ¡la carpeta AppData probablemente sea una mejor ubicación de todos modos! - Felipe Stratford

No me gusta la solución propuesta de usar web.config or app.config. Intente leer su propio XML. Mira esto Archivos de configuración XML: no más web.config.

Respondido el 28 de diciembre de 16 a las 00:12

Otras opciones, en lugar de usar un archivo XML personalizado, podemos usar un formato de archivo más fácil de usar: archivo JSON o YAML.

  • Si usa .NET 4.0 dinámico, esta biblioteca es realmente fácil de usar (serializar, deserializar, admitir objetos anidados y ordenar la salida como desee + fusionar múltiples configuraciones en una) JsonConfig (el uso es equivalente a ApplicationSettingsBase)
  • Para la biblioteca de configuración .NET YAML ... no he encontrado uno que sea tan fácil de usar como JsonConfig

Puede almacenar su archivo de configuración en varias carpetas especiales (para todos los usuarios y por usuario) como se enumeran aquí Environment.SpecialFolder Enumeración y varios archivos (predeterminado de solo lectura, por rol, por usuario, etc.)

Si opta por utilizar varias configuraciones, puede fusionar esas configuraciones: por ejemplo, fusionando la configuración predeterminada + BasicUser + AdminUser. Puede utilizar sus propias reglas: la última anula el valor, etc.

contestado el 23 de mayo de 17 a las 13:05

"¿Significa esto que debo usar un archivo XML personalizado para guardar los ajustes de configuración?" No, no necesariamente. Usamos SharpConfig para tales operaciones.

Por ejemplo, si un archivo de configuración es así

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

Podemos recuperar valores como este

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

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

Es compatible con .NET 2.0 y superior. Podemos crear archivos de configuración sobre la marcha y guardarlos más tarde.

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

Respondido el 17 de enero de 20 a las 07:01

Por lo que puedo decir, .NET admite configuraciones persistentes utilizando la función de configuración de la aplicación incorporada:

La función Configuración de la aplicación de Windows Forms facilita la creación, el almacenamiento y el mantenimiento de las preferencias de usuario y aplicaciones personalizadas en la computadora cliente. Con la configuración de la aplicación de Windows Forms, puede almacenar no solo los datos de la aplicación, como las cadenas de conexión de la base de datos, sino también los datos específicos del usuario, como las preferencias de la aplicación del usuario. Con Visual Studio o un código administrado personalizado, puede crear nuevas configuraciones, leerlas y escribirlas en el disco, vincularlas a propiedades en sus formularios y validar los datos de configuración antes de cargarlos y guardarlos. - http://msdn.microsoft.com/en-us/library/k4s6c3a0.aspx

Respondido el 24 de diciembre de 10 a las 23:12

No es cierto .. vea la respuesta de aku arriba. es posible usando Settings y ApplicationSettingsBase - gishu

Si, es posible guardar la configuración, pero depende en gran medida de la forma en que elija hacerlo. Permítame describir las diferencias técnicas para que pueda comprender las opciones que tiene:

Primero, debe distinguir si desea utilizar Configuraciones de la aplicación or Ajustes de Aplicacion en tu *.exe.config(también llamado App.config en Visual Studio) archivo - hay diferencias fundamentales, siendo descrito aquí.

Ambos proporcionan diferentes formas de guardar cambios:

  • El Ajustes de Aplicacion le permite leer y escribir directamente en el archivo de configuración (a través de config.Save(ConfigurationSaveMode.Modified);, donde config se define como config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);).

  • El Configuraciones de la aplicación permitir leer, pero si escribe cambios (a través de Properties.Settings.Default.Save();) se escribirá por usuario, se almacenará en un lugar especial (p. ej. C:\Documents and Settings\USERID\Local Settings\Application Data\FIRMNAME\WindowsFormsTestApplicati_Url_tdq2oylz33rzq00sxhvxucu5edw2oghw\1.0.0.0). Como Hans Passant mencionó en su respuesta, esto se debe a que un usuario generalmente tiene derechos restringidos sobre los archivos de programa y no puede escribir en ellos sin invocar el indicador de UAC. Una desventaja es que si va a agregar claves de configuración en el futuro, debe sincronizarlas con cada perfil de usuario.

Nota: Como se menciona en la pregunta, hay una 3ª opción: Si trata el archivo de configuración como Documento XML, puede cargarlo, modificarlo y guardarlo utilizando el System.Xml.Linq.XDocument clase. No es necesario utilizar un archivo XML personalizado, puede leer el archivo de configuración existente; para consultar elementos, incluso puede utilizar consultas Linq. He dado un ejemplo aquí, mira la función GetApplicationSetting ahí en la respuesta.

Si usted requiere cifrado para proteger sus valores, echa un vistazo este responder.

Respondido el 28 de enero de 20 a las 11:01

@NoChance - ¡De nada, me alegro de poder ayudarlo! - Matt

¡Lindo! Finalmente lo descubrí todo 😂😂😂 - Momoro

A veces, desea deshacerse de esas configuraciones guardadas en el archivo tradicional web.config o app.config. Desea un control más detallado sobre la implementación de sus entradas de configuración y el diseño de datos separados. O el requisito es habilitar la adición de nuevas entradas en tiempo de ejecución.

Puedo imaginar dos buenas opciones:

  • La versión fuertemente tipada y
  • La versión orientada a objetos.

La ventaja de la versión fuertemente tipada son los nombres y valores de las configuraciones fuertemente tipadas. No hay riesgo de mezclar nombres o tipos de datos. La desventaja es que se deben codificar más configuraciones, no se pueden agregar en tiempo de ejecución.

Con la versión orientada a objetos, la ventaja es que se pueden agregar nuevas configuraciones en tiempo de ejecución. Pero no tiene nombres y valores fuertemente tipados. Debe tener cuidado con los identificadores de cadena. Debe conocer el tipo de datos guardado antes al obtener un valor.

Puede encontrar el código de ambas implementaciones completamente funcionales AQUÍ.

Respondido el 27 de diciembre de 13 a las 18:12

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();
    }
}

Respondido 27 Jul 16, 17:07

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.