Comment puis-je enregistrer les paramètres d'application dans une application Windows Forms?

Ce que je veux réaliser est très simple: j'ai une application Windows Forms (.NET 3.5) qui utilise un chemin pour lire les informations. Ce chemin peut être modifié par l'utilisateur, en utilisant le formulaire d'options que je fournis.

Maintenant, je veux enregistrer la valeur du chemin d'accès dans un fichier pour une utilisation ultérieure. Ce serait l'un des nombreux paramètres enregistrés dans ce fichier. Ce fichier se trouverait directement dans le dossier de l'application.

Je comprends que trois options sont disponibles:

• Fichier ConfigurationSettings (appname.exe.config)
• Enregistrement
• Fichier XML personnalisé

J'ai lu que le fichier de configuration .NET n'est pas prévu pour y sauvegarder des valeurs. Quant au registre, je voudrais m'en éloigner le plus possible.

Est-ce à dire que je dois utiliser un fichier XML personnalisé pour enregistrer les paramètres de configuration?

Si c'est le cas, je voudrais voir un exemple de code (C #).

J'ai vu d'autres discussions sur ce sujet, mais ce n'est toujours pas clair pour moi.

Si vous travaillez avec Visual Studio, il est assez facile d'obtenir des paramètres persistants. Cliquez avec le bouton droit sur le projet dans l'Explorateur de solutions et choisissez Propriétés. Sélectionnez l'onglet Paramètres et cliquez sur l'hyperlien si les paramètres n'existent pas.

Utilisez l'onglet Paramètres pour créer des paramètres d'application. Visual Studio crée les fichiers Settings.settingset Settings.Designer.settingsqui contiennent la classe singleton Settingshéritée d' ApplicationSettingsBase . Vous pouvez accéder à cette classe à partir de votre code pour lire / écrire les paramètres de l'application:

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

Cette technique est applicable à la fois pour la console, les Windows Forms et d'autres types de projets.

Notez que vous devez définir la propriété d' étendue de vos paramètres. Si vous sélectionnez Portée d'application, Settings.Default. <Votre propriété> sera en lecture seule.

Référence: Comment: écrire des paramètres utilisateur lors de l'exécution avec C # - Microsoft Docs

Si vous prévoyez d'enregistrer dans un fichier dans le même répertoire que votre exécutable, voici une bonne solution qui utilise le format 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;
        }
    }
}

Le registre est un no-go. Vous n'êtes pas sûr que l'utilisateur qui utilise votre application dispose des droits suffisants pour écrire dans le registre.

Vous pouvez utiliser le app.configfichier pour enregistrer les paramètres au niveau de l'application (qui sont les mêmes pour chaque utilisateur qui utilise votre application).

Je stockerais les paramètres spécifiques à l'utilisateur dans un fichier XML, qui serait enregistré dans le stockage isolé ou dans le répertoire SpecialFolder.ApplicationData .

À côté de cela, à partir de .NET 2.0, il est possible de stocker des valeurs dans le app.configfichier.

La ApplicationSettingsclasse ne prend pas en charge l'enregistrement des paramètres dans le fichier app.config . C'est très bien par conception; les applications qui s'exécutent avec un compte d'utilisateur correctement sécurisé (pensez à Vista UAC) n'ont pas accès en écriture au dossier d'installation du programme.

Vous pouvez combattre le système avec la ConfigurationManagerclasse. Mais la solution de contournement triviale consiste à entrer dans le concepteur de paramètres et à modifier la portée du paramètre en utilisateur. Si cela cause des difficultés (par exemple, le paramètre est pertinent pour chaque utilisateur), vous devez placer votre fonctionnalité Options dans un programme distinct afin de pouvoir demander l'invite d'élévation des privilèges. Ou renoncez à utiliser un paramètre.

L'argument Registry / configurationSettings / XML semble toujours très actif. Je les ai tous utilisés, au fur et à mesure que la technologie a progressé, mais mon préféré est basé sur le système de Threed combiné avec le stockage isolé .

L'exemple suivant permet le stockage d'un objet nommé propriétés dans un fichier dans un stockage isolé. Tel que:

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

Les propriétés peuvent être récupérées en utilisant:

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

