Announcement

Collapse
No announcement yet.

MenüShortcutKeys in .config-datei speichern und wieder auslesen

Collapse
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • MenüShortcutKeys in .config-datei speichern und wieder auslesen

    ich weiss, dass man Programmeinstellungen in .config-dateien speichert.
    habe das aber noch nie gemacht.

    kann mir jemand bißchen quellcode geben, wie man da anfängt?
    ich möchte meine MenüShortcutKeys in eine config-datei und wieder auslesen!
    Herzliche Grüße

    Markus Lemcke
    barrierefreies Webdesign

  • #2
    Hallo,

    am einfachsten wenn im VS der Designer verwendet wird. Dort kann mittels den ApplicationSettings und PropertyBindings Eigenschaften in eine config-Datei gespeichert werden. Siehe Abbildung.

    Diese Einstellungen werden (zuerst) in der App.config gespeichert. Während der Laufzeit werden geänderte Einstellungen der User-Section in der config-Datei unter den Lokalen Einstellungen des Benutzer gespeichert.

    Um die Werte zu Speichern ist simpler Code notwendig
    [highlight=c#]
    // Speichern:
    Properties.Settings.Default.Save();

    // Zugriff auf Wert:
    Properties.Settings.Default.mnuKey10;
    [/highlight]
    Das Laden geschieht automatisch. Der Zugriff auf die Werte erfolgt ebenfalls ganz einfach.

    mfG Gü
    Attached Files
    "Any fool can write code that a computer can understand. Good programmers write code that humans can understand". - Martin Fowler

    Comment


    • #3
      Hallo,

      welcher Sinn steckt dahinter?
      In Delphi habe ich meine Daten in inis abgelegt (registry war mir zu umständlich)! Bei Programmstart habe ich geprüft ob es die ini-datei schon gibt oder nicht, wenn nicht, habe ich sie per sourcecode angelegt!

      dieses altbewährte prinzip hätte ich eigentlich in c# auch gerne vollzogen
      geht das irgendwie?
      wenn ja, würde ich mich über source-code freuen
      Herzliche Grüße

      Markus Lemcke
      barrierefreies Webdesign

      Comment


      • #4
        Hallo,

        der Sinn dahinter ist der gleiche wie bei INIs, nur dass hier die Daten in config-Files gespeichert werden. Diese sind Xml basiert und der vom Designer generierte Code erledigt das von dir gewünschte Verhalten. Der Zugriff auf Eigenschaften ist viel einfacher als beim INI-Zugriff (für diesen müssen API-Funktionen gebunden werden - entspricht auch ein wenig dem Grundprinzip von C# mit der Plattformunabhängigkeit) denn es nur eine Code-Zeile nötig.

        Alternativ könnten die Einstellungen auch selbst in Xml-Datein serialisiert werden (mit XmlSerializer) oder wenn die Datei mit den gespeicherten Einstellungen nicht "Humanreadalbe" sein muss auch mittels BinaryFormatter.

        Wenn es trotzdem INI sein muss dann schau unter http://dotnet-snippets.de/dns/c-ini-...se-SID660.aspx und http://dotnet-snippets.de/dns/c-ini-...ben-SID60.aspx

        Ich persönlich ziehe die Verwendung der Properties (Designer) vor.

        mfG Gü
        "Any fool can write code that a computer can understand. Good programmers write code that humans can understand". - Martin Fowler

        Comment


        • #5
          hi,

          ich möchte uch die properties verwenden!
          aber warum ist dem zusammenhang immer vom designer die rede?
          Welchen Sinn macht es die Konfigurationsdatei in der IDE zu erstellen?

          was mir bei sämtlichen codebeispielen die ich im netz entdcken konnte völig unklar ist, isdt die sache mit dem pfad!
          wenn ich mit delphi eine ini-datei anlege muss ich im erst sagen wo die liegen soll! c# kann angeblich hellsehen oder?
          Herzliche Grüße

          Markus Lemcke
          barrierefreies Webdesign

          Comment


          • #6
            Hallo,

            für allgemeine Infos über die Konfigurationsdatei möchte ich auf http://www.galileocomputing.de/openb...b5aafb9dc952ee verweisen.

            Vom Designer ist deshalb die Rede da dieser den Code zum Lesen/Schreiben in Form von Wrapper-Klassen (oder ist es nur eine - egal) erstellt und dir über diese Klasse Eigenschaften zum Lesen/Schreiben der Einstellungen anbietet. Der Sinn die Einstellungen in der IDE zu erstellen ist dass du selber keinen Code schreiben musst sonder in grafischen Oberfläche der IDE sagen kannst was in der Konfigurationsdatei gespeichert werden soll (oder nicht).

            Grundsätzlich sollte es egal sein wie die Konfigurationsdatei aufgebaut ist - Hauptsache die Wert kommen richtig Rein und Raus.

            Zur Sache mit dem Pfad:
            Alle Einstellungen die in der IDE erstellt werden sind in app.config (wird beim Kompilieren im Ausgabeverzeichnis umbenannt zu Anwendungsname.exe.config) als Xml gespeichert. Werden zur Laufzeit vom Benutzer Einstellungen geändert und über Properties.Settings.Default.Save() gespeichert dann werden die geänderten Eigenschaften in eine Xml-Datei 'user.config' gespeichert. Diese Datei liegt im Pfad der lokalen Anwendungeinstellungen des Users (C:\Dokumente und Einstellungen\<User>\Lokale Einstellungen\Anwendungsdaten\<Firma>\<Anwendungsn ame>.exe_Url_<Token>\<Version>\user.config).
            Somit wird dir ursprüngliche app.config nicht geändert -> für jeden User die selben Ausgangseinstellungen.

            Ich finde das ist eine gute Lösung, mit ein paar Mausklicks ist alles fertig.

            mfG Gü
            "Any fool can write code that a computer can understand. Good programmers write code that humans can understand". - Martin Fowler

            Comment


            • #7
              C# versucht einfach nur einen Standard durchzudrücken der da heißt
              allgemeine Anwendungseinstellungen liegen in der Anwendungsname.exe.config oder in einer userabhängigen config-Datei im Anwendungsdaten Ordner des Userprofils.
              Eine Supersache wenn sich alle dran halten und funktioniert auch immer.
              Ini. bzw. Registry-Bastler stolpern meißt spätestens an Rechte-Problemen wenn sie Ihre Anwendung unter Vista zum laufen bringen wollen.

              Und zum Thema Designer, man kann in Winforms jede(fast) Property per Databindung auch an die Config-Datei binden komplett ohne Code. Man erstellt dort also keine Config-Datei sondern bindet einfach nur und überläßt den Rest der NET-Magie im Hintergrund.

              Comment


              • #8
                Hi Gü,

                GallilioComputing habe ich sogar als richtiges Buch vor mir

                was mir fehlt ist ne alternative zu dem hier:
                Eine Anwendungskonfigurationsdatei mit Visual Studio 2008 bereitstellen

                In Dekphi konnte man ini-Files per code erstellen!

                Warum mir das so wichtig ist?

                ganz einfach:
                was passiert, wenn meine mit VS 2008 erstellte .config-datei gelöscht wird?

                In Delphi habe ich bei Programm start überprüft ob die ini-datei da ist und wenn nicht, habe ich sie per code erstellt und für die Anwendung wichtige werte reingeschrieben

                Das hätte ich gerne auch mit der .config-datei gemacht!!

                Geht oder geht nicht? wenn es geht, wie geht es ?
                Herzliche Grüße

                Markus Lemcke
                barrierefreies Webdesign

                Comment


                • #9
                  Hi,

                  wenn die Konfigurationsdatei in Lokalen Einstellungen gelöscht wird werden die Default-Werte aus der app.config verwendet (beim nächsten .Save() wird die user.config wieder erstellt).

                  Wird die app.config gelöscht startet die Anwendung nicht mehr da ihr eine Teil fehlt. Das Löschen dieser Datei ist vergleichbar mit dem Löschen der exe.

                  Wenn du aber die Einstellungen selbst verwalten willst muss Code geschrieben werden. Werde dir gleich ein Bsp posten....
                  "Any fool can write code that a computer can understand. Good programmers write code that humans can understand". - Martin Fowler

                  Comment


                  • #10
                    Um die Einstellungen selbst zu Verwalten können diese mit dem XmlSerializer serialisiert/deserialisert werden.

                    1) Erstelle ein Klasse mit mit den Anwendungeinstellungen:
                    [highlight=c#]
                    using System;
                    using System.Xml.Serialization;

                    namespace ConsoleApplication1
                    {
                    [Serializable()]
                    [XmlRoot("MeineKonfigEinstellungen")]
                    public class Anwendungseinstellungen
                    {
                    #region Felder
                    private string einstellung1 = "Defaultwert 1";
                    private string einstellung2 = "Defaultwert 2";
                    #endregion
                    //---------------------------------------------------------------------
                    #region Eigenschaften
                    [XmlElement("MeineEinstellung1")]
                    public string Einstellung1
                    {
                    get { return einstellung1; }
                    set { einstellung1 = value; }
                    }

                    [XmlElement("MeineEinstellung2")]
                    public string Einstellung2
                    {
                    get { return einstellung2; }
                    set { einstellung2 = value; }
                    }
                    #endregion
                    }
                    }
                    [/highlight]

                    2) Beispiel des Programms. Zur Serialisierung siehe 3).
                    [highlight=c#]
                    using System;
                    using System.IO;
                    using System.Xml.Serialization;
                    using gfoidl.Tools.Serialisierung;

                    namespace ConsoleApplication1
                    {
                    class Program
                    {
                    #region Konstanten
                    // Dateiendung ist egal.
                    public const string Konfigurationsdatei = "MeinKonfiguration.config";
                    #endregion
                    //---------------------------------------------------------------------
                    #region Felder
                    private static Anwendungseinstellungen konfig =
                    new Anwendungseinstellungen();
                    #endregion
                    //---------------------------------------------------------------------
                    static void Main(string[] args)
                    {
                    // Prüfen ob die Konfigurationsdatei existiert:
                    if (!File.Exists(Konfigurationsdatei))
                    // Existiert nicht -> erstellen mittels Serialisation:
                    XmlSerialisierung<Anwendungseinstellungen>.Seriali sieren(
                    konfig, Konfigurationsdatei);
                    else
                    // Existiert -> Einstellung mittels Deserialisation laden:
                    konfig =
                    XmlSerialisierung<Anwendungseinstellungen>.Deseria lisieren(Konfigurationsdatei);

                    // Zugriff auf Einstellungen:
                    Console.WriteLine(konfig.Einstellung1);

                    // Ändern von Einstellungen:
                    konfig.Einstellung2 = "Neuer Wert für Einstellung2";

                    // Einstellung speichern:
                    XmlSerialisierung<Anwendungseinstellungen>.Seriali sieren(
                    konfig, Konfigurationsdatei);

                    Console.ReadKey();
                    }
                    }
                    }
                    [/highlight]

                    3) Ich habe mal eine generische Klasse für die Serialisierung erstellt welche die XmlSerialisation vereinfacht (vom Zugriff und Komfort). Diese stelle ich hier zur Verfügung.
                    [highlight=c#]
                    /************************************************** ****************************
                    * Copyright: Nach österreichischem Urheberrecht geltent.
                    * Die Verwendung/Lizenzierung obliegt dem Autor.
                    ************************************************** ***************************/
                    using System.IO;
                    using System.Xml.Serialization;

                    namespace gfoidl.Tools.Serialisierung
                    {
                    /// <summary>
                    /// Generische Implementierung einer XML-Serialisation
                    /// </summary>
                    /// <typeparam name="T">
                    /// generischer Typ
                    /// </typeparam>
                    public static class XmlSerialisierung<T> where T : class
                    {
                    /// <summary>
                    /// Serialisiert das Objekt
                    /// </summary>
                    /// <param name="obj">
                    /// zu serialisierendes Objekt
                    /// </param>
                    /// <param name="file">
                    /// XML-Datei in die serialisiert wird
                    /// </param>
                    public static void Serialisieren(T obj, string file)
                    {
                    XmlSerializer xmlSer = new XmlSerializer(typeof(T));

                    using (FileStream fs = new FileStream(file, FileMode.Create))
                    {
                    xmlSer.Serialize(fs, obj);
                    }
                    }
                    //---------------------------------------------------------------------
                    /// <summary>
                    /// Deserialisiert das Objekt
                    /// </summary>
                    /// <param name="file">
                    /// XML-Datei
                    /// </param>
                    /// <returns>
                    /// deserialisiertes Objekt
                    /// </returns>
                    public static T Deserialisieren(string file)
                    {
                    XmlSerializer xmlSer = new XmlSerializer(typeof(T));

                    using (FileStream fs = new FileStream(file, FileMode.Open))
                    {
                    return xmlSer.Deserialize(fs) as T;
                    }
                    }
                    }
                    }
                    [/highlight]

                    Hoffe es hilft dir.

                    mfG Gü
                    "Any fool can write code that a computer can understand. Good programmers write code that humans can understand". - Martin Fowler

                    Comment


                    • #11
                      tach,

                      komme erst jetzt dazu!
                      mal schauen ob ich es hinbekomme!
                      vielen Dank für Deine hilfe!


                      Gruß


                      Markus
                      Herzliche Grüße

                      Markus Lemcke
                      barrierefreies Webdesign

                      Comment


                      • #12
                        ich habe jetzt aufgrund des Gallleo-Buch mit VS 2008 diese App.config.datei angelegt:
                        Code:
                        <?xml version="1.0" encoding="utf-8" ?>
                        <configuration>
                        </configuration>
                        ich möchte jetzt in <ApplicationSettings> Schriftart und Schriftfarbe einer Textbox speichern. was muss ixh nun tun, wenn ich die Datei weitzer von hand schreiben möche?
                        Herzliche Grüße

                        Markus Lemcke
                        barrierefreies Webdesign

                        Comment


                        • #13
                          folgender code ist aus dem netz und von mir noch etwas modifiziert:

                          Code:
                          using System;
                          using System.Xml;
                          using System.Configuration;
                          using System.Reflection;
                          using System.Collections.Generic;
                          using System.Linq;
                          using System.Text;
                          using System.IO;
                          using System.Windows.Forms;
                          
                          namespace Kommunikator
                          {
                              public class ConfigSettings
                              {
                                  private ConfigSettings() { }
                          
                                  public static string ReadSetting(string key)
                                  {
                                      bool vErg;
                                      vErg = ConfigFileExist();
                          
                                      if (vErg = false)
                                          CreateConfigFile();
                          
                                      return ConfigurationSettings.AppSettings[key];
                                  }
                          
                                  public static void WriteSetting(string key, string value)
                                  {
                                      // load config document for current assembly
                                      XmlDocument doc = loadConfigDocument();
                          
                                      // retrieve appSettings node
                                      XmlNode node = doc.SelectSingleNode("//appSettings");
                          
                                      if (node == null)
                                          throw new InvalidOperationException("appSettings section not found in config file.");
                          
                                      try
                                      {
                                          // select the 'add' element that contains the key
                                          XmlElement elem = (XmlElement)node.SelectSingleNode(string.Format("//add[@key='{0}']", key));
                          
                                          if (elem != null)
                                          {
                                              // add value for key
                                              elem.SetAttribute("value", value);
                                          }
                                          else
                                          {
                                              // key was not found so create the 'add' element 
                                              // and set it's key/value attributes 
                                              elem = doc.CreateElement("add");
                                              elem.SetAttribute("key", key);
                                              elem.SetAttribute("value", value);
                                              node.AppendChild(elem);
                                          }
                                          doc.Save(getConfigFilePath());
                                      }
                                      catch
                                      {
                                          throw;
                                      }
                                  }
                          
                                  public static void RemoveSetting(string key)
                                  {
                                      // load config document for current assembly
                                      XmlDocument doc = loadConfigDocument();
                          
                                      // retrieve appSettings node
                                      XmlNode node = doc.SelectSingleNode("//appSettings");
                          
                                      try
                                      {
                                          if (node == null)
                                              throw new InvalidOperationException("appSettings section not found in config file.");
                                          else
                                          {
                                              // remove 'add' element with coresponding key
                                              node.RemoveChild(node.SelectSingleNode(string.Format("//add[@key='{0}']", key)));
                                              doc.Save(getConfigFilePath());
                                          }
                                      }
                                      catch (NullReferenceException e)
                                      {
                                          throw new Exception(string.Format("The key {0} does not exist.", key), e);
                                      }
                                  }
                          
                                  private static XmlDocument loadConfigDocument()
                                  {
                                      XmlDocument doc = null;
                                      try
                                      {
                                          doc = new XmlDocument();
                                          doc.Load(getConfigFilePath());
                                          return doc;
                                      }
                                      catch (System.IO.FileNotFoundException e)
                                      {
                                          throw new Exception("No configuration file found.", e);
                                      }
                                  }
                          
                          
                          
                                  private static string getConfigFilePath()
                                  {
                                      return Assembly.GetExecutingAssembly().Location + ".config";
                                  }
                          
                                  //Überprüft ob es eine Config-Datei schon gibt
                                  public static bool ConfigFileExist()
                                  {
                                      string vConfigPfad;
                                      vConfigPfad = getConfigFilePath();
                                      if (File.Exists(vConfigPfad))
                                      {
                                          return true;
                                      }
                                      else return false;
                                  }
                          
                          
                                  //Erstellt eine leere Config-Datei
                                  public static void CreateConfigFile()
                                  {
                                      XmlWriter vConfig = XmlWriter.Create(getConfigFilePath());
                                      //Prolog erzeugen
                                      vConfig.WriteStartDocument();
                          
                                      vConfig.WriteStartElement("configuration");
                                      vConfig.WriteElementString("appSettings","");
                                      vConfig.WriteEndElement();
                                      vConfig.WriteEndDocument();
                                      vConfig.Close();
                                  }
                          
                          
                              }
                          }
                          Herzliche Grüße

                          Markus Lemcke
                          barrierefreies Webdesign

                          Comment


                          • #14
                            Hallo Markus,

                            warum benutzt du nicht den eingebauten Editor - der erzeugt die Codes für das Lesen/Schreiben der Einstellungen für dich. Effizient programmieren heißt auch vorhandene Mittel zu nutzen, anstatt "das Rad neu zu erfinden". Ich würde jedenfalls die VS-Unterstützung nutzen um mich auf das eigentliche Problem konzentrieren zu können.

                            mfG Gü
                            "Any fool can write code that a computer can understand. Good programmers write code that humans can understand". - Martin Fowler

                            Comment


                            • #15
                              Hallo Gü,

                              weil ich erst mal den Aufbau verstehen möchte! die Assistenten von VS verstecken sehr viel!
                              Mit dieser Klasse kann ich ja auch die Datei auslesen und das brauche ich auf jeden Fall!

                              andere Frage in dem Zusammenhang:
                              Beim aktuellen Projekt habe ich die Klassendatei "ConfigSettings.cs" ins Projekt kopiert!
                              schlauer ist es die Datei in ein "Lib-Verzeichnis" zentral abzulegen und dann in jedes Projekt wo Sie gebraucht wird einzubinden.
                              wie macht man in VS diese "Einbindung"?
                              Herzliche Grüße

                              Markus Lemcke
                              barrierefreies Webdesign

                              Comment

                              Working...
                              X