14.4 Die Klasse »XmlReader«

14.4.1 XML-Dokumente mit einem »XmlReader«-Objekt lesen

Das .NET Framework bietet mehrere Möglichkeiten, die von einem XML-Dokument beschriebenen Daten zu lesen. In diesem Abschnitt wollen wir uns mit der einfachsten Variante beschäftigen, nämlich dem Einlesen über ein XmlReader-Objekt.

Ein Objekt vom Typ XmlReader liest die Elemente eines XML-Dokuments einzeln und der Reihe nach einmal ein. Die gelesenen Daten sind schreibgeschützt und bleiben nicht im Arbeitsspeicher. Das mag ein Nachteil sein, hat aber auch zur Folge, dass die Speicherressourcen geschont werden und der Lesevorgang schnell ist. Damit bietet sich die Klasse XmlReader besonders an, wenn es ausreicht, ein XML-Dokument nur sequenziell zu lesen und nicht innerhalb des Dokuments nach bestimmten Daten zu suchen. Die Klasse ist abstract definiert und kann demnach nicht instanziiert werden. Allerdings bietet die Klasse mit der statischen Methode Create die Möglichkeit, sich eine Instanz zu besorgen.

XmlReader reader = XmlReader.Create(@"MeineDaten.xml");

Beachten Sie bitte, dass Sie den Namespace System.Xml mit using bekannt geben sollten.

Nachdem Sie das XmlReader-Objekt erzeugt haben, rufen Sie in einer Schleife die Methode Read auf, die alle Knoten im XML-Dokument nacheinander abruft. Der Rückgabewert der Methode ist true, wenn noch mindestens ein weiterer Knoten eingelesen werden kann.

while(reader.Read())
{
  [...]
}

In der Schleife muss zuerst untersucht werden, welcher Knoten aktuell gelesen wird. Hier interessieren vorrangig Typ und Name des Knotens. Den Typ des Knotens rufen Sie mit der Eigenschaft NodeType ab, die durch einen Wert der Enumeration XmlNodeType beschrieben wird. Tabelle 14.2 beschreibt einen Auszug aus dieser Enumeration.

Die Struktur einer Schleife könnte also wie folgt codiert sein:

while (reader.Read()) {
  switch (reader.NodeType) {
    case XmlNodeType.XmlDeclaration:
      [...]
      break;
    case XmlNodeType.CDATA:
      [...]
      break;
    [...]
  }
}

Die Untersuchung des Knotentyps hat eine besondere Bedeutung hinsichtlich der Auswertung, denn je nach Typ möchten Sie entweder den Knotenbezeichner oder den von einem Knoten beschriebenen Inhalt auswerten. Dazu dienen die beiden Eigenschaften Name und Value des XmlReader-Objekts.

Mit Value rufen Sie den Inhalt des aktuellen Knotens ab. Von den in Tabelle 14.2 angeführten Knotentypen können nur Attribute, CDATA, Comment, ProcessingInstruction, Text, Whitespace und XmlDeclaration einen Wert zurückgeben. Alle anderen Knoten liefern String.Empty.

Die Eigenschaft Name hingegen liefert den Bezeichner des aktuellen Knotens. Auch diese Eigenschaft ist auf bestimmte Knotentypen beschränkt. Dazu gehören Attribute, Element, EndElement, ProcessingInstruction und XmlDeclaration.

Die Attribute eines Elements auswerten

Eine »spezielle« Behandlung erfahren die Attribute eines Knotens vom Typ XmlNodeType.Element. Eigentlich würde man erwarten, dass ein Attribut als Knoten erkannt wird und das XmlReader-Objekt sich bei jedem Aufruf von Read auch von Attribut zu Attribut hangelt. Tatsächlich aber liest der XmlReader ein XmlNodeType.Element samt seinen Attributen komplett ein, so dass die Attribute beim nächsten Aufruf der Read-Methode nicht mehr im Datenstrom enthalten sind. Sie haben dann zwar den Inhalt des Elements ausgewertet, aber die Attribute unberücksichtigt gelassen.

Ist nicht exakt bekannt, ob und wie viele Attribute ein Element hat, hilft Ihnen die Eigenschaft HasAttributes des XmlReader-Objekts weiter, die true oder false zurückliefert. Diese Eigenschaft wird aufgerufen, wenn es sich bei dem aktuellen Knoten um den Typ XmlNodeType.Element handelt. Mit der Eigenschaft AttributeCount lässt sich die Anzahl der Attribute in Erfahrung bringen. Den zurückgelieferten Wert können Sie in einer for-Schleife verwenden. Die Methode GetAttribute unter Angabe entweder des Index oder des Attributbezeichners liefert den Wert des Attributs.

