Ich habe einen Artikel im Internet gesehen und es selbst ausprobiert. Tatsächlich ist XMLTextReader schneller!
Die im System.XML-Namespace des .NET Framework enthaltene XMLTextReader-Klasse kann schnell Daten aus XML-Dateien lesen, ohne die Systemressourcen stark zu beanspruchen. Verwenden Sie die Klasse XMLTextReader, um Daten aus XML-Dateien zu lesen und sie zur Ausgabe im Browser in das HTML-Format zu konvertieren.
Bevor Sie diesen Artikel lesen, müssen die Leser über einige Grundkenntnisse verfügen: XML, HTML, die Programmiersprache C# und einige Kenntnisse über .NET, insbesondere das ASP.NET-Framework.
Das .NET-Framework von Microsoft bietet Entwicklern viele Entwicklungsvorteile. Da die Bedeutung von XML weiter zunimmt, freuen sich Entwickler auf die Entwicklung eines vollständigen Satzes leistungsstarker XML-Tools. Das .NET-Framework hat unsere Erwartungen erfüllt und die folgenden Klassen für XML im System.XML-Namespace organisiert:
XMLTextReader------Bietet schnellen, unidirektionalen, ungepufferten Zugriff auf XML-Daten. (Einseitig bedeutet, dass Sie die XML-Datei nur von vorne nach hinten lesen können, nicht umgekehrt)
XMLValidatingReader------In Verbindung mit der XMLTextReader-Klasse bietet es die Möglichkeit, DTD-, XDR- und XSD-Schemas zu überprüfen.
XMLDocument------folgt den primären und sekundären Standards der W3C Document Object Model-Spezifikation, um einen wahlfreien und zwischengespeicherten Zugriff auf XML-Daten zu erreichen. Die erste Ebene enthält die grundlegendsten Teile des DOM, während die zweite Ebene eine Reihe von Verbesserungen hinzufügt, einschließlich der Unterstützung für Namespaces und Cascading Charts (CSS).
XMLTextWriter------Generieren Sie XML-Dateien, die der W3C XML 1.0-Spezifikation entsprechen.
In diesem Artikel geht es hauptsächlich um die erste Klasse XMLTextReader. Der Zweck dieser Klasse besteht darin, schnell Daten aus XML-Dateien zu lesen, ohne hohe Anforderungen an die Systemressourcen zu stellen (hauptsächlich Speicher und Prozessorzeit). Unter der Kontrolle des übergeordneten Programms implementiert es diesen Arbeitsprozess, indem es die XML-Datei schrittweise bearbeitet und jeweils nur einen Knoten verarbeitet. In jedem Knoten der XML-Datei kann das übergeordnete Programm den Typ des Knotens, seine Attribute und Daten (falls vorhanden) sowie andere Informationen über den Knoten bestimmen. Basierend auf diesen Informationen kann das übergeordnete Programm entscheiden, ob es diesen Knoten verarbeiten oder die Informationen des Knotens ignorieren möchte, um den Anforderungen verschiedener Anwendungsanforderungen gerecht zu werden. Dies wird als Pull-Verarbeitungsmodell bezeichnet, da das übergeordnete Programm die Anforderung stellt, die einzelnen Knoten aus der XML-Datei extrahiert und sie dann je nach Bedarf verarbeitet oder nicht verarbeitet.
Wir können die XMLTextReader-Klasse mit dem XML Simple Application Programming Interface (SAX) vergleichen, einer weiteren Technologie zum Lesen von XML-Daten, die bei Programmierern sehr beliebt ist. XMLTextReader und SAX sind sich insofern sehr ähnlich, als sie schnell Daten aus XML-Dateien lesen können, ohne viele Systemressourcen zu beanspruchen. Im Gegensatz zum Extraktionsmodell von XMLTextReader verwendet SAX jedoch ein Push-Modell: Der XML-Prozessor informiert die Host-Anwendung über „Ereignisse“, welche Knotendaten verfügbar sind und welche nicht wie benötigt abgerufen werden können. Das Host-Programm reagiert entsprechend oder ignoriert sie . Mit anderen Worten: Die Daten werden vom SAX-Handler an den Host übertragen. Programmierer werden sicherlich darüber diskutieren, ob die Pull-out- oder Push-in-Verarbeitungsmodelle mehr Vorteile bieten, aber es lässt sich nicht leugnen, dass beide Modelle gut funktionieren. Das .NET Framework unterstützt SAX nicht, Sie können jedoch vorhandene SAX-Tools wie den MSXML-Parser mit Ihren .NET-Anwendungen verwenden.
Die XMLTextReader-Klasse verfügt über Konstruktoren für verschiedene Situationen, z. B. das Lesen von Daten aus einem vorhandenen Datenstrom oder einem Uniform Resource Locator. Am häufigsten möchten Sie möglicherweise XML-Daten aus einer Datei lesen, und es gibt einen entsprechenden Konstruktor, der dies unterstützt. Hier ist ein Beispiel (alle meine Codebeispiele sind in C# und können leicht konvertiert werden, wenn Sie VISUAL BASIC bevorzugen).
XMLTextReader myReader;
myReader = New XMLTextReader("c:datasales.XML")
erstellt eine Schleife namens Read()-Methode. Der Rückgabewert dieser Methode ist immer wahr, bis sie das Ende der Datei erreicht, dann wird der Rückgabewert falsch . . Mit anderen Worten, die Schleife beginnt am Anfang der Datei und liest nacheinander alle Knoten ein, bis das Ende der Datei erreicht ist:
While (myReader.Read()) {
...
// Verarbeiten Sie hier jeden Knoten.
...
}
Nach jedem erfolgreichen Aufruf von Read() enthält das Instanziierungsprogramm XMLTextReader Informationen über den aktuellen Knoten (d. h. den Knoten, der gerade aus der Datei gelesen wurde). Wir können die oben genannten Informationen von den Mitgliedern von XMLTextReader erhalten, wie in Tabelle 1 beschrieben, und den Typ des aktuellen Knotens über das NodeType-Attribut bestimmen. Basierend auf dem Knotentyp kann der Programmcode die Knotendaten lesen, prüfen, ob sie Attribute haben und ob sie ignoriert werden sollen oder entsprechende Vorgänge und Verarbeitungen entsprechend den Anforderungen des Programms durchführen.
Bei der Verwendung des NodeType-Attributs ist es wichtig zu verstehen, wie Knoten mit XML-Zellen zusammenhängen. Sehen Sie sich beispielsweise das folgende XML-Element an:
＜city＞Chongqing＜/city＞
XMLtextReader betrachtet dieses Element als 3 Knoten in der folgenden Reihenfolge:
1. Das <city>-Tag wird als Knoten vom Typ XMLNodeType.Element gelesen und der Name des Elements „city“ kann aus dem Name-Attribut von XMLTextReader abgerufen werden.
2. Die Textdaten „Chongqing“ werden als Knoten vom Typ XMLNodeType.Text gelesen. Die Daten „Chongqing“ können aus dem Value-Attribut von XMLTextReader abgerufen werden.
3． Das </city>-Tag wird als Knoten vom Typ XMLNodeType.EndElement gelesen. Ebenso ist der Name des Elements „city“ über die Name-Eigenschaft des XMLTextReader verfügbar.
Dies sind drei wichtige Knotentypen, die in der .NET-Dokumentation ausführlich beschrieben werden.
Wenn XMLTextReader auf einen Fehler stößt, beispielsweise einen Verstoß gegen die XML-Syntax, löst er eine Ausnahme vom Typ System.XML.XMLException aus. Code, der diese Klasse verwendet, sollte immer geschützt sein (in einem Try...Catch-Block), wie Sie später im Demoprogramm sehen werden.
Dieser Artikel ist nur eine ziemlich einfache Einführung in die XMLTextReader-Klasse. Die XMLTextReader-Klasse hat eine ganze Reihe von Mitgliedern, und es ist unmöglich, sie alle hier zu erwähnen. XMLTextReader bietet erhebliche Flexibilität beim Lesen von XML-Daten. Trotzdem habe ich noch viel darüber gesprochen, um sicherzustellen, dass Leser Programme schreiben können, um Aufgaben zu erfüllen, die in der realen Welt häufig erforderlich sind, nämlich Daten aus einer XML-Datei zu lesen und sie dann im HTML-Format auszugeben, um sie im Browser zu implementieren. Anzeige.
Dieses ASP.NET-Programm (Skript) wird auf dem Server ausgeführt und generiert eine HTML-Seite zurück an den Browser. Das Skript ist in Snippet 1 angegeben, und die XML-Datendatei, mit der es arbeitet, ist in Snippet 2 angegeben. Sie können sehen, dass diese XML-Datei eine Liste von Beziehungen enthält. Das Ziel des Programms besteht darin, diese Liste anzuzeigen, die so formatiert wurde, dass sie für uns leichter sichtbar ist.
Führen Sie das Programm aus:
1. Speichern Sie Codeausschnitt 1 als XMLTextReader.ASPx-Datei und Codeausschnitt 2 als XMLData.XML-Datei.
2. Platzieren Sie beide Dateien in einem virtuellen Ordner auf einem Webserver, auf dem .NET Framework installiert ist.
3． Öffnen Sie Internet Explorer und navigieren Sie zur ASPx-Datei. Auf einem LAN-Server lautet die URL beispielsweise http://localhost/xmltextreader.ASPx ;.
Die meiste Arbeit des Programms wird von der XMLDisplay-Klasse erledigt, insbesondere von der ProcessXML()-Methode. Es liest jeweils einen Knoten im XML-Format. Für das gewünschte Element werden die Knotendaten und der Knotenname gefolgt von einem Doppelpunkt zusammen mit dem entsprechenden HTML-Formatierungs-Tag in das Ausgabeergebnis geschrieben. Zu diesem Zeitpunkt besteht das „Ausgabeergebnis“ aus einem StringBuilder-Objekt, in dem der HTML-Text vorübergehend gespeichert wird.
Die ProcessXML()-Methode wird von der LoadDocument()-Methode aufgerufen. Die Aufgabe dieser Methode besteht darin, ein XMLTextReader-Instanziierungsprogramm zu generieren und die XML-Datei zu laden, bevor ProcessXML aufgerufen wird. Es behandelt auch Ausnahmen und generiert anschließend Fehlermeldungen und zeigt diese im Browser an. Letztendlich gibt die Methode einen String zurück, der entweder den generierten HTML-Inhalt oder eine Fehlermeldung enthält, wenn eine Ausnahme aufgetreten ist.
Die Programmausführung beginnt mit dem Programm Page_Load(). Wenn der Browser das Durchsuchen dieser Seite anfordert, wird dieser Schritt automatisch ausgeführt. Der Code hier instanziiert die XMLDisplay-Klasse und ruft ihre LoadDocument()-Methode auf. Wenn alles normal läuft, wird der formatierte HTML-Rückgabewert in ein <div>-Tag auf der Seite kopiert und das generierte HTML-Dokument an den Browser zurückgesendet und angezeigt.
Welche Leistung erbringen andere .NET Framework-Klassen, beispielsweise die XMLDocument-Klasse, beim Lesen von XML-Daten? Die XMLDocument-Klasse unterscheidet sich von der XMLTextReader-Klasse dadurch, dass sie einen Knotenbaum des gesamten XML-Dokuments im Speicher erstellt. Auf diese Weise können XML-Daten zufällig abgerufen werden (genau das Gegenteil der linearen Methode, mit der die XMLTextReader-Klasse Daten abruft) und bietet perfekte Flexibilität beim Ändern der Daten und Struktur der XML-Datei. Darüber hinaus können Sie mit XMLDocument XSLT-Transformationen durchführen, diese zusätzlichen Funktionen gehen jedoch zu Lasten einer langsameren Ausführungsgeschwindigkeit und einer höheren Auslastung der Systemressourcen.
Codeausschnitt 1: XmlTextReader.aspx
<%@ Import Namespace="System.Xml" %>
<script language="C#" runat=server>
öffentliche Klasse XmlDisplay
file://Diese Klasse liest und verarbeitet XML-Dateien.
{
öffentliche Zeichenfolge LoadDocument(String XmlFileName) {
XmlTextReader xmlReader = null;
StringBuilder html = new StringBuilder();
versuchen {
file:// erstellt eine Instanz von XMLTextReader.
xmlReader = new XmlTextReader(XmlFileName);
// XML-Dateien verarbeiten
html.Append(ProcessXml(xmlReader));
}
Catch (XmlException ex){
html.Append("Eine XML-Ausnahme ist aufgetreten: " +
ex.ToString());
}
Catch (Ausnahme ex){
html.Append("Eine häufige Ausnahme ist aufgetreten: " +
ex.ToString());
}
Endlich
{
if (xmlReader != null)
xmlReader.Close();
}
return html.ToString();
}
privater String ProcessXml(XmlTextReader xmlReader)
{
StringBuilder temp = new StringBuilder();
file://Diese Methode liest die XML-Datei und generiert das Ausgabe-HTML-Dokument.
while (xmlReader.Read())
{
// Behandeln Sie den Anfang eines Elementknotens.
if (xmlReader.NodeType == XmlNodeType.Element)
{
file://ignoriert die Elemente <people> und <person>
if ((xmlReader.Name != "person") && (xmlReader.Name != "people"))
{
file://Wenn es sich um ein <category>-Element handelt, beginnen Sie einen neuen Absatz
if (xmlReader.Name == "category" )
temp.Append("＜p＞");
file://fügt der Ausgabe Elementnamen hinzu
temp.Append( xmlReader.Name + ": " );
}
}
// Textknoten verarbeiten
sonst wenn (xmlReader.NodeType == XmlNodeType.Text)
temp.Append(xmlReader.Value + "<br>");
file:// behandelt das Ende des Elementknotens
sonst wenn (xmlReader.NodeType == XmlNodeType.EndElement)
{
Wenn file:// ein <email>-Knoten ist, fügen Sie ein Tag hinzu, um den Absatz zu beenden.
if (xmlReader.Name == "email" )
temp.Append("＜/p＞");
}
}//Beende die while-Schleife
return temp.ToString();
} file://End ProcessXML method
} file://End XmlDisplay class
private void Page_Load(Object sender, EventArgs e){
file://Erstellen Sie eine Instanz der XmlDisplay-Klasse
XmlDisplay XmlDisplayDemo = new XmlDisplay();
Output.InnerHtml = XmlDisplayDemo.LoadDocument(Server.MapPath("XMLData.xml"));
}
＜/script＞
<html>
<Kopf>
＜/Kopf＞
<Körper>
＜h2＞Demo XmlTextReader-Klasse＜/h2＞
＜div id="output" runat="server"/＞
＜/Körper＞
＜/html＞
1 statisches void Main(string[] args)
2 {
3 DateTime d1 =DateTime.Now;
4 XmlDocumentTest();
5 DateTime d2 =DateTime.Now;
6 TimeSpan ts =d2-d1;
7
8 Console.WriteLine(ts.TotalMilliseconds);
9 Console.Read();
10
11 }
12
13
14 öffentliche statische Zeichenfolge XmlFileName = "../../XML/1.xml";
15
16 private statische void XmlTextReaderTest()
17 {
18 XmlTextReader reader = new XmlTextReader(XmlFileName);
19 while (reader.Read() )
20 {
21 bool Ausgang =false;
22 Schalter(reader.NodeType)
dreiundzwanzig {
24 Fall XmlNodeType.Element:
25 Pause;
26 Fall XmlNodeType.Text:
27 if (reader.Value=="last")
28 {
29 Exit=true;
30}
31 Pause;
32 Fall XmlNodeType.EndElement:
33 Pause;
34 Standard:
35 Pause;
36}
37 if(exit)
38 {
39 Rückkehr;
40
41 }
42
43}
44}
45
46 privates statisches void XmlDocumentTest()
47 {
48 XmlDocument xd =new XmlDocument();
49 xd.Load(XmlFileName);
50 XmlNode node = xd.SelectSingleNode("/people/person[category='last']");
51 Console.Write(node.Name);
52 }
Es stellt sich heraus, dass der erste sehr lange dauert:
Es stellt sich heraus, dass der zweite zeitaufwändig ist:
http://www.cnblogs.com/goody9807/archive/2006/10/24/534888.html