XML richtig einlesen ?!

  • C#
  • .NET (FX) 4.5–4.8

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von TRiViUM.

    XML richtig einlesen ?!

    Hallo liebe Community,ich möchte eine XML-Datei einlesen, die folgenden Inhalt hat:
    Spoiler anzeigen

    HTML-Quellcode

    1. <?xml version="1.0" encoding="utf-8"?>
    2. <Messages>
    3. <Message ID="1">
    4. <Text>
    5. <DE>ABC</DE>
    6. <EN>ABC</EN>
    7. </Text>
    8. <ResetMode>0</ResetMode>
    9. <Action>0</Action>
    10. </Message>
    11. <Message ID="2">
    12. <Text>
    13. <DE>ABC</DE>
    14. <EN>ABC</EN>
    15. </Text>
    16. <ResetMode>0</ResetMode>
    17. <Action>0</Action>
    18. </Message>
    19. <Message ID="3">
    20. <Text>
    21. <DE>ABC</DE>
    22. <EN>ABC</EN>
    23. </Text>
    24. <ResetMode>0</ResetMode>
    25. <Action>0</Action>
    26. </Message>
    27. </Messages>


    Um nach dem Einlesen einfacher auf den Inhalt zugreifen zu können habe ich dazu erstmal eine Klasse Message erstellt, welche folgende Eigenschaften besitzt:
    Spoiler anzeigen

    C#-Quellcode

    1. /// <summary>
    2. /// Ruft die ID ab, die der Meldung zugeordnet ist, oder legt diese fest.
    3. /// </summary>
    4. public string ID { get; set; }
    6. /// <summary>
    7. /// Ruft das Wörterbuch mit den anzuzeigenden Texten in unterschiedlichen Sprachen ab, oder legt dieses fest.
    8. /// </summary>
    9. public Dictionary<string, string> Text;
    11. /// <summary>
    12. /// Ruft ab, wie diese Meldung zu behandeln ist, oder legt dies fest.
    13. /// </summary>
    14. public int Action { get; set; }
    16. /// <summary>
    17. /// Ruft die Betriebsart ab, in der die Meldung zurückgesetzt werden kann, oder legt dies fest.
    18. /// Dies hat nur Auswirkungen auf Meldungen, dessen Action das Flag SysStop besitzt.
    19. /// </summary>
    20. public int ResetMode { get; set; }


    Diese Klasse soll quasi einen Knotenpunkt Message repräsentieren.

    Die Elemente, die im XML-Dokument so zu sagen unter dem XML-Pfad Messages/Message/Text auftauchen (aktuell DE, EN) sind beliebig erweiterbar.
    Hier sollen Übersetzungstexte rein, weshalb die vorhandenen Sprachen eigentlich unbekannt sind und somit iteriert werden sollen.
    Die gefundenen Sprachen sollen dann im zuvor instanzierten Message-Object der Dictionary hinzugefügt werden.

    Leider bekomme ich es einfach nicht auf die Reihe, alle Infos sauber auszulesen, ohne dass ich versehentlich einen Knoten überspringe.
    Aktuell nutze ich den XmlReader zum Auslesen, da dieser schneller sein soll als andere Objekte und das XML-Dokument etwas größer werden kann (z.B. 500 Message-Einträge).

    Hier mein aktueller Versuch:
    Spoiler anzeigen

    C#-Quellcode

    1. internal List<Message> ReadMessages(string path = "D:\\Test.xml")
    2. {
    3. var messageList = new List<Message>();
    5. using (var reader = XmlReader.Create( path))
    6. {
    7. try
    8. {
    9. // Haupt-Knoten für Meldungen öffnen
    10. reader.ReadStartElement("Messages");
    12. while (reader.Read())
    13. {
    14. // Meldungs-Knoten einlesen
    15. if ( reader.Name != "Message" && reader.NodeType != XmlNodeType.Element) continue;
    17. // Meldungs-ID einlesen
    18. var msgid = reader.GetAttribute("ID");
    20. // Meldungstexte einlesen
    22. reader.ReadStartElement("Text");
    24. var nodeType = reader.NodeType;
    25. //using (var innerReader = reader.ReadSubtree())
    26. //{
    27. // while (innerReader.Read())
    28. // {
    29. // var abc = reader.Name;
    30. // var value = reader.ReadElementContentAsString();
    31. // }
    32. //}
    35. }
    36. }
    37. catch (Exception ex) { throw ex; }
    39. }
    41. return messageList;
    42. }


    Sobald ich das Element Text einlesen möchte, fliegt er mit einer Exception raus, weil das Element Text nicht gefunden wurde.

    Wie kann ich das bewerkstelligen?

    BTW:
    Die XML-Struktur habe ich mir selber "ausgedacht" und kann natürlich geändert werden, sofern mein Vorhaben mit der aktuellen Struktur gar nicht Sinnvoll wäre...

    Vielen Dank für Eure Unterstützung! :saint:

    @TRiViUM Warum willst Du das Multi-Language-Konzept von Microsoft neu erfinden?
    Warum nicht so:
    Programme mehrsprachig erstellen
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    RodFromGermany schrieb:

    Warum willst Du das Multi-Language-Konzept von Microsoft neu erfinden?

    Nee, das habe ich gar nicht vor.

    Meine Software soll eine XML-Datei einlesen, in der Meldungen hinterlegt sind, die das Programm anzeigen kann.
    Zu jeder Meldung gibts ja noch weitere Eigenschaften, die das Verhalten meiner Software bei bestimmten Meldungen beeinflussen sollen.

    Das mit der Sprache habe ich dort mit aufgenommen, weil ich hier das erste mal mit mehreren Sprachen in meiner Software arbeite.
    Aber eigentlich geht's mir mittlerweile eher ums Prinzip, wie man sowas in der Praxis einlesen würde.

    Ob ich das mit der Sprache so lasse sei mal dahin gestellt, aber ich möchte mich mehr mit XML befassen ^^

    TRiViUM schrieb:

    Meine Software soll eine XML-Datei einlesen, in der Meldungen hinterlegt sind, die das Programm anzeigen kann.
    Probiere es mal anders herum:
    Erstell Dir eine Datenklasse mit all Deinen Properties und serialisiere die per XML.
    Dann ist das Einlesen bereits erledigt.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    RodFromGermany schrieb:

    Erstell Dir eine Datenklasse mit all Deinen Properties und serialisiere die per XML

    Das habe ich bereits schon versucht.
    Allerdings gibt es bei Dictionary<string, string> eine Exception, weil dieses Objekt scheinbar nicht Serialisiert werden kann:

    C#-Quellcode

    1. Das Element Core.Message.Text vom Typ System.Collections.Generic.Dictionary`2[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] kann nicht serialisiert werden, da es IDictionary implementiert


    Was ich probiert habe:

    C#-Quellcode

    1. var msgList = new List<Core.Message>();
    2. for(int i = 0; i < 10; i++)
    3. {
    4. var msg = new Core.Message();
    5. msg.ID = i.ToString();
    6. msg.Action = 0;
    7. msg.Text.Add("DE", "Deutsch");
    8. msg.Text.Add("EN", "English");
    9. msgList.Add(msg);
    10. }
    12. string xml = "";
    13. var xs = new XmlSerializer(typeof(List<Core.Message>));
    14. using (var sw = new StringWriter())
    15. {
    16. using (XmlWriter writer = XmlWriter.Create(sw))
    17. {
    18. xs.Serialize(writer, msgList);
    19. xml = sw.ToString();
    20. }
    21. }

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „TRiViUM“ ()

    @TRiViUM Ich habe da ein SerializableDictionary gefunden: stackoverflow.com/questions/12…erializing-net-dictionary
    und meine Umsetzung (läuft):
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Runtime.Serialization;
    4. using System.Xml;
    5. using System.Xml.Serialization;
    7. namespace CrdApp.Settings
    8. {
    9. /// <summary>
    10. /// Klasse zur XML-Serialisierung eines Dictionaries
    11. /// </summary>
    12. /// <typeparam name="TKey"></typeparam>
    13. /// <typeparam name="TVal"></typeparam>
    14. [Serializable()]
    15. public class SerializableDictionary<TKey, TVal>
    16. : Dictionary<TKey, TVal>, IXmlSerializable, ISerializable
    17. {
    18. #region Constants
    20. private const string ItemNodeName = "Item";
    21. private const string KeyNodeName = "Key";
    22. private const string ValueNodeName = "Value";
    24. #endregion Constants
    26. #region Properties
    28. /// <summary>
    29. /// Kurze Beschreibung für das Dictionary,
    30. /// muss nach dem Lesen erneut gesetzt werden.
    31. /// </summary>
    32. public string Comment { get; set; }
    34. #endregion Properties
    36. #region Private Members
    38. private XmlSerializer keySerializer = null;
    39. private XmlSerializer valueSerializer = null;
    41. #endregion Private Members
    43. #region Constructors
    45. /// <summary>
    46. /// Standardkonstruktor der Klasse SerializableDictionary
    47. /// </summary>
    48. public SerializableDictionary()
    49. : base()
    50. {
    51. }
    53. /// <summary>
    54. /// Parameter-Konstruktor der Klasse SerializableDictionary
    55. /// </summary>
    56. public SerializableDictionary(IDictionary<TKey, TVal> dictionary)
    57. : base(dictionary)
    58. {
    59. }
    61. /// <summary>
    62. /// Parameter-Konstruktor der Klasse SerializableDictionary
    63. /// </summary>
    64. public SerializableDictionary(IEqualityComparer<TKey> comparer)
    65. : base(comparer)
    66. {
    67. }
    69. /// <summary>
    70. /// Parameter-Konstruktor der Klasse SerializableDictionary
    71. /// </summary>
    72. public SerializableDictionary(int capacity)
    73. : base(capacity)
    74. {
    75. }
    77. /// <summary>
    78. /// Parameter-Konstruktor der Klasse SerializableDictionary
    79. /// </summary>
    80. public SerializableDictionary(IDictionary<TKey, TVal> dictionary, IEqualityComparer<TKey> comparer)
    81. : base(dictionary, comparer)
    82. {
    83. }
    85. /// <summary>
    86. /// Parameter-Konstruktor der Klasse SerializableDictionary
    87. /// </summary>
    88. public SerializableDictionary(int capacity, IEqualityComparer<TKey> comparer)
    89. : base(capacity, comparer)
    90. {
    91. }
    93. /// <summary>
    94. /// Streaming-Konstruktor der Klasse SerializableDictionary
    95. /// </summary>
    96. protected SerializableDictionary(SerializationInfo info, StreamingContext context)
    97. {
    98. int itemCount = info.GetInt32("ItemCount");
    99. for (int i = 0; i < itemCount; i++)
    100. {
    101. KeyValuePair<TKey, TVal> kvp = (KeyValuePair<TKey, TVal>)info.GetValue($"Item{i}", typeof(KeyValuePair<TKey, TVal>));
    102. this.Add(kvp.Key, kvp.Value);
    103. }
    104. }
    106. #endregion Constructors
    108. #region ISerializable Members
    110. /// <summary>
    111. /// Füllt eine System.Runtime.Serialization.SerializationInfo mit den Daten,
    112. /// die zum Serialisieren des Zielobjekts erforderlich sind.
    113. /// </summary>
    114. /// <param name="info">
    115. /// Die mit Daten zu füllende System.Runtime.Serialization.SerializationInfo.
    116. /// </param>
    117. /// <param name="context">Das Ziel (siehe StreamingContext) dieser Serialisierung.</param>
    118. void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    119. {
    120. info.AddValue("ItemCount", this.Count);
    121. int itemIdx = 0;
    122. foreach (KeyValuePair<TKey, TVal> kvp in this)
    123. {
    124. info.AddValue($"Item{itemIdx}", kvp, typeof(KeyValuePair<TKey, TVal>));
    125. itemIdx++;
    126. }
    127. }
    129. #endregion ISerializable Members
    131. #region IXmlSerializable Members
    133. /// <summary>
    134. /// Konvertiert ein Objekt in seine XML-Darstellung.
    135. /// </summary>
    136. /// <param name="writer">
    137. /// Der System.Xml.XmlWriter-Stream, in den das Objekt serialisiert wird.
    138. /// </param>
    139. void IXmlSerializable.WriteXml(XmlWriter writer)
    140. {
    141. if (this.Count > 0 && !string.IsNullOrWhiteSpace(this.Comment))
    142. {
    143. // wenn das Dict leer ist, knallt es beim Einlesen!
    144. writer.WriteComment(this.Comment);
    145. }
    147. foreach (KeyValuePair<TKey, TVal> kvp in this)
    148. {
    149. writer.WriteStartElement(ItemNodeName);
    150. writer.WriteStartElement(KeyNodeName);
    151. this.KeySerializer.Serialize(writer, kvp.Key);
    152. writer.WriteEndElement();
    153. writer.WriteStartElement(ValueNodeName);
    154. this.ValueSerializer.Serialize(writer, kvp.Value);
    155. writer.WriteEndElement();
    156. writer.WriteEndElement();
    157. }
    158. }
    160. /// <summary>
    161. /// Generiert ein Objekt aus seiner XML-Darstellung.
    162. /// </summary>
    163. /// <param name="reader">
    164. /// Der System.Xml.XmlReader-Stream, aus dem das Objekt deserialisiert wird.
    165. /// </param>
    166. void IXmlSerializable.ReadXml(XmlReader reader)
    167. {
    168. if (reader.IsEmptyElement)
    169. {
    170. return;
    171. }
    173. // Move past container
    174. if (!reader.Read())
    175. {
    176. throw new XmlException("Error in Deserialization of Dictionary");
    177. }
    179. while (reader.NodeType != XmlNodeType.EndElement)
    180. {
    181. reader.ReadStartElement(ItemNodeName);
    182. reader.ReadStartElement(KeyNodeName);
    183. TKey key = (TKey)this.KeySerializer.Deserialize(reader);
    184. reader.ReadEndElement();
    185. reader.ReadStartElement(ValueNodeName);
    186. TVal value = (TVal)this.ValueSerializer.Deserialize(reader);
    187. reader.ReadEndElement();
    188. reader.ReadEndElement();
    189. this.Add(key, value);
    190. reader.MoveToContent();
    191. }
    193. // Read End Element to close Read of containing node
    194. reader.ReadEndElement();
    195. }
    197. /// <summary>
    198. /// Diese Methode ist reserviert und sollte nicht verwendet werden.
    199. /// </summary>
    200. /// <returns></returns>
    201. System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema()
    202. {
    203. return null;
    204. }
    206. #endregion IXmlSerializable Members
    208. #region Private Properties
    210. /// <summary>
    211. /// Serializer zum Einlesen eines Value-Elements
    212. /// </summary>
    213. private XmlSerializer ValueSerializer
    214. {
    215. get
    216. {
    217. if (this.valueSerializer == null)
    218. {
    219. this.valueSerializer = new XmlSerializer(typeof(TVal));
    220. }
    222. return this.valueSerializer;
    223. }
    224. }
    226. /// <summary>
    227. /// Serializer zum Einlesen eines Key-Elements
    228. /// </summary>
    229. private XmlSerializer KeySerializer
    230. {
    231. get
    232. {
    233. if (this.keySerializer == null)
    234. {
    235. this.keySerializer = new XmlSerializer(typeof(TKey));
    236. }
    238. return this.keySerializer;
    239. }
    240. }
    242. #endregion Private Properties
    243. }
    244. }

    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    TRiViUM schrieb:

    Warum benötigt man dennoch so eine erweiterte Klasse?
    Weil das Serialisierungs-Zeugs eben nur als Interface verfügbar ist, nicht aber als implementierter Code.
    Als ich das brauchte, bab ich gesucht und gefunden und genutzt.
    Tiefergehende Gedanken hab ich mir da wohl nicht gemacht.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Jo, werde ich jetzt vermutlich auch so machen.

    Aber noch mal kurz zurück zum "manuellen" Auslesen der XML-Datei:

    HTML-Quellcode

    1. <Message ID="1">
    2. <Text>
    3. <DE>Deutsch</DE>
    4. <EN>English</EN>
    5. </Text>
    6. <Action>0</Action>
    7. <ResetMode>0</ResetMode>
    8. </Message>


    Wie würde ich das Attribute ID auslesen, bis zum Knoten Text kommen und alle dort befindlichen "Elemente" auslesen können? (rein interessehalber)...

    Offenbar habe ich noch nicht ganz verstanden, wie die XmlReader.Read()-Funktion funktioniert bzw. was für dieses Objekt ein Knoten bedeutet und was nicht.

    Was ich suche ist quasi eine Erklärung, welche Funktionen der Klasse XmlReader den Cursor auf die Einzelnen Knotenpunkte setzen kann, die ich in meinem XML-Dokument habe.

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „TRiViUM“ ()

    TRiViUM schrieb:

    (rein interessehalber)
    Ich gehe immer den anderen Weg. ;)
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

Facebook
Telefonspende