[...]
case XmlNodeType.Element:
  if (reader.HasAttributes) {
    for (int i = 0; i < reader.AttributeCount; i++) {
      Console.WriteLine(reader.GetAttribute(i));
    }
  }
  break;
[...]

Listing 14.24 Struktur der Auswertung einer Liste von Attributen (1)

Alternativ können Sie auch mit der Methode MoveToNextAttribute durch die Liste der Attribute navigieren. Ähnlich der Read-Methode des XmlReader-Objekts liefert auch diese Methode true zurück, falls das Element noch ein weiteres Attribut enthält.

[...]
case XmlNodeType.Element:
  if (reader.HasAttributes) {
    while (reader.MoveToNextAttribute()) {
      [...]
    }
  }
  break;
[...]

Listing 14.25 Struktur der Auswertung einer Liste von Attributen (2)

Beispielprogramm

Wir wollen uns nun die bisherigen Erkenntnisse in einem kompletten Beispielprogramm ansehen. Dazu bedarf es einer XML-Datei. Um nicht nur die XML-Datei, sondern auch deren Analyse und Ausgabe nicht zu aufwendig zu gestalten, wird mit dem Dokument nur eine Person mit den wichtigsten Eckdaten beschrieben.

<?xml version="1.0" encoding="utf-8" ?>
<!-- Liste von Personen-->
<Personen>
  <Person>
    <Befehl><![CDATA[Ich stehe unter CDATA]]></Befehl>
    <Vorname>Manfred</Vorname>
    <Telefon/>
    <Zuname>Fischer</Zuname>
    <Alter>45</Alter>
    <Adresse Ort="Bonn" Strasse="Neuestr.34"></Adresse>
  </Person>
</Personen>

Listing 14.26 XML-Dokument für das Beispielprogramm »XmlReaderSample«

Auf eine genaue Erklärung des folgenden Programmbeispiels werde ich an dieser Stelle verzichten. Es enthält ausschließlich Passagen, die bereits zuvor erläutert worden sind. Sie sollten den Code jedoch einmal mit der Konsolenausgabe, die Sie in Abbildung 14.5 sehen, vergleichen.

// Beispiel: ..\Kapitel 14\XmlReaderSample
static void Main(string[] args) {
  XmlReader reader = XmlReader.Create(@"..\..\Personen.xml");
  while (reader.Read()) {
    switch (reader.NodeType) {
     case XmlNodeType.XmlDeclaration:
       Console.WriteLine("{0,-20}<{1}>", "DEKLARATION", reader.Value);
       break;
     case XmlNodeType.CDATA:
       Console.WriteLine("{0,-20}{1}", "CDATA", reader.Value);
       break;
     case XmlNodeType.Whitespace:
       Console.WriteLine("{0,-20}","WHITESPACE");
       break;
     case XmlNodeType.Comment:
       Console.WriteLine("{0,-20}<!--{1}-->","COMMENT", reader.Value);
       break;
     case XmlNodeType.Element:
       if (reader.IsEmptyElement)
         Console.WriteLine("{0,-20}<{1} />","EMPTY_ELEMENT", reader.Name);
       else {
         Console.WriteLine("{0,-20}<{1}>", "ELEMENT", reader.Name);
         // Prüfen, ob der Knoten Attribute hat
         if (reader.HasAttributes) {
           // Durch die Attribute navigieren
           while (reader.MoveToNextAttribute()) {
             Console.WriteLine("{0,-20}{1}", 
                    "ATTRIBUT", reader.Name + "=" + reader.Value);
           }
         }
       }
       break;
     case XmlNodeType.EndElement:
       Console.WriteLine("{0,-20}</{1}>", "END_ELEMENT", reader.Name);
       break;
     case XmlNodeType.Text:
       Console.WriteLine("{0,-20}{1}", "TEXT", reader.Value);
       break;
    }
  }
  Console.ReadLine();
}

Listing 14.27 Das Beispielprogramm »XmlReaderSample«

Abbildung 14.5 Ausgabe des Beispielprogramms »XmlReaderSample«

Die Daten eines XML-Dokuments verarbeiten

Das folgende Beispiel zeigt, wie die Daten eines XML-Dokuments dazu benutzt werden können, Objekte zu erstellen, die die gelesenen Daten in einem sinnvollen Kontext speichern. Ausgangspunkt sei wieder eine XML-Datei, die in diesem Fall aber nicht nur eine, sondern mehrere Personen beschreibt. Eine Person sei durch Vorname, Zuname, Alter sowie eine Adresse beschrieben.

