{"id":55000233,"date":"2020-08-01T00:00:00","date_gmt":"2020-11-26T11:26:14","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=233"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"XMLDokumente_schnell_lesen_mit_XmlReader","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/XMLDokumente_schnell_lesen_mit_XmlReader\/","title":{"rendered":"XML-Dokumente schnell lesen mit XmlReader"},"content":{"rendered":"

Unter .NET gibt es verschiedene Methoden und Klassen, mit denen Sie auf die Daten in XML-Dokumenten zugreifen können. Diese nutzen Sie je nach Einsatzzweck. Wenn Sie sehr große Dateien einlesen wollen, bietet sich die XmlReader-Klasse an. Mit dieser durchlaufen Sie das XML-Dokument sequenziell, das heißt, Element für Element. Dieser Artikel zeigt, wie Sie mit den Methoden der XmlReader-Klasse auf die Elemente eines XML-Dokuments zugreifen. Außerdem schauen wir uns an, wie Sie die eingelesen Inhalte in Objekte schreiben können, über die Sie die Inhalte dann in die Tabellen einer Datenbank eintragen.<\/b><\/p>\n

Wer unter Access\/VBA auf XML-Dokumente zugegriffen hat, hat dazu in der Regel das Document Object Model verwendet und dabei die Elemente mit den gewünschten Daten gezielt angesteuert. Unter VBA gibt es noch eine weitere Technik namens SAX. Diese ist recht kompliziert und wird sehr selten verwendet. Dieser Technik kommt der hier verwendete XmlReader <\/b>jedoch recht nahe. Seine Handhabung ist allerdings einfacher als bei SAX.<\/p>\n

Dokument öffnen<\/b><\/p>\n

Um ein XML-Dokument zu öffnen, benötigen wir ein Objekt auf Basis der XMLReader<\/b>-Klasse. Diese ist Teil des Namespaces System.XML<\/b>, den wir mit der folgenden Anweisung etwa in der Code behind-Klasse eines Fensters einer neuen Desktop-Anwendung auf Basis von XAML und VB referenzieren:<\/p>\n

Imports System.Xml<\/pre>\n
Danach können wir auf die XmlReader<\/b>-Klasse und ihre Elemente zugreifen. Bei der Klasse handelt es sich um eine abstrakte Klasse, das heißt, Sie können diese nicht instanzieren. Wir können aber dennoch eine Objektvariable nutzen, um auf das zu lesende XML-Dokument zuzugreifen. Um ein XML-Dokument zu öffnen, das auf der Festplatte liegt, verwenden Sie die Create<\/b>-Methode. Dieser übergeben wir den Pfad zu der einzulesenden XML-Datei:<\/p>\n
Dim <\/span>objReader As <\/span>XmlReader\r\nDim <\/span>strPfad As String<\/span>\r\nstrPfad = \"c:\\...\\Kunden.xml\"\r\nobjReader = XmlReader.Create(strPfad)<\/pre>\n
Danach befindet sich das XML-Dokument im Zugriff. Wir schauen uns die Funktionsweise der Klasse XmlReader <\/b>anhand des folgenden XML-Dokuments an:<\/p>\n
<xml version=\"1.0\" encoding=\"utf-8\">\r\n<Bestellverwaltung>\r\n   <!--Auflistung der Kunden-->\r\n   <Kunden>\r\n     <Kunde ID=\"1\">\r\n       <Firma>André Minhorst Verlag<\/Firma>\r\n       <Vorname>André<\/Vorname>\r\n       <Nachname>Minhorst<\/Nachname>\r\n       <Beschreibung><![CDATA[Beschreibung mit CDATA]]><\/Beschreibung>\r\n     <\/Kunde>\r\n     <Kunde ID=\"2\">\r\n       <Firma>Müller GmbH<\/Firma>\r\n       <Vorname>Klaus<\/Vorname>\r\n       <Nachname>Müller<\/Nachname>\r\n     <\/Kunde>\r\n   <\/Kunden>\r\n<\/Bestellverwaltung><\/pre>\n
XML-Dokument sequenziell durchlaufen mit Read<\/b><\/p>\n
Im Gegensatz zum Durchlaufen einer Textdatei durchlaufen wir hier nicht Zeile für Zeile, sondern Element für Element. Ein Element ist dabei nicht etwa eine Einheit wie André<\/Nachname><\/b>. In diesem Fall sind <\/b>, André <\/b>und <\/Vorname> <\/b>jeweils ein Element. Auch der Prolog des XML-Dokuments ist ein eigenes Element. Auf diese Elemente greifen wir mit der Read<\/b>-Methode zu. Nachdem wir diese erstmals aufgerufen haben, referenziert objReader <\/b>das erste Element, in diesem Fall den Prolog. Danach geht es weiter mit den folgenden Elementen – also den Starttags, den enthaltenen Texten, den Endtags und auch den leeren Elementen dazwischen, den sogenannten Whitespace<\/b>-Elementen. Wie erkennen wir nun, welchen Elementtyp objReader <\/b>gerade geladen hat Dazu können wir die Eigenschaft NodeType verwenden. Diesen lassen wir uns in einer ersten Schleife ausgeben:<\/p>\n
Do While<\/span> objReader.Read\r\n     Debug.Print<\/span>(objReader.NodeType)\r\nLoop<\/span><\/pre>\n
Wir durchlaufen also alle Elemente in einer Do While<\/b>-Schleife, deren Abbruch objReader.Read <\/b>lautet. Die Read<\/b>-Methode liefert den Wert True <\/b>zurück, falls noch ein neues Element eingelesen werden konnte und den Wert False<\/b>, wenn das Ende des Dokuments erreicht wurde. Das Ergebnis der Ausgabe ist wenig aussagekräftig, denn NodeType <\/b>liefert einen Zahlenwert (siehe Bild 1).<\/p>\n
\"Elementtypen\"<\/p>\n
Bild 1: Elementtypen<\/span><\/b><\/p>\n
Welcher Wert entspricht nun welchem Elementtyp Das können wir uns im Objektkatalog ansehen, wo wir nach der Eigenschaft NodeType<\/b> suchen und den Eintrag System.Xml.XmlNodeType <\/b>vorfinden. Beim Anklicken der Elemente zeigt der Dialog auch die Zahlenwerte an, die wir mit denen unserer Ausgabe abgleichen können (siehe Bild 2).<\/p>\n
\"Elementtypen<\/p>\n
Bild 2: Elementtypen im Objektkatalog<\/span><\/b><\/p>\n
Also reichern wir unsere Do While<\/b>-Schleife um eine Select Case<\/b>-Bedingung an, welche den Typ ermittelt und diesen im Direktbereich ausgibt. Für uns sind die folgenden Elementtypen interessant:<\/p>\n