XML ApplicationSettings und .NET CF



  • Hallo zusammen,

    im "großen" .NET Framework gibt es ja die Klasse ApplicationSettingsBase um Anwendungseinstellungen zu laden. Im Moment bin ich dabei eine Anwendung für einen PDA mit .NET Compact Framework zu ertsllen. Leider wird hier die ApplicationSettingsBase nicht zur Vefügung gestellt.

    Hat jemand eine Idee, wie ich auf einfache Art und Weise (möglichst mit den Bordmitteln des .NET CF) Einstellungen einlesen kann. Hier im Forum wurde ich trotz Suche (die Suchfunktion ist nicht wirklich gut 😞 ) nicht fündig.

    Gruß
    Kramny



  • Wenn es wenig Infomationen sind oder die Lade- Speicherzeit nicht ganz wichtig ist, dann würde ich XML nehmen. Ist ganz einfach...



  • Hm,
    es wird wohl auf eine XML-Datei hinauslaufen, da es wirklich nicht viele Daten zum Lesen sind. Ich bin mir nur nicht sicher wie ich das am Besten bewerkstelligen soll.
    Die Struktur für meine XML-Datei habe ich mir z.B. wie folgt überlegt:

    <Settings>
    	<Application>
    	    <UsingGPSDefault>0</UsingGPSDefault>
    	    <StoringRawDefault>1</StoringRawDefault>
    	    <DefaultMethod>Wertziffer</DefaultMethod>
    	</Application>
    	<MeassureMethod1>
    		<FFT_Length>2048</FFT_Length>
    		<FFT_Overlap>1024</FFT_Overlap>
    	</MeassureMethod1>
    	<MeassureMethod2>
    		<FFT_Length>2048</FFT_Length>
    		<FFT_Overlap>1024</FFT_Overlap>
    	</MeassureMethod2>
    	<DAQ-Modul>
    		<ClockDivider>5</ClockDivider>
    	</DAQ-Modul>
    	<GPS-Modul>
    		<Port>COM6</Port>
    		<Baudrate>38400</Baudrate>
    	</GPS-Modul>
    </Settings>
    

    Die Frage ist nun, wie ich am einfachsten auf die einzelnen Konten zugreifen kann. In meiner Beispielanwendung ist eine Klasse, die sich um den GPS-Empfang kümmert, diese soll im Konstruktoraufruf die Daten, die unter dem Knoten "GPS-Modul" stehen einlesen. Eine Andere Klasse ist z.B. "MeassureMethod1". diese soll ebenfalls bei der Instanzerstellung die Daen vom Knoten "MeassureMethod1" einlesen.

    Am liebsten wäre mir ein Aufruf wie:

    public class MeassureMethod1
    {
      private int fft_length;
      //...
    
      public constructor()
      {
        this.fft_length = LeseInt("MeassureMethod1", "FFT_Length");
      }
    }
    
    public class MeassureMethod1
    {
      private int baudrate;
      //...
    
      public constructor()
      {
        this.baudrate = LeseInt("GPS-Modul", "baudrate");
      }
    }
    

    LeseInt greift dabei direkt auf das XML-Dokument zu (bzw. wurde das XML-Dokument bereits mittels XMLDocument.Load()) geladen und liest den Wert (hier 2048) und gibt ihn als Return-Wert zurück. Diese Funktionen würde ich gerne in eine eigene (statische) Klasse auslagern.
    Ist sowas in der Art denkbar, und welchen Ansatz wähle ich am Besten um im XML-Dokument frei navigieren zu können? Ich bin da etwas ratlos.

    Vielen Dank.

    Gruß
    Kramny



  • Ich hatte da einen andere Art im Sinn (Ein Name:Wert-Speicherung):

    using System;
    using System.Collections.Generic;
    using System.Xml;
    using System.Xml.Serialization;
    
    namespace Somewhere
    {
        //TODO: Bei Vererbung "sealed"-Schlüsselwort entfernen
        /// <summary>
        /// Eine Klasse zum Speichern von String-Werten in eine
        /// XML-Datei.
        /// </summary>
        public sealed class Settings
        {
            private static Dictionary<String, String> data;
    
            // Schlüsseldefinitonen
            private const String root = "settings";
            private const String child = "setting";
            private const String key = "key";
    
            //TODO: Unter Umständen einen absoluten Pfads verwenden
            private const String file = "icons.xml";
    
            private Settings() { }
    
            /// <summary>
            /// Bereitet den Zugriff auf die Optionen vor
            /// </summary>
            static Settings()
            {
                data = new Dictionary<String, String>();
                Read();
            }
    
            /// <summary>
            /// Ließt die Eintellungen aus der XML-Datei
            /// </summary>
            /// <returns>
            /// true, wenn es keine Fehler gab, sonst false
            /// </returns>
            public static bool Read()
            {
                XmlTextReader reader = null;
                try
                {
                    reader = new XmlTextReader(file);
    
                    data.Clear();
    
                    reader.ReadStartElement(root);
    
                    while (reader.ReadToFollowing(child))
                    {
                        data.Add(
                            reader.GetAttribute(key),
                            reader.ReadString());
                    }
                    return true;
                }
                catch { }
                finally
                {
                    if (reader != null)
                        reader.Close();
                }
                return false;
            }
    
            /// <summary>
            /// Speichert die Datei
            /// </summary>
            /// <returns>
            /// true, wenn es keine Fehler gab, sonst false
            /// </returns>
            public static bool Save()
            {
                XmlTextWriter writer = null;
                try
                {
                    writer = new XmlTextWriter(
                        file, Encoding.Default);
                    writer.Formatting = Formatting.Indented;
                    writer.WriteStartDocument();
                    writer.WriteStartElement(root);
                    foreach (
                        KeyValuePair<String, String>
                            pair in data)
                    {
                        writer.WriteStartElement(child);
                        writer.WriteStartAttribute(key);
                        writer.WriteString(pair.Key);
                        writer.WriteEndAttribute();
                        writer.WriteString(pair.Value);
                        writer.WriteEndElement();
                    }
                    writer.WriteEndElement();
                    writer.WriteEndDocument();
                    return true;
                }
                catch { }
                finally
                {
                    if (writer != null)
                        writer.Close();
                }
    
                return false;
            }
    
            /// <summary>
            /// Ruft die angegebene Einstellung ab, oder
            /// legt sie fest.
            /// </summary>
            /// <param name="index">
            /// Die Einstellung
            /// </param>
            /// <returns>
            /// Den Wert der Einstellung oder null, falls nicht
            /// vorhanden.
            /// </returns>
            public String this[String index]
            {
                get
                {
                    return Get(index, null);
                }
                set
                {
                    Set(index, value);
                }
            }
    
            /// <summary>
            /// Weißt die angebenen Einstellung den angebenen
            /// Wert zu.
            /// </summary>
            /// <param name="index">
            /// Die Einstellung
            /// </param>
            /// <param name="value">
            /// Der Wert
            /// </param>
            /// <remarks>
            /// Wenn der Wert null ist, wird die Einstellung
            /// aus dem Speicher gelöscht.
            /// </remarks>
            public static void Set(String index, String value)
            {
                if (data.ContainsKey(index))
                    if (value == null)
                        data.Remove(value);
                    else
                        data[index] = value;
                else
                    if (value != null)
                        data.Add(index, value);
            }
    
            /// <summary>
            /// Gibt die enthaltenden Daten, der angegebenen
            /// Einstellung zurück.
            /// </summary>
            /// <param name="index">
            /// Der Einstellungsname
            /// </param>
            /// <returns>
            /// Den jeweiligen Wert, oder null, wenn nicht
            /// gefunden
            /// </returns>
            public static String Get(String index)
            {
                return Get(index, null);
            }
    
            /// <summary>
            /// Gibt die enthaltenden Daten, der angegebenen
            /// Einstellung zurück, oder den angegebenen Wert,
            /// wenn die Einstellung nicht gefunden wurde.
            /// </summary>
            /// <param name="index">
            /// Den Eintellungsnamen
            /// </param>
            /// <param name="default">
            /// Den Rückgabewert, wenn der Einstellungsname nicht
            /// gefunden wurde.
            /// </param>
            /// <returns>
            /// Den jeweiligen Wert, oder null, wenn nicht
            /// gefunden
            /// </returns>
            public static String Get(String index, String @default)
            {
                if (!data.ContainsKey(index))
                    return @default;
                return data[index];
            }
        }
    }
    // Der Kommentartext ist leider nicht das beste Deutsch
    

    Kramny schrieb:

    Ich bin mir nur nicht sicher wie ich das am Besten bewerkstelligen soll.

    Nimm XMLDocument (ist aber etwas langsam)

    Kramny schrieb:

    Die Frage ist nun, wie ich am einfachsten auf die einzelnen Konten zugreifen kann. In meiner Beispielanwendung ist eine Klasse, die sich um den GPS-Empfang kümmert, diese soll im Konstruktoraufruf die Daten, die unter dem Knoten "GPS-Modul" stehen einlesen. Eine Andere Klasse ist z.B. "MeassureMethod1". diese soll ebenfalls bei der Instanzerstellung die Daen vom Knoten "MeassureMethod1" einlesen.

    public class SomeClass
    {
    
       private int baudrate;
       private string port;
    
       public SomeClass() // So geht ein Konstruktor
       {
    
          XmlDocument doc = new XmlDocument();
          doc.Load(@"..."); // Den Pfad kenn ich nicht
    
          // doc.SelectSingleNode()... gibt einen (in dem Fall keinen ) Knoten zurück
          // ...   .InnerText    gibt den Testinhalt zurück
          // System.ConvertTo%X% Konvertiert den Quelltyp zum Zieltyp %X% (funktioniert nicht mit allen
    
          port = doc.SelectSingleNode("//Settings/GPS-Modul/Port").InnerText;
          baudrate = System.ConvertToInt(doc.SelectSingleNode("//Settings/GPS-Modul/Baudrate").InnerText);
    
          /*    [...]    */
       }
    


  • Danke für die Antwort - sie klingt vielversprechend. Leider komme ich heute nicht mehr dazu es auszutesten.

    public SomeClass() // So geht ein Konstruktor

    Du hast vollkommen recht - das habe ich wohl in der Eile übersehen ;-).

    Gruß
    Kramny



  • So, jetzt habe ich es getestet - es funktioniert wunderbar!

    Vielen Dank nochmal


Anmelden zum Antworten