XML schreiben mit dem Document Object Model

Im Artikel “XML-Dokumente erstellen mit XmlWriter” haben wir beschrieben, wie Sie XML-Dokumente mit der XmlWriter-Klasse schreiben. Dort können Elemente nur sequenziell hinzugefügt werden. Die Methoden des Object Document Models erlauben eine wesentlich flexiblere Vorgehensweise. Dieser Artikel zeigt, wie Sie mit dem Document Object Model neue XML-Dokumente erstellen und Elemente der verschiedenen Typen hinzufügen und mit Daten füllen.

Beispieldaten

Die Beispiele aus dem ersten Teil des Artikels finden Sie im Beispielprojekt XmlBeispiele aus dem Download.

Erstellen eines neuen XML-Dokuments

Im Artikel XML lesen mit dem Document Object Model (www.datenbankentwickler.net/****) haben Sie neue XML-Dokument-Objekte erstellt und diese mit Load oder LoadXml befüllt. Nun wollen wir ein neues, leeres XML-Dokument erstellen und dieses speichern. Die Mindestanforderung ist dabei, dass das Dokument ein Stammelement enthält. Um das mit VB zu realisieren, benötigen wir wie in den vorherigen Artikeln einen Verweis auf den Namespace System.Xml:

Imports System.Xml

Danach können wir mit der folgenden Methode ein neues XmlDocument erstellen. Bevor wir dieses speichern können, fügen wir das Stammelement in zwei Schritten hinzu:

• Erstellen eines neuen Elements des Typs XmlElement mit der CreateElement-Methode des XmlDocument-Objekts und
• Hinzufügen dieses Elements mit der AppendChild-Methode an das XML-Dokument aus objXml.

Danach können wir das Dokument mit Save und dem gewünschten Dateipfad speichern:

Private Sub btnDokumentErstellenDOM_Click(sender As Object, e As RoutedEventArgs)
     Dim objXml As XmlDocument
     Dim objElement As XmlElement
     Dim strDocument As String
     strDocument = "C:\...\BestellverwaltungDOM.xml"
     objXml = New XmlDocument
     objElement = objXml.CreateElement("Bestellverwaltung")
     objXml.AppendChild(objElement)
     objXml.Save(strDocument)
End Sub

Das Dokument enthält nun schlicht folgenden Text:

<Bestellverwaltung />

Prolog hinzufügen

Für manche Anwendungen ist es wichtig, dass die XML-Datei einen Prolog enthält, also folgende Zeile:

<xml version="1.0" encoding="utf-8">

Diese nennt man auch Processing Instruction. Und genau so ein Objekt gibt es auch im Namespace System.Xml. Um dieses zu erstellen, deklarieren wir eine Variable des Typs XmlProcessingInstruction sowie eine für den Inhalt dieses Objekts:

Dim objPI As XmlProcessingInstruction
Dim strPI As String

Dann schreiben wir den Text in strPI und erstellen mit der Methode CreateProcessingInstruction das XmlProcessingInstruction-Element. Der erste Parameter ist der Name, der hinter < erscheinen soll, also xml, der zweite die Angabe der gewünschten Name-Wert-Paare. Danach hängen wir das Element wie herkömmliche Elemente mit der AppendChild-Methode an das Dokument an und speichern es anschließend:

strPI = "version=""1.0"" encoding=""utf-8"""
objPI = objXml.CreateProcessingInstruction("xml", strPI)
objXml.AppendChild(objPI)
...
objXml.Save(strDocument)

Das Ergebnis lautet, kombiniert mit den Anweisungen des ersten Beispiele, wie folgt:

<xml version="1.0" encoding="utf-8">
<Bestellverwaltung />

Da wir eine solche Processing Instruction allen XML-Dokumenten voranstellen, gliedern wir die notwendigen Anweisungen in eine eigene Methode aus, die wie folgt aussieht:

Public Sub AddProcessingInstruction(ByVal objXml As XmlDocument)
     Dim objPI As XmlProcessingInstruction
     Dim strPI As String
     strPI = "version=""1.0"" encoding=""utf-8"""
     objPI = objXml.CreateProcessingInstruction("xml", strPI)
     objXml.AppendChild(objPI)
End Sub

Den Aufruf können wir dann so in die eigentliche Methode zum Erstellen des XML-Dokuments einstreuen:

AddProcessingInstruction(objXml)

Unterelemente hinzufügen

Unser XML-Dokument besteht nun gerade mal aus der Processing Instruction und dem Stammelement Bestellverwaltung. Weitere Elemente müssen wir zwingend dem Stammelement unterordnen. Dieses haben wir aber bereits mit objElement referenziert, sodass wir eigentlich direkt loslegen können. Allerdings machen wir uns direkt an dieser Stelle Gedanken über die Benennung der XmlElement-Variablen, denn wir werden ja vielleicht noch weitere verschachtelte Elemente wie Kunden, Bestellungen und Bestellpositionen einfügen wollen und wir benötigen für alle zumindest eine Objektvariable je Typ. Also ändern wir den Namen der Objektvariablen für das Stammelement in objBestellverwaltung. Die folgenden Elemente wollen wir dann objKunden, objKunde, objBestellungen, objBestellung und so weiter nennen. Als Erstes wollen wir nur das Unterelement Kunden hinzufügen. Dazu legen wir die Variable objKunden mit dem Typ XmlElement an.

Dieser weisen wir dann das mit der CreateElement von objXml erstellte Objekt mit dem Namen Kunden zu. Allerdings hängen wir das Kunden-Element nicht an das XML-Dokument aus objXml an, sondern an das Element aus objBestellverwaltung:

Private Sub btnDokumentErstellenDOM_Unterelemente_Click(sender As Object, e As RoutedEventArgs)
     ...
     Dim objKunden As XmlElement
     ...
     objBestellverwaltung = objXml.CreateElement("Bestellverwaltung")
     objXml.AppendChild(objBestellverwaltung)
     objKunden = objXml.CreateElement("Kunden")
     objBestellverwaltung.AppendChild(objKunden)
     objXml.Save(strDocument)
End Sub

Das Ergebnis sieht dann genau wie gewünscht aus:

<xml version="1.0" encoding="utf-8">
<Bestellverwaltung>
   <Kunden />
</Bestellverwaltung>

Elemente mit Werten hinzufügen

Nun nähern wir uns den Elementen, die selbst Werte enthalten, also zum Beispiel das folgende:

   <Kunden>
     <Kunde>
       <Firma>André Minhorst Verlag</Firma>
     </Kunde>
   </Kunden>

Texte wie hier innerhalb des Elements Firma sind Elemente des Typs XmlText. Neben den übrigen neu hinzugekommenen Elementen deklarieren wir dieses entsprechend. Danach legen wir unterhalb des Elements aus objKunden weitere neue Elemente namens objKunde und objFirma an, beide des Typs XmlElement. Schließlich erstellen wir ein neues Element des Typs XmlText und weisen diesem mit dem Parameter text den gewünschten Inhalt zu. Dieses Objekt hängen wir an objFirma an:

Dim objKunde As XmlElement
Dim objFirma As XmlElement
Dim objText As XmlText
...
objKunde = objXml.CreateElement("Kunde")
objKunden.AppendChild(objKunde)
objFirma = objXml.CreateElement("Firma")
objKunde.AppendChild(objFirma)
objText = objXml.CreateTextNode("André Minhorst Verlag")
objFirma.AppendChild(objText)
objXml.Save(strDocument)

Damit hätten wir die Werkzeuge zum Zusammenstellen der Grundstruktur vollständig und können uns anderen Elementen zuwenden.

Attribute hinzufügen

Die Elemente Kunde, Bestellung und Bestellposition sollen jeweils um ein Attribut namens ID ergänzt werden:

<Kunde ID="123">

Dazu deklarieren wir eine Variable des Typs XmlAttribute:

Dim objID As XmlAttribute

Nach dem Erstellen des Elements, das wir mit dem Attribut ausstatten wollen, erzeugen wir das XmlAttribute-Objekt. Dann weisen wir diesem über das Attribut Value den gewünschten Wert zu und hängen das Attribut über die Methode Append der Auflistung Attributes an das XmlElement-Objekt an. Schließlich fügen wir das XmlElement-Objekt zum übergeordneten Objekt zu:

objKunde = objXml.CreateElement("Kunde")
objID = objXml.CreateAttribute("ID")
objID.Value = "123"
objKunde.Attributes.Append(objID)
objKunden.AppendChild(objKunde)

Sie können das Attribut allerdings auch erst nach dem Anhängen des XmlElement-Objekts an das übergeordnete Element hinzufügen.

CDATA-Block hinzufügen

Mit der Methode CreateCDataSection erstellen Sie ein Element mit einem CDATA-Block. Den Inhalt des CDATA-Blocks übergeben Sie als Parameter der Methode CreateCDataSection. Heraus kommt ein Objekt des Typs XmlCDataSection, das Sie wie gewohnt mit der AppendChild-Methode an das übergeordnete Element anfügen:

Dim objCData As XmlCDataSection
...
objCData = objXml.CreateCDataSection("Dies ist ein CDATA-Block mit Sonderzeichen wie <>&.")
objBestellverwaltung.AppendChild(objCData)

Username or Email

Passwort

Angemeldet bleiben