<Person>
  <Vorname>Manfred</Vorname>
  <Zuname>Fischer</Zuname>
  <Alter>45</Alter>
  <Adresse Ort="Bonn" Strasse="Neuestr.34"></Adresse>
</Person>

Listing 14.28 XML-Struktur einer »Person« für das nächste Beispielprogramm

Die Daten zu einer Person sollen in einem Objekt vom Typ Person gespeichert werden. Für die Angaben der Adresse einer Person steht eine weitere Klasse Adresse zur Verfügung, die mit Ort und Strasse zwei Eigenschaften hat.

// Beispiel: ..\Kapitel 14\UsingXmlData
static void Main(string[] args) {
  XmlReader reader;
  reader = XmlReader.Create(@"..\..\Personen.xml");
  List<Person> liste = new List<Person>();
  Person person = null;
  Adresse adresse = null;
  while (reader.Read()) {
    // Prüfen, ob es sich aktuell um ein Element handelt
    if (reader.NodeType == XmlNodeType.Element) {
      // Alle relevanten Elemente untersuchen
      switch(reader.Name) {
        case "Person":
          // Neue Person erzeugen und in Liste eintragen
          person = new Person();
          liste.Add(person);
          break;
        case "Vorname":
          person.Vorname = reader.ReadString();
          break;
        case "Zuname":
          person.Zuname = reader.ReadString();
          break;
        case "Alter":
          person.Alter = reader.ReadElementContentAsInt(); 
          break;
        case "Adresse":
          // Neue Adresse erzeugen und der Person zuordnen
          adresse = new Adresse();
          person.Adresse = adresse;
          if (reader.HasAttributes) {
            // Attributsliste durchlaufen
            while (reader.MoveToNextAttribute())
            {
              if (reader.Name == "Ort")
                adresse.Ort = reader.Value;
              else if (reader.Name == "Strasse")
                adresse.Strasse = reader.Value;
            }
          }
          break;
      }
    }
  }
  // Liste an der Konsole ausgeben
  GetList(liste);
  reader.Close();
  Console.ReadLine();
}
// Ausgabe der Listeneinträge
static void GetList(List<Person> liste) {
  foreach (Person temp in liste)
  {
    Console.WriteLine("Vorname: {0}\nZuname: {1}\nAlter: {2}",
            temp.Vorname, temp.Zuname, temp.Alter);
    Console.WriteLine("Ort: {0}\nStrasse: {1}\n", 
            temp.Adresse.Ort, temp.Adresse.Strasse);
  }
}

Listing 14.29 Das Beispielprogramm »UsingXmlData«

In der while-Schleife interessieren im Zusammenhang mit der Aufgabenstellung nur die Elemente, die Daten beschreiben. Trifft der Reader auf einen Knoten vom Typ XmlNodeType.Element, wird mit einer switch-Anweisung der Elementbezeichner ausgewertet. In den case-Zweigen wird der beschriebene Wert des Elements ermittelt und der entsprechenden Eigenschaft eines Person-Objekts zugewiesen, das bei Erreichen des Elements Person erzeugt und einer generischen Liste hinzugefügt wird. Trifft die Laufzeit auf das Element Adresse, wird ein Objekt der gleichnamigen Klasse erzeugt und die Liste der Attribute des Elements ausgewertet.

14.4.2 Validieren eines XML-Dokuments

Die XML-Dokumente in den beiden zuvor gezeigten Beispielprogrammen sind wohlgeformt. Sie erkennen das daran, dass die gesamte Datei eingelesen wird, ohne dass es zu einer Ausnahme vom Typ XmlException kommt. Das bedeutet aber noch nicht, dass das Dokument valide, also gültig ist. Wie Sie wissen, bedarf es dazu einer XML-Schemadatei. Mit dem Tool xsd.exe oder Visual Studio ist eine solche sehr einfach zu erzeugen.

Um ein XML-Dokument, das mit einem XmlReader-Objekt sequenziell eingelesen wird, zu validieren, müssen wir auf eine Überladung der Methode Create der Klasse XmlReader zurückgreifen, die in einem zweiten Parameter nach einem Objekt vom Typ XmlReaderSettings verlangt.

public static XmlReader Create(string, XmlReaderSettings)

Ein XmlReaderSettings-Objekt dient nicht nur dazu, die Validierung vorzuschreiben. Es kann darüber hinaus das XmlReader-Objekt mit spezifischen Eigenschaften ausstatten. Beispielsweise könnte das XmlReaderSettings-Objekt das Einlesen der Kommentare oder die Berücksichtigung der Whitespaces unterbinden.

