Einstellungen in *.config ändern

Hi ihr,

ich habs bereits hinbekommen Programmeinstellungen aus einer *.config -Datei auszulesen, aber ich möchte diese Einstellungen auch gerne ändern können, wie z.B. ein Pfad einer Datenbank oder sowas. Wie bekomme ich das hin?

Datei mit Notepad oder anderen Editor deiner Wahl öffnen, Änderungen schreiben, Datei->Speichern 😁

Aber da ich davon ausgehe, dass du das nicht meinst, sondern wie man programmatisch die Datei ändert: Benutzereinstellungen gehören nicht in die .config, sondern in eine eigene Konfigurationsdatei im Benutzer-spezifischen Einstellungsordner (z.B. in Environment.SpecialFolder.ApplicationData). Die .config ist eine globale Anwendungskonfiguration und sollte nur durch den Admin geändert werden.

MfG VizOne

Und was wäre dann so eine Konfigurationsdatei? Und wie kann man sie ändern, bzw. Einstellungen einlesen?

erstelle eine App.config und behandel diese wie eine XML Datei so kannst du dann die werte wunder bar ändern

nutze dafür name="" und value=""

ich kann dir auch ein beispiel liefern, nur bin ich grade aufn Sprung, sach einfach bescheit.

Das kann alles sein, was du willst, z.B. eine Binärdatei oder eine XML-Datei. Wenn du willst, dass die Datei von "außen" editierbar ist, dann würde ich XML nehmen.

Am einfachsten ist es, wenn du dir eine Klasse schreibst, die die Konfiguration enthält (z.B. Configuration) und diese dann in die entsprechende Datei serialisierst bzw. aus ihr deserialisierst.

Beispiel:

/// <summary>
/// Stores the configuration of the application
/// </summary>
[Serializable] // important: make it serializable!
public class Config {

    #region Methods
    /// <summary>
    /// Loads configuration from file
    /// </summary>
    /// <param name="fileName">Filename</param>
    /// <returns>The configuration loaded</returns>
    public static Config Load( string fileName ) {
        BinaryFormatter formatter = new BinaryFormatter();
        using ( Stream stream = File.OpenRead( GetRealPath( fileName ) ) ) {
            return formatter.Deserialize( stream ) as Config;
        }
    }

    /// <summary>
    /// Saves this config to a file
    /// </summary>
    /// <param name="fileName">Name of the file</param>
    public void Save( string fileName ) {
        BinaryFormatter formatter = new BinaryFormatter();
        using ( Stream stream = File.OpenWrite( GetRealPath( fileName ) ) ) {
            formatter.Serialize( stream, this );
        }
    }


    private static string GetRealPath( string path ) {
        string fileName = Path.GetFileName( path );
        string folder = string.Format("{0}{1}{2}{1}", 
            Environment.GetFolderPath( Environment.SpecialFolder.ApplicationData ),
            Path.DirectorySeparatorChar,
            "MyApp");
        if ( !Directory.Exists( folder ) ) {
            Directory.CreateDirectory( folder );
        }
        return folder + fileName;
    }


    /// <summary>
    /// Resets the configuration to a standard state
    /// </summary>
    public void Reset() {
        m_userName = "<Unknown>";
        m_blabla = 0;
    }
    #endregion


    #region Properties
    /// <summary>
    /// Returns the username
    /// </summary>
    /// <value>Username</value>
    public string UserName {
        get { return m_userName; }
        set { m_userName = value; }
    }

    /// <summary>
    /// Returns another config-property
    /// </summary>
    /// <value>Whatever...</value>
    public int Blabla {
        get { return m_blabla; }
        set { m_blabla = value; }
    }
    #endregion


    #region Fields
    string m_userName;
    int m_blabla;
    #endregion
}

Anwendung:

static void Main( string[] args ) {

    // speichern
    Config cfg = new Config();
    cfg.UserName = "Andre";
    cfg.Blabla = 100;
    cfg.Save( "config.bin" );

    // laden
    Config cfg2 = Config.Load( "config.bin" );

}

MfG VizOne

Hi,

Du kannst Dir für genau diesen Zweck auch den CAB (Configuration Application Block) aus der MSDN runterladen. Die Application Blocks sind Codebeispiele von Microsoft für Best Practices zu bestimmten Themen.

