J'ai vu un article sur Internet et je l'ai essayé moi-même, XMLTextReader est plus rapide !
La classe XMLTextReader incluse dans l'espace de noms System.XML du .NET Framework peut lire rapidement les données des fichiers XML sans être très gourmande en ressources système. Utilisez la classe XMLTextReader pour lire les données des fichiers XML et les convertir au format HTML pour les afficher dans le navigateur.
Avant de lire cet article, les lecteurs doivent comprendre certaines connaissances de base : XML, HTML, langage de programmation C# et certaines connaissances de .NET, en particulier du framework ASP.NET.
Le framework .NET de Microsoft offre aux développeurs de nombreuses commodités de développement. À mesure que l'importance du XML continue de croître, les développeurs attendent avec impatience le développement d'un ensemble complet d'outils XML puissants. Le framework .NET a répondu à nos attentes et a organisé les classes suivantes pour XML dans l'espace de noms System.XML :
XMLTextReader------Fournit un accès rapide, unidirectionnel et sans tampon. (Un sens signifie que vous ne pouvez lire le fichier XML que d'avant en arrière, et non inversement)
XMLValidatingReader------Utilisé avec la classe XMLTextReader, il offre la possibilité de vérifier les schémas DTD, XDR et XSD.
XMLDocument------suit les normes primaires et secondaires de la spécification W3C Document Object Model pour obtenir un accès aléatoire et mis en cache aux données XML. Le premier niveau contient les parties les plus élémentaires du DOM, tandis que le deuxième niveau ajoute une variété d'améliorations, notamment la prise en charge des espaces de noms et des graphiques en cascade (CSS).
XMLTextWriter------Générer des fichiers XML conformes à la spécification W3C XML 1.0.
Cet article parle principalement de la première classe XMLTextReader. Le but de cette classe est de lire rapidement les données des fichiers XML sans exiger beaucoup de ressources système (notamment la mémoire et le temps processeur). Sous le contrôle du programme parent, il implémente ce processus de travail en exploitant progressivement le fichier XML en traitant un seul nœud à la fois. Dans chaque nœud du fichier XML, le programme parent peut déterminer le type du nœud, ses attributs et données (le cas échéant), ainsi que d'autres informations sur le nœud. Sur la base de ces informations, le programme parent peut choisir de traiter ce nœud ou d'ignorer les informations du nœud pour répondre aux besoins des diverses demandes d'application. C'est ce qu'on appelle le modèle de traitement pull car le programme parent effectue la requête et extrait les nœuds individuels du fichier XML, puis le traite ou ne le traite pas selon les besoins.
Nous pouvons comparer la classe XMLTextReader avec XML Simple Application Programming Interface, ou SAX, qui est une autre technologie de lecture de données XML très populaire parmi les programmeurs. XMLTextReader et SAX sont très similaires dans le sens où ils peuvent lire rapidement les données des fichiers XML sans utiliser beaucoup de ressources système. Cependant, contrairement au modèle d'extraction de XMLTextReader, SAX utilise un modèle push : le processeur XML utilise des « événements » pour informer l'application hôte quelles données de nœud sont disponibles et lesquelles ne peuvent pas être obtenues selon les besoins, le programme hôte réagit en conséquence ou les ignore ; . En d'autres termes, les données sont transmises du gestionnaire SAX vers l'hôte. Les programmeurs se demanderont forcément si les modèles de traitement extractible ou push-in présentent plus d'avantages, mais il est indéniable que les deux modèles fonctionnent bien. Le .NET Framework ne prend pas en charge SAX, mais vous pouvez utiliser les outils SAX existants, tels que l'analyseur MSXML, avec vos applications .NET.
La classe XMLTextReader possède des constructeurs pour s'adapter à diverses situations, telles que la lecture de données à partir d'un flux de données existant ou d'un Uniform Resource Locator. Le plus souvent, vous souhaiterez peut-être lire des données XML à partir d'un fichier, et il existe un constructeur correspondant pour le faire. Voici un exemple (tous mes exemples de code sont en C#, ils sont faciles à convertir si vous préférez utiliser VISUAL BASIC).
XMLTextReader monLecteur ;
myReader = New XMLTextReader("c:datasales.XML")
crée une boucle appelée méthode Read(). La valeur de retour de cette méthode est toujours vraie jusqu'à ce qu'elle atteigne le bas du fichier, lorsque la valeur de retour devient fausse. . En d'autres termes, la boucle commence au début du fichier et lit tous les nœuds, un à la fois, jusqu'à ce que la fin du fichier soit atteinte :
While (myReader.Read()) {
...
// Traitez chaque nœud ici.
...
}
Après chaque appel réussi à Read(), le programme d'instanciation XMLTextReader contient des informations sur le nœud actuel (c'est-à-dire le nœud qui vient de lire le fichier). Nous pouvons obtenir les informations ci-dessus auprès des membres de XMLTextReader, comme décrit dans le tableau 1 et déterminer le type du nœud actuel via l'attribut NodeType ; En fonction du type de nœud, le code du programme peut lire les données du nœud, vérifier s'il possède des attributs et s'il doit les ignorer ou effectuer les opérations et traitements correspondants en fonction des besoins du programme.
Lorsque vous utilisez l'attribut NodeType, il est important de comprendre comment les nœuds sont liés aux cellules XML. Par exemple, regardez l'élément XML suivant :
＜city＞Chongqing＜/city＞
XMLtextReader considère cet élément comme 3 nœuds, dans l'ordre suivant :
1. La balise <city> est lue comme un nœud de type XMLNodeType.Element, et le nom de l'élément "city" peut être obtenu à partir de l'attribut Name de XMLTextReader.
2. Les données texte « Chongqing » sont lues comme un nœud de type XMLNodeType.Text. Les données "Chongqing" peuvent être obtenues à partir de l'attribut Value de XMLTextReader.
3. La balise </city> est lue comme un nœud de type XMLNodeType.EndElement. De même, le nom de l'élément « city » est disponible depuis la propriété Name de XMLTextReader.
Il s'agit de trois types de nœuds importants. D'autres types sont décrits en détail dans la documentation .NET. Veuillez vous référer aux informations pertinentes.
Si XMLTextReader rencontre une erreur, telle qu'une violation de la syntaxe XML, il lève une exception de type System.XML.XMLException. Le code utilisant cette classe doit toujours être protégé (dans un bloc Try...Catch), comme vous le verrez plus tard dans le programme de démonstration.
Cet article n'est qu'une introduction assez simple à la classe XMLTextReader. La classe XMLTextReader compte un certain nombre de membres, et il est impossible de tous les mentionner ici. XMLTextReader offre une flexibilité considérable lors de la lecture de données XML. Malgré cela, j'ai encore beaucoup discuté pour garantir que les lecteurs puissent écrire des programmes pour accomplir des tâches souvent requises dans le monde réel, à savoir lire les données d'un fichier XML, puis les afficher au format HTML pour les implémenter dans le navigateur. afficher.
Ce programme ASP.NET (script) s'exécute sur le serveur et génère une page HTML vers le navigateur. Le script est donné dans l'extrait 1 et le fichier de données XML avec lequel il fonctionne est donné dans l'extrait 2. Vous pouvez voir que ce fichier XML contient une liste de relations ; le but du programme est d'afficher cette liste, qui a été formatée pour la rendre plus facile à visualiser.
Exécutez le programme :
1. Enregistrez l'extrait de code 1 en tant que fichier XMLTextReader.ASPx et l'extrait de code 2 en tant que fichier XMLData.XML.
2. Placez les deux fichiers dans un dossier virtuel sur un serveur Web sur lequel .NET Framework est installé.
3. Ouvrez Internet Explorer et accédez au fichier ASPx, par exemple, sur un serveur LAN, l'URL serait http://localhost/xmltextreader.ASPx ;.
La plupart du travail du programme est effectué par la classe XMLDisplay, en particulier par la méthode ProcessXML(). Il lit les données XML d'un nœud à la fois. Pour l'élément d'intérêt, les données du nœud et le nom du nœud suivi de deux points seront écrits dans le résultat de sortie avec la balise de formatage HTML correspondante. A ce stade, le « résultat de sortie » consiste en un objet StringBuilder dans lequel le texte HTML est temporairement stocké.
La méthode ProcessXML() est appelée depuis la méthode LoadDocument(). La tâche effectuée par cette méthode consiste à générer un programme d'instanciation XMLTextReader et à charger le fichier XML avant d'appeler ProcessXML. Il gère également les exceptions, génère ensuite des messages d'erreur et les affiche dans le navigateur. En fin de compte, la méthode renvoie une chaîne contenant soit le contenu HTML généré, soit un message d'erreur si une exception s'est produite.
L'exécution du programme commence par le programme Page_Load() Lorsque le navigateur demande à parcourir cette page, cette étape sera exécutée automatiquement. Le code ici instancie la classe XMLDisplay et appelle sa méthode LoadDocument(). Si tout fonctionne normalement, la valeur de retour HTML formatée sera copiée dans une balise <div> sur la page et le document HTML généré sera renvoyé au navigateur et affiché.
Comment les autres classes .NET Framework, telles que la classe XMLDocument, fonctionnent-elles lors de la lecture de données XML ? La classe XMLDocument diffère de la classe XMLTextReader en ce sens qu'elle crée une arborescence de nœuds de l'intégralité du document XML en mémoire. De cette façon, les données XML peuvent être obtenues de manière aléatoire (à l'opposé de la manière linéaire dont la classe XMLTextReader obtient les données), et elle a une parfaite flexibilité lors de la modification des données et de la structure du fichier XML. De plus, XMLDocument vous permet d'effectuer des transformations XSLT, mais ces fonctionnalités supplémentaires se font au détriment d'une vitesse d'exécution plus lente et d'une plus grande utilisation des ressources système.
Extrait de code 1 : XmlTextReader.aspx
<%@ Import Namespace="System.Xml" %>
<script language="C#" runat=server>
classe publique XmlDisplay
file://Cette classe lit et traite les fichiers XML.
{
chaîne publique LoadDocument (String XmlFileName) {
XmlTextReader xmlReader = null ;
StringBuilder html = new StringBuilder();
essayer {
file:// crée une instance de XMLTextReader.
xmlReader = nouveau XmlTextReader(XmlFileName);
// Traiter les fichiers XML
html.Append(ProcessXml(xmlReader));
}
catch (XmlException ex){
html.Append("Une exception XML s'est produite : " +
ex.ToString());
}
attraper (Exception ex){
html.Append("Une exception courante s'est produite : " +
ex.ToString());
}
enfin
{
si (xmlReader != null)
xmlReader.Close();
}
return html.ToString();
}
chaîne privée ProcessXml(XmlTextReader xmlReader)
{
StringBuilder temp = new StringBuilder();
file://Cette méthode lit le fichier XML et génère le document HTML de sortie.
tandis que (xmlReader.Read())
{
// Gère le début d'un nœud d'élément.
si (xmlReader.NodeType == XmlNodeType.Element)
{
file://ignore les éléments <people> et <person>
if ((xmlReader.Name != "personne") && (xmlReader.Name != "people"))
{
file://S'il s'agit d'un élément <category>, commencez un nouveau paragraphe
if (xmlReader.Name == "catégorie" )
temp.Append("＜p＞");
file://ajoute les noms d'éléments à la sortie
temp.Append( xmlReader.Name + ": " );
}
}
// Traiter les nœuds de texte
sinon si (xmlReader.NodeType == XmlNodeType.Text)
temp.Append(xmlReader.Value + "<br>");
file:// gère la fin du nœud de l'élément
sinon si (xmlReader.NodeType == XmlNodeType.EndElement)
{
Si file:// est un nœud <email>, ajoutez une balise pour terminer le paragraphe.
if (xmlReader.Name == "email" )
temp.Append("＜/p＞");
}
}//Fin de la boucle while
return temp.ToString();
} file://Fin de la méthode ProcessXML
} file://Fin de la classe XmlDisplay
private void Page_Load (Expéditeur d'objet, EventArgs e){
file://Créer une instance de la classe XmlDisplay
XmlDisplay XmlDisplayDemo = new XmlDisplay();
output.InnerHtml = XmlDisplayDemo.LoadDocument(Server.MapPath("XMLData.xml"));
}
＜/script＞
<html>
＜tête＞
＜/tête＞
<corps>
＜h2＞Classe Démo XmlTextReader＜/h2＞
＜div id="sortie" runat="serveur"/＞
＜/corps＞
＜/html＞
1 vide statique principal (string[] arguments)
2 {
3 DateHeure d1 =DateHeure.Maintenant ;
4 XmlDocumentTest();
5 DateTime d2 =DateTime.Maintenant ;
6 TimeSpan ts = d2-d1 ;
7
8 Console.WriteLine(ts.TotalMilliseconds);
9 Console.Read();
10
11 }
12
13
14 chaîne statique publique XmlFileName = "../../XML/1.xml";
15
16 vide statique privé XmlTextReaderTest()
17 {
18 Lecteur XmlTextReader = new XmlTextReader(XmlFileName);
19 tandis que (reader.Read() )
20 {
21 bool exit =faux ;
22 commutateur (lecteur.NodeType)
vingt-trois {
24 cas XmlNodeType.Element :
25 pause;
26 cas XmlNodeType.Text :
27 si (reader.Value=="dernier")
28 {
29 sortie = vrai ;
30}
31 pause;
32 cas XmlNodeType.EndElement :
33 pause;
34 par défaut :
35 pauses ;
36}
37 si (sortie)
38 {
39 retour;
40
41 }
42
43}
44}
45
46 vide statique privé XmlDocumentTest()
47 {
48 XmlDocument xd =nouveau XmlDocument();
49 xd.Load(XmlFileName);
50 Noeud XmlNode = xd.SelectSingleNode("/people/person[category='last']");
51 Console.Write(node.Name);
52 }
Il s'avère que le premier prend beaucoup de temps :
Il s'avère que le second prend beaucoup de temps :
http://www.cnblogs.com/goody9807/archive/2006/10/24/534888.html