Doch widmen wir uns hier der Validierung. Zunächst müssen wir die Klasse XmlReaderSettings instanziieren und anschließend die Eigenschaft ValidationType einstellen. Wollen wir das Dokument gegen ein XML-Schema validieren, müssen wir ValidationType.Schema angeben, z. B.:

XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.ValidationType = ValidationType.Schema;

Im nächsten Schritt ist das XML-Schema zu benennen. Da es sich auch um mehrere handeln könnte, kommt eine Auflistung ins Spiel, der alle XML-Schemata hinzugefügt werden. Die Referenz auf diese Auflistung erhalten wir über die Eigenschaft Schemas des XmlReaderSettings-Objekts. Darauf rufen wir die Methode Add auf, die im ersten Parameter den im Schema angegebenen targetNamespace erwartet. Enthält das XML-Schema kein Attribut targetNamespace oder legen Sie auf den Namespace der im XML-Schema beschriebenen Elemente keinen Wert, können Sie dem ersten Parameter auch null übergeben. Dem zweiten Parameter teilen Sie den URI der XML-Schemadatei mit.

readerSettings.Schemas.Add(null, @"..\..\Personen.xsd");

Sollte bei der Validierung des XML-Dokuments ein Fehler auftreten, wird das XmlReaderSettings-Objekt das Ereignis ValidationEventHandler auslösen. Wir müssen bei dem Objekt jetzt nur noch einen passenden Ereignishandler registrieren.

readerSettings.ValidationEventHandler += ValidationCallback;

Scheitert die Validierung, wird die Überprüfung des XML-Dokuments abgebrochen. Der Rest des Dokuments wird zwar weiterhin eingelesen, bleibt aber ungeprüft, und folgende Validierungsfehler werden nicht mehr erkannt. Besser ist es, im Fall des Scheiterns der Validierung eine Ausnahme auszulösen. Dies ermöglicht uns der Parameter vom Typ ValidationEventArgs des Ereignishandlers, der drei spezifische Eigenschaften hat, die Sie der Tabelle 14.3 entnehmen können.

Bitte beachten Sie, dass die Klasse ValidationEventArgs im Namespace System.Xml.Schema enthalten ist, der über using bekannt gegeben werden sollte.

Nachdem nun alle vorbereitenden Maßnahmen ergriffen worden sind, müssen wir zum Schluss noch dem XmlReader-Objekt das konfigurierte XmlReaderSettings-Objekt übergeben.

XmlReader reader = XmlReader.Create(@"..\..\Personen.xml", readerSettings);

Beispielprogramm zur Validierung

Die XML-Datei aus dem Beispiel XmlReaderSample soll nun anhand eines XML-Schemas validiert werden. Tritt ein Validierungsfehler auf, soll eine Ausnahme ausgelöst werden, die wir dem zweiten Parameter des Ereignishandlers entnehmen.

Darüber hinaus interessieren uns in der Ausgabe weder die Kommentare noch die Whitespaces. Diese werden durch die Einstellungen IgnoreWhitespace und IgnoreComments des XmlReaderSettings-Objekts ignoriert.

// Beispiel: ..\Kapitel 14\ValidationSample
static void Main(string[] args) {
  XmlReaderSettings readerSettings = new XmlReaderSettings();
  readerSettings.IgnoreWhitespace = true;
  readerSettings.IgnoreComments = true;
  readerSettings.ValidationType = ValidationType.Schema;
  readerSettings.Schemas.Add(null, @"..\..\Personen.xsd");
  readerSettings.ValidationEventHandler += ValidationCallback;
  XmlReader reader = XmlReader.Create(@"..\..\Personen.xml", readerSettings);
  try {
    while (reader.Read()) {
      // Code wie im Beispielprogramm "XmlReaderSample"
    }
  }
  catch(Exception ex) {
    Console.WriteLine("Validierung fehlgeschlagen. \n{0}", ex.Message);
  }
  reader.Close();
  Console.ReadLine();
}
// Ereignishandler
static void ValidationCallback(object sender, ValidationEventArgs e)
{
  throw e.Exception;
}

Listing 14.30 Beispielprogramm zur Validierung von XML

Die XSD-Datei zu diesem Beispielprogramm liegt im Verzeichnis der Sourcecode-Dateien. Die Validierung wird zunächst ergeben, dass das XML-Dokument wohlgeformt und gültig ist. Sie können, um eine fehlgeschlagene Validierung zu simulieren, in der XML-Schemadatei beispielsweise das Element Befehl in Befehl1 ändern.

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.