Comment faire pour enregistrer les paramètres de l'application dans une Application Windows Forms?

Si vous travaillez avec Visual Studio, alors il est assez facile d'obtenir des permanent des paramètres. Clic droit sur le projet dans l'Explorateur de solutions, cliquez sur Propriétés. Sélectionnez l'onglet Paramètres, cliquez sur le lien hypertexte si les paramètres n'existe pas. Utilisez l'onglet Paramètres pour créer des paramètres de l'application. Visual Studio crée les fichiers Settings.settings et Settings.Designer.settings qui contiennent de la classe singleton Settings hérité de ApplicationSettingsBase. Vous pouvez accéder à cette classe à partir de votre code de lecture/écriture des 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, Windows Forms et d'autres types de projet.

Noter que vous devrez régler la portée propriété de vos paramètres. Si vous sélectionnez l'Application puis sur Paramètres.Par défaut.< votre propriété > sera en lecture seule.

Le registre est un no-go. Vous n'êtes pas sûr de savoir si l'utilisateur qui utilise votre application, dispose de suffisamment de droits pour écrire dans le registre.

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

Je serait de stocker les paramètres spécifiques à l'utilisateur dans un fichier XML, ce qui serait enregistré dans Le Stockage Isolé ou dans le SpecialFolder.ApplicationData répertoire.

À côté de cela, comme de .NET 2.0, il est possible de stocker des valeurs de retour de la app.config fichier.

Je voulais partager une bibliothèque que j'ai construit pour cela. C'est une petite bibliothèque, mais une grande amélioration (à mon humble avis) de plus .les fichiers de paramètres.

La bibliothèque est appelée Iota (GitHub), voici une vieille Le Projet de Code de l'article j'ai écrit à ce sujet.

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

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 à .les fichiers de paramètres: Il y a beaucoup moins de code, et c'est beaucoup moins sujettes à l'erreur puisque vous n'avez qu'à mentionner chaque propriété une fois.

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

De stockage, la sérialisation, etc. sont entièrement configurables. Lorsque la cible objets sont créés par un conteneur IOC, vous pouvez [connecter][] de sorte qu'il s'applique suivi automatiquement à tous les objets qu'il résout, de sorte que tout ce que vous devez faire pour faire une propriété persistante est une claque [Suivi de] attribut.

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

Confiance en moi, la bibliothèque est au top!

Un moyen simple est d'utiliser une configuration de données de l'objet, de l'enregistrer comme un fichier XML avec le nom de l'application dans le Dossier local et au démarrage le lire.

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

La configuration dataobject 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; }
}
}

Un gérant de classe 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();
}
}
}

Maintenant, vous pouvez créer une instance et l'utilisation en charge de votre formulaire et de fermer les événements:

    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 produit de fichier XML 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>

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

• Si vous utilisez .NET 4.0 dynamique, cette bibliothèque est vraiment facile à utiliser
  (sérialiser, désérialiser, objets imbriqués de soutien et de commande de sortie
  comme vous le souhaitez + la fusion de plusieurs paramètres à un) JsonConfig (l'usage est l'équivalent de ApplicationSettingsBase)
• Pour .NET de configuration YAML, bibliothèque... je n'ai pas trouvé un qui est comme
  facile à utiliser comme JsonConfig

Vous pouvez stocker votre fichier de settings dans plusieurs dossiers spéciaux (pour tous les utilisateurs et par utilisateur) comme indiqué ici De l'environnement.SpecialFolder Énumération et plusieurs fichiers (par défaut en lecture seule, par rôle, par l'utilisateur, etc.)

• De l'échantillon pour obtenir le chemin 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, la fusion des paramètres par défaut + BasicUser + AdminUser. Vous pouvez utiliser vos propres règles: le dernier remplace la valeur, etc.

Autant que je peux dire .NET prend en charge la persistance des paramètres en utilisant l'application intégrée des paramètres de l'installation:

Les Paramètres de l'Application de la fonctionnalité de Windows Forms permet de créer, de stocker et de maintenir des applications personnalisées et des préférences de l'utilisateur sur l'ordinateur client. Avec Windows Forms paramètres de l'application, vous pouvez stocker non seulement des données d'application tels que la base de données de chaînes de connexion, mais aussi des données spécifiques à l'utilisateur, telles que l'utilisateur préférences de l'application. À l'aide de Visual Studio ou de code géré personnalisé, vous pouvez créer de nouveaux paramètres, de les lire et de les écrire sur le disque, les lier à des propriétés sur vos formes, et de valider les données de réglages avant le chargement et la sauvegarde.
- http://msdn.microsoft.com/en-us/library/k4s6c3a0.aspx

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