Wie kann ich Anwendungseinstellungen in einer Windows Forms-Anwendung speichern?

Was ich erreichen möchte, ist sehr einfach: Ich habe eine Windows Forms-Anwendung (.NET 3.5), die einen Pfad zum Lesen von Informationen verwendet. Dieser Pfad kann vom Benutzer mithilfe des von mir bereitgestellten Optionsformulars geändert werden.

Jetzt möchte ich den Pfadwert zur späteren Verwendung in einer Datei speichern. Dies wäre eine der vielen Einstellungen, die in dieser Datei gespeichert sind. Diese Datei würde sich direkt im Anwendungsordner befinden.

Ich verstehe, dass drei Optionen verfügbar sind:

• ConfigurationSettings-Datei (appname.exe.config)
• Registrierung
• Benutzerdefinierte XML-Datei

Ich habe gelesen, dass die .NET-Konfigurationsdatei nicht zum Speichern von Werten vorgesehen ist. Was die Registrierung betrifft, möchte ich mich so weit wie möglich davon entfernen.

Bedeutet dies, dass ich eine benutzerdefinierte XML-Datei verwenden sollte, um Konfigurationseinstellungen zu speichern?

Wenn ja, würde ich gerne ein Codebeispiel dafür sehen (C #).

Ich habe andere Diskussionen zu diesem Thema gesehen, aber es ist mir immer noch nicht klar.

Wenn Sie mit Visual Studio arbeiten, ist es ziemlich einfach, dauerhafte Einstellungen zu erhalten. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt und wählen Sie Eigenschaften. Wählen Sie die Registerkarte Einstellungen und klicken Sie auf den Hyperlink, wenn keine Einstellungen vorhanden sind.

Verwenden Sie die Registerkarte Einstellungen, um Anwendungseinstellungen zu erstellen. Visual Studio erstellt die Dateien Settings.settingsund Settings.Designer.settingsdas enthält die Singleton - Klasse Settingsgeerbt Application . Sie können über Ihren Code auf diese Klasse zugreifen, um Anwendungseinstellungen zu lesen / schreiben:

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

Diese Technik ist sowohl für Konsolen, Windows Forms als auch für andere Projekttypen anwendbar.

Beachten Sie, dass Sie die Bereichseigenschaft Ihrer Einstellungen festlegen müssen . Wenn Sie Anwendungsbereich auswählen, ist Settings.Default. <Ihreigenschaft> schreibgeschützt.

Referenz: Gewusst wie: Schreiben von Benutzereinstellungen zur Laufzeit mit C # - Microsoft Docs

Wenn Sie vorhaben, in einer Datei im selben Verzeichnis wie Ihre ausführbare Datei zu speichern, finden Sie hier eine nette Lösung, die das JSON- Format verwendet:

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

Die Registrierung ist ein No-Go. Sie sind sich nicht sicher, ob der Benutzer, der Ihre Anwendung verwendet, über ausreichende Rechte zum Schreiben in die Registrierung verfügt.

Sie können die app.configDatei zum Speichern von Einstellungen auf Anwendungsebene verwenden (die für jeden Benutzer, der Ihre Anwendung verwendet, gleich sind).

Ich würde benutzerspezifische Einstellungen in einer XML-Datei speichern, die im isolierten Speicher oder im Verzeichnis SpecialFolder.ApplicationData gespeichert würde .

Darüber hinaus ist es ab .NET 2.0 möglich, Werte wieder in der app.configDatei zu speichern.

Die ApplicationSettingsKlasse unterstützt das Speichern von Einstellungen in der Datei app.config nicht . Das ist sehr beabsichtigt; Anwendungen, die mit einem ordnungsgemäß gesicherten Benutzerkonto ausgeführt werden (z. B. Vista UAC), haben keinen Schreibzugriff auf den Installationsordner des Programms.

Sie können das System mit der ConfigurationManagerKlasse bekämpfen . Die triviale Problemumgehung besteht jedoch darin, in den Einstellungsdesigner zu wechseln und den Bereich der Einstellung in Benutzer zu ändern. Wenn dies zu Schwierigkeiten führt (z. B. ist die Einstellung für jeden Benutzer relevant), sollten Sie Ihre Optionsfunktion in ein separates Programm einfügen, damit Sie nach der Eingabeaufforderung zur Erhöhung von Berechtigungen fragen können. Oder verzichten Sie auf eine Einstellung.

Das Argument registry / configurationSettings / XML scheint immer noch sehr aktiv zu sein. Ich habe sie alle verwendet, während die Technologie Fortschritte gemacht hat, aber mein Favorit basiert auf dem System von Threed in Kombination mit isoliertem Speicher .

Das folgende Beispiel ermöglicht das Speichern von Objekten mit dem Namen properties in einer Datei im isolierten Speicher. Sowie:

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

Eigenschaften können wiederhergestellt werden mit:

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

Dies ist nur ein Beispiel, das keine Best Practices enthält.

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

Ich wollte eine Bibliothek teilen, die ich dafür gebaut habe. Es ist eine winzige Bibliothek, aber eine große Verbesserung (IMHO) gegenüber .settings-Dateien.

Die Bibliothek heißt Jot (GitHub) . Hier ist ein alter Artikel von The Code Project, den ich darüber geschrieben habe.

So würden Sie es verwenden, um die Größe und Position eines Fensters zu verfolgen:

public MainWindow()
{
    InitializeComponent();

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

Der Vorteil im Vergleich zu .settings-Dateien: Es gibt erheblich weniger Code und es ist viel weniger fehleranfällig, da Sie jede Eigenschaft nur einmal erwähnen müssen .

Bei Einstellungsdateien müssen Sie jede Eigenschaft fünfmal erwähnen : einmal, wenn Sie die Eigenschaft explizit erstellen, und weitere viermal im Code, der die Werte hin und her kopiert.

Speicher, Serialisierung usw. sind vollständig konfigurierbar. Wenn die Zielobjekte von einem IoC- Container erstellt werden, können Sie [[einbinden] [], sodass die Verfolgung automatisch auf alle aufgelösten Objekte angewendet wird. Alles, was Sie tun müssen, um eine Eigenschaft dauerhaft zu machen, ist ein [Trackingable] zu schlagen. Attribut darauf.

Es ist hochgradig konfigurierbar und Sie können Folgendes konfigurieren: - wenn Daten global oder für jedes verfolgte Objekt beibehalten und angewendet werden - wie sie serialisiert werden - wo sie gespeichert werden (z. B. Datei, Datenbank, Online, isolierter Speicher, Registrierung) - Regeln, die die Anwendung abbrechen können / persistente Daten für eine Eigenschaft

Vertrauen Sie mir, die Bibliothek ist erstklassig!

Eine einfache Möglichkeit besteht darin, ein Konfigurationsdatenobjekt zu verwenden, es als XML-Datei mit dem Namen der Anwendung im lokalen Ordner zu speichern und beim Start zurückzulesen.

Hier ist ein Beispiel zum Speichern der Position und Größe eines Formulars.

Das Konfigurationsdatenobjekt ist stark typisiert und einfach zu verwenden:

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

Eine Manager-Klasse zum Speichern und Laden:

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

Jetzt können Sie eine Instanz erstellen und in den Lade- und Schließereignissen Ihres Formulars verwenden:

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

Die erstellte XML-Datei ist auch lesbar:

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

Ich mag die vorgeschlagene Lösung der Verwendung von web.configoder nicht app.config. Versuchen Sie, Ihr eigenes XML zu lesen. Schauen Sie sich die XML-Einstellungsdateien an - Keine web.config mehr .

Andere Optionen, anstatt eine benutzerdefinierte XML-Datei zu verwenden, können wir ein benutzerfreundlicheres Dateiformat verwenden: JSON- oder YAML-Datei.

• Wenn Sie .NET 4.0 dynamic verwenden, ist diese Bibliothek sehr einfach zu verwenden (Serialisierung, Deserialisierung, Unterstützung verschachtelter Objekte und Reihenfolge der Ausgabe nach Ihren Wünschen + Zusammenführen mehrerer Einstellungen zu einer). JsonConfig (Verwendung entspricht ApplicationSettingsBase)
• Für die .NET YAML-Konfigurationsbibliothek ... Ich habe keine gefunden, die so einfach zu verwenden ist wie JsonConfig

Sie können Ihre Einstellungsdatei in mehreren speziellen Ordnern (für alle Benutzer und pro Benutzer) speichern, wie hier aufgeführt. Environment.SpecialFolder Enumeration und mehrere Dateien (standardmäßig schreibgeschützt, pro Rolle, pro Benutzer usw.)

• Beispiel für den Pfad eines speziellen Ordners: C # Ermittelt den Pfad von% AppData%

Wenn Sie mehrere Einstellungen verwenden möchten, können Sie diese Einstellungen zusammenführen: Beispiel: Zusammenführen von Einstellungen für Standard + BasicUser + AdminUser. Sie können Ihre eigenen Regeln verwenden: Die letzte überschreibt den Wert usw.

"Bedeutet dies, dass ich eine benutzerdefinierte XML-Datei verwenden sollte, um Konfigurationseinstellungen zu speichern?" Nein, nicht unbedingt. Wir verwenden SharpConfig für solche Operationen.

Zum Beispiel, wenn eine Konfigurationsdatei so ist

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

Wir können solche Werte abrufen

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

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

Es ist kompatibel mit .NET 2.0 und höher. Wir können Konfigurationsdateien im laufenden Betrieb erstellen und später speichern.

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

Soweit ich das beurteilen kann, unterstützt .NET dauerhafte Einstellungen mithilfe der integrierten Funktion für Anwendungseinstellungen:

Mit der Funktion "Anwendungseinstellungen" von Windows Forms können Sie auf einfache Weise benutzerdefinierte Anwendungs- und Benutzereinstellungen auf dem Clientcomputer erstellen, speichern und verwalten. Mit den Windows Forms-Anwendungseinstellungen können Sie nicht nur Anwendungsdaten wie Datenbankverbindungszeichenfolgen, sondern auch benutzerspezifische Daten wie Benutzeranwendungseinstellungen speichern. Mit Visual Studio oder benutzerdefiniertem verwaltetem Code können Sie neue Einstellungen erstellen, diese lesen und auf die Festplatte schreiben, sie an Eigenschaften in Ihren Formularen binden und Einstellungsdaten vor dem Laden und Speichern überprüfen. - http://msdn.microsoft.com/en-us/library/k4s6c3a0.aspx

Manchmal möchten Sie diese Einstellungen entfernen, die in der herkömmlichen Datei web.config oder app.config gespeichert sind. Sie möchten eine genauere Kontrolle über die Bereitstellung Ihrer Einstellungseinträge und das getrennte Daten-Design. Oder Sie müssen das Hinzufügen neuer Einträge zur Laufzeit aktivieren.

Ich kann mir zwei gute Möglichkeiten vorstellen:

• Die stark typisierte Version und
• Die objektorientierte Version.

Der Vorteil der stark typisierten Version sind die stark typisierten Einstellungsnamen und -werte. Es besteht kein Risiko, Namen oder Datentypen zu vermischen. Der Nachteil ist, dass mehr Einstellungen codiert werden müssen, die zur Laufzeit nicht hinzugefügt werden können.

Bei der objektorientierten Version besteht der Vorteil darin, dass zur Laufzeit neue Einstellungen hinzugefügt werden können. Sie haben jedoch keine stark typisierten Namen und Werte. Muss mit String-IDs vorsichtig sein. Der Datentyp muss früher gespeichert werden, wenn ein Wert abgerufen wird.

Den Code der beiden voll funktionsfähigen Implementierungen finden Sie HIER .

Ja, es ist möglich, die Konfiguration zu speichern - aber es hängt ziemlich stark davon ab, wie Sie sich dafür entscheiden. Lassen Sie mich die technischen Unterschiede beschreiben, damit Sie die Optionen verstehen, die Sie haben:

Zunächst müssen Sie unterscheiden, ob Sie applicationSettings oder AppSettings in Ihrer Datei *.exe.config(auch bekannt als App.configin Visual Studio) verwenden möchten. Hier werden grundlegende Unterschiede beschrieben .

Beide bieten verschiedene Möglichkeiten zum Speichern von Änderungen:

• Mit den AppSettings können Sie direkt in die Konfigurationsdatei lesen und schreiben (via config.Save(ConfigurationSaveMode.Modified);, wobei config als definiert ist config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);).
  
  
• Die applicationSettings ermöglichen das Lesen, aber wenn Sie Änderungen (über Properties.Settings.Default.Save();) schreiben , werden diese auf Benutzerbasis geschrieben und an einem bestimmten Ort (z C:\Documents and Settings\USERID\Local Settings\Application Data\FIRMNAME\WindowsFormsTestApplicati_Url_tdq2oylz33rzq00sxhvxucu5edw2oghw\1.0.0.0. B. ) gespeichert . Wie Hans Passant in seiner Antwort erwähnte , liegt dies daran, dass ein Benutzer normalerweise eingeschränkte Rechte an Programmdateien hat und nicht darauf schreiben kann, ohne die UAC-Eingabeaufforderung aufzurufen. Ein Nachteil ist, dass Sie beim Hinzufügen von Konfigurationsschlüsseln in Zukunft diese mit jedem Benutzerprofil synchronisieren müssen.
  

Hinweis: Wie in der Frage erwähnt, gibt es eine dritte Option: Wenn Sie die Konfigurationsdatei als XML-Dokument behandeln, können Sie sie mithilfe der System.Xml.Linq.XDocumentKlasse laden, ändern und speichern . Es ist nicht erforderlich, eine benutzerdefinierte XML-Datei zu verwenden. Sie können die vorhandene Konfigurationsdatei lesen. Zum Abfragen von Elementen können Sie sogar Linq-Abfragen verwenden. Ich habe ein Beispiel gegeben hier , um die Funktion überprüfen GetApplicationSettinges in der Antwort.

Wenn Sie benötigen Verschlüsselung , um Ihre Werte zu schützen, überprüfen Sie diese Antwort.

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