Il ne s'agit que d'un échantillon, ne suggérant pas les meilleures pratiques.

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

Je voulais partager une bibliothèque que j'ai construite pour cela. C'est une petite bibliothèque, mais une grande amélioration (à mon humble avis) par rapport aux fichiers .settings.

La bibliothèque s'appelle Jot (GitHub) . Voici un vieil article de The Code Project que j'ai écrit à ce sujet.

Voici comment l'utiliser pour garder une trace de la taille et de l'emplacement d'une fenêtre:

public MainWindow()
{
    InitializeComponent();

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

L'avantage par rapport aux fichiers .settings: il y a beaucoup moins de code et il est beaucoup moins sujet aux erreurs car vous n'avez besoin de mentionner chaque propriété qu'une seule fois .

Avec un fichier de paramètres, vous devez mentionner chaque propriété cinq fois: une fois lorsque vous créez explicitement la propriété et quatre fois supplémentaires dans le code qui copie les valeurs d'avant en arrière.

Le stockage, la sérialisation, etc. sont entièrement configurables. Lorsque les objets cibles sont créés par un IoC conteneur , vous pouvez [le raccorder] [] afin qu'il applique automatiquement le suivi à tous les objets qu'il résout, de sorte que tout ce que vous devez faire pour rendre une propriété persistante est de gifler un [Trackable] attribuer dessus.

Il est hautement configurable et vous pouvez configurer: - lorsque les données sont persistantes et appliquées globalement ou pour chaque objet suivi - comment elles sont sérialisées - où elles sont stockées (par exemple fichier, base de données, en ligne, stockage isolé, registre) - règles qui peuvent annuler l'application / données persistantes pour une propriété

Croyez-moi, la bibliothèque est de premier ordre!

Un moyen simple consiste à utiliser un objet de données de configuration, à l'enregistrer en tant que fichier XML avec le nom de l'application dans le dossier local et au démarrage à le relire.

Voici un exemple pour stocker la position et la taille d'un formulaire.

L'objet de données de configuration est fortement typé et facile à utiliser:

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

Une classe gestionnaire pour la sauvegarde et le chargement:

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

Vous pouvez maintenant créer une instance et l'utiliser dans les événements de chargement et de fermeture de votre formulaire:

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

Et le fichier XML produit est également lisible:

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

Je n'aime pas la solution proposée d'utiliser web.configou app.config. Essayez de lire votre propre XML. Jetez un œil aux fichiers de paramètres XML - Plus de web.config .

D'autres options, au lieu d'utiliser un fichier XML personnalisé, nous pouvons utiliser un format de fichier plus convivial: fichier JSON ou YAML.

• Si vous utilisez .NET 4.0 dynamic, cette bibliothèque est vraiment facile à utiliser (sérialiser, désérialiser, prendre en charge les objets imbriqués et ordonner la sortie comme vous le souhaitez + fusionner plusieurs paramètres en un seul) JsonConfig (l'utilisation est équivalente à ApplicationSettingsBase)
• Pour la bibliothèque de configuration .NET YAML ... Je n'en ai pas trouvé qui soit aussi facile à utiliser que JsonConfig

Vous pouvez stocker votre fichier de paramètres dans plusieurs dossiers spéciaux (pour tous les utilisateurs et par utilisateur) comme indiqué ici Environment.SpecialFolder Enumeration et plusieurs fichiers (par défaut en lecture seule, par rôle, par utilisateur, etc.)

• Exemple pour obtenir le chemin d'accès du dossier spécial: C # obtenir le chemin d'accès de% AppData%

Si vous choisissez d'utiliser plusieurs paramètres, vous pouvez fusionner ces paramètres: par exemple, fusionner les paramètres par défaut + BasicUser + AdminUser. Vous pouvez utiliser vos propres règles: la dernière remplace la valeur, etc.

"Cela signifie-t-il que je devrais utiliser un fichier XML personnalisé pour enregistrer les paramètres de configuration?" Non pas forcément. Nous utilisons SharpConfig pour de telles opérations.

Par exemple, si un fichier de configuration est comme ça

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

Nous pouvons récupérer des valeurs comme celle-ci

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

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

Il est compatible avec .NET 2.0 et supérieur. Nous pouvons créer des fichiers de configuration à la volée et nous pouvons les enregistrer plus tard.

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

Pour autant que je sache, .NET prend en charge les paramètres persistants à l'aide de la fonction de paramètres d'application intégrée:

La fonction Paramètres d'application de Windows Forms facilite la création, le stockage et la gestion des préférences personnalisées d'application et d'utilisateur sur l'ordinateur client. Avec les paramètres d'application Windows Forms, vous pouvez stocker non seulement les données d'application telles que les chaînes de connexion à la base de données, mais également les données spécifiques à l'utilisateur, telles que les préférences d'application utilisateur. À l'aide de Visual Studio ou d'un code managé personnalisé, vous pouvez créer de nouveaux paramètres, les lire et les écrire sur le disque, les lier aux propriétés de vos formulaires et valider les données de paramètres avant le chargement et l'enregistrement. - http://msdn.microsoft.com/en-us/library/k4s6c3a0.aspx

Parfois, vous voulez vous débarrasser de ces paramètres conservés dans le fichier web.config ou app.config traditionnel. Vous voulez un contrôle plus fin sur le déploiement de vos entrées de paramètres et la conception de données séparées. Ou l'exigence est d'activer l'ajout de nouvelles entrées lors de l'exécution.

Je peux imaginer deux bonnes options:

• La version fortement typée et
• La version orientée objet.

L'avantage de la version fortement typée réside dans les noms et valeurs des paramètres fortement typés. Il n'y a aucun risque de mélanger des noms ou des types de données. L'inconvénient est que plus de paramètres doivent être codés, ne peuvent pas être ajoutés au moment de l'exécution.

Avec la version orientée objet, l'avantage est que de nouveaux paramètres peuvent être ajoutés au moment de l'exécution. Mais vous n'avez pas de noms et de valeurs fortement saisis. Doit être prudent avec les identificateurs de chaîne. Doit connaître le type de données enregistré précédemment lors de l'obtention d'une valeur.

Vous pouvez trouver le code des deux implémentations entièrement fonctionnelles ICI .

Oui, il est possible d'enregistrer la configuration - mais cela dépend à peu près de la façon dont vous choisissez de le faire. Permettez-moi de décrire les différences techniques afin que vous puissiez comprendre les options dont vous disposez:

Tout d'abord, vous devez distinguer si vous souhaitez utiliser applicationSettings ou AppSettings dans votre fichier *.exe.config(aka App.configdans Visual Studio) - il existe des différences fondamentales, décrites ici .

Les deux offrent différentes façons d'enregistrer les modifications:

• Les AppSettings vous permettent de lire et d'écrire directement dans le fichier de configuration (via config.Save(ConfigurationSaveMode.Modified);, où config est défini comme config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);).
  
  
• Les paramètres d'application permettent de lire, mais si vous écrivez des modifications (via Properties.Settings.Default.Save();), elles seront écrites par utilisateur, stockées dans un endroit spécial (par exemple C:\Documents and Settings\USERID\Local Settings\Application Data\FIRMNAME\WindowsFormsTestApplicati_Url_tdq2oylz33rzq00sxhvxucu5edw2oghw\1.0.0.0). Comme Hans Passant l'a mentionné dans sa réponse, cela est dû au fait qu'un utilisateur a généralement des droits restreints sur Program Files et ne peut pas y écrire sans invoquer l'invite UAC. Un inconvénient est que si vous ajoutez des clés de configuration à l'avenir, vous devez les synchroniser avec chaque profil utilisateur.
  

Remarque: Comme mentionné dans la question, il existe une troisième option: si vous traitez le fichier de configuration comme un document XML, vous pouvez le charger, le modifier et l'enregistrer en utilisant la System.Xml.Linq.XDocumentclasse. Il n'est pas nécessaire d'utiliser un fichier XML personnalisé, vous pouvez lire le fichier de configuration existant; pour interroger des éléments, vous pouvez même utiliser des requêtes Linq. J'ai donné un exemple ici , consultez la fonction GetApplicationSettinglà-bas dans la réponse.

Si vous avez besoin d'un chiffrement pour protéger vos valeurs, consultez cette réponse.

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