Such einfach mal in der MSDN ...

Viele Grüße,

Golo

Nehmen wir an, ich nutze eine XML-Datei für meine Optionen.
Nun schreibe ich eine Klasse "Config" mit den statischen Methoden Load() und Save().

Diese beiden Methoden laden Daten aus bzw. schreiben Daten in die XML-Datei.
Dazu brauche ich u.a. XmlTextReader und XmlTextWriter.

Erzeuge ich nun bei jedem Config.Load() bzw. Config.Save() innerhalb der Methode einen neue Instanz von XmlTextReader bzw. XmlTextWriter oder arbeite ich mit einer XML-Klasse (die aber ja auch bei jedem Laden oder Schreiben neu instanziert werden müsste), die dann von den beiden Methoden genutzt wird, oder...?

Mein Problem ist also nicht die Funktionalität (lesen und schreiben der XML-Datei klappt), sondern das Design.

Jeder Tipp wäre super, danke!

Setze doch einfach ein Configurations-Framework ein (z.B. NINI).

Die können Daten aus verschiedenen Quellen (Config, Xml, Registry, Ini) lesen und schreiben. Teilweise unterstützen die sogar die Benachrichtigung über externe Änderung der Datei zur Laufzeit.

Lohnt nicht was selbst zu coden....

Will ja was lernen und daher schon gerne selbst was schreiben.
Ist ja auch nicht das Problem, da es ja schon funktioniert.
Würde nur gerne wissen, wie man es richtig macht.

Des Weiteren denke ich, dass so ein Framework ein wenig übertrieben wäre. Ist nur ein ganz kleines Programm.

Hallo BillTuer,

zum Lernen gehört aber auch zu lernen, wann man was selber macht und wann was fertiges benutzt. 🙂

herbivore

Framework hört sich jetzt sehr mächtig an, ist aber eigentlich nichts weiter als eine Klasse.

Meine Erfahrung ist da folgende: Wenn man mit .NET anfängt ist man erstmal ganz begeistert, dass es da sowas wie Config-Files gibt und nutzt das auch fleissig. Irgendwann will man dann zurückspeichern und merkt: GEHT NICHT.

Dann testet man verschiedene Wege aus, codet mehr und mehr um letztlich doch zu merken, dass Aufwand und Nutzen in keinem Verhältnis mehr stehen.

Schließlich hat das ganze Thema nichts mit der eigentlichen Aufgabe zu tun sondern ist nur Infrastruktur-Schnickschack, den man eigentlich im .NET-Framework erwartet hätte.

Vielleicht merkt man auch irgendwann mal, dass man ja eigentlich User-spezifische Einstellungen hat, aber nur ein globales Config-File. Oder man will nicht, dass irgendjemand per Hand an der Config rummacht, der dazu gar nicht die Berechtigung hat (normaler User). Dann möchte man einen Teil der Daten nun doch in die Registry schieben, weil da eine Zugriffskontrolle stattfindet. Schwupps musst du deinen Code umschreiben.

Solche Frameworks abstrahieren, so dass du nur irgendwo eine Zeile Code austauschen musst und schon geht alles in die Registry anstelle ins Config.

Configuration und Tracing/Logging sollte man sich nicht selbst antun. Dafür gibts 1A Open-Source-Lösungen, die man auch nutzen sollte um sich auf die eigentliche Aufgabe konzentrieren zu können.

Aber wie gesagt: Wenn du es als Übungsaufgabe ansiehst, dann spricht nichts dagegen das mal selbst zu machen. Man lernt viel über XML-Serialisierung und deren Tücken. 🙂

Noch ein kleiner Tip dazu: XML-Serialisierung macht keine Schema-Prüfung! Wenn die XML-Datei nicht dem Format der Klasse entspricht (z.B. weil du was vergessen hast), dann ist das Feld im besten Falle leer. Deswegen ist es um so wichtiger, dass man für die Erzeugung der XML-Dateien ein Tool wie XmlSpy benutzt, welches ein Dokument validieren kann.

MS hat für diesen Fall sogar ein Tool geschrieben, welches direkt aus dem Schema die Klasse codegeneriert (xsd.exe). Leider sind diese Klassen so implementiert, dass man Aufzählungen nicht erweitern kann.