Vi un artículo en Internet y lo probé yo mismo. Efectivamente, ¡XMLTextReader es más rápido!
La clase XMLTextReader incluida en el espacio de nombres System.XML de .NET Framework puede leer rápidamente datos de archivos XML sin exigir mucho recursos del sistema. Utilice la clase XMLTextReader para leer datos de archivos XML y convertirlos al formato HTML para mostrarlos en el navegador.
Antes de leer este artículo, los lectores deben tener algunos conocimientos básicos: XML, HTML, lenguaje de programación C# y algunos conocimientos de .NET, especialmente el marco ASP.NET.
El marco .NET de Microsoft proporciona a los desarrolladores muchas comodidades de desarrollo. A medida que la importancia de XML continúa creciendo, los desarrolladores esperan desarrollar un conjunto completo de potentes herramientas XML. El marco .NET estuvo a la altura de nuestras expectativas y organizó las siguientes clases para XML en el espacio de nombres System.XML:
XMLTextReader------Proporciona acceso rápido, unidireccional y sin búfer. (Unidireccional significa que solo puede leer el archivo XML de adelante hacia atrás, no al revés)
XMLValidatingReader------Utilizado con la clase XMLTextReader, proporciona la capacidad de verificar esquemas DTD, XDR y XSD.
XMLDocument------sigue los estándares primarios y secundarios de la especificación del modelo de objetos de documento W3C para lograr acceso aleatorio y en caché a datos XML. El primer nivel contiene las partes más básicas del DOM, mientras que el segundo nivel agrega una variedad de mejoras, incluida la compatibilidad con espacios de nombres y gráficos en cascada (CSS).
XMLTextWriter------Genere archivos XML que cumplan con la especificación W3C XML 1.0.
Este artículo habla principalmente sobre XMLTextReader de primera clase. El propósito de esta clase es leer rápidamente datos de archivos XML sin exigir mucho a los recursos del sistema (principalmente memoria y tiempo de procesador). Bajo el control del programa principal, implementa este proceso de trabajo operando gradualmente el archivo XML procesando solo un nodo a la vez. En cada nodo del archivo XML, el programa principal puede determinar el tipo de nodo, sus atributos y datos (si los hay) y otra información sobre el nodo. Con base en esta información, el programa principal puede elegir si procesar este nodo o ignorar la información del nodo para satisfacer las necesidades de varias solicitudes de aplicaciones. Esto se denomina modelo de procesamiento de extracción porque el programa principal realiza la solicitud y extrae los nodos individuales del archivo XML y luego lo procesa o no según sea necesario.
Podemos comparar la clase XMLTextReader con la Interfaz de programación de aplicaciones simple XML, o SAX, que es otra tecnología para leer datos XML muy popular entre los programadores. XMLTextReader y SAX son muy similares en el sentido de que pueden leer rápidamente datos de archivos XML sin consumir muchos recursos del sistema. Sin embargo, a diferencia del modelo de extracción de XMLTextReader, SAX utiliza un modelo de inserción: el procesador XML utiliza "eventos" para informar a la aplicación host qué datos de nodo están disponibles y cuáles no se pueden obtener según sea necesario, el programa host responde en consecuencia, reacciona o los ignora; . En otras palabras, los datos se envían desde el controlador SAX al host. Los programadores seguramente debatirán si los modelos de procesamiento de extracción o inserción tienen más ventajas, pero no se puede negar que ambos modelos funcionan bien. .NET Framework no es compatible con SAX, pero puede utilizar herramientas SAX existentes, como el analizador MSXML, con sus aplicaciones .NET.
La clase XMLTextReader tiene constructores para adaptarse a una variedad de situaciones, como leer datos de un flujo de datos existente o un localizador uniforme de recursos. Lo más común es que desees leer datos XML de un archivo, y existe un constructor correspondiente para hacerlo. Aquí hay un ejemplo (todos mis ejemplos de código están en C#, son fáciles de convertir si prefieres usar VISUAL BASIC).
XMLTextReader miLector;
myReader = New XMLTextReader("c:datasales.XML")
crea un bucle llamado método Read() El valor de retorno de este método siempre es verdadero hasta que llega al final del archivo, cuando el valor de retorno se vuelve falso. . En otras palabras, el bucle comienza al principio del archivo y lee todos los nodos, uno a la vez, hasta llegar al final del archivo:
While (myReader.Read()) {
...
// Procesa cada nodo aquí.
...
}
Después de cada llamada exitosa a Read(), el programa de creación de instancias XMLTextReader contiene información sobre el nodo actual (es decir, el nodo que acaba de leer del archivo). Podemos obtener la información anterior de los miembros de XMLTextReader, tal como se describe en la Tabla 1 y determinar el tipo del nodo actual a través del atributo NodeType; Según el tipo de nodo, el código del programa puede leer los datos del nodo, verificar si tiene atributos y si ignorarlos o realizar las operaciones y el procesamiento correspondientes de acuerdo con las necesidades del programa.
Cuando se utiliza el atributo NodeType, es importante comprender cómo se relacionan los nodos con las celdas XML. Por ejemplo, observe el siguiente elemento XML:
＜ciudad＞Chongqing＜/ciudad＞
XMLtextReader considera este elemento como 3 nodos, en el siguiente orden:
1. La etiqueta <ciudad> se lee como un nodo de tipo XMLNodeType.Element y el nombre del elemento "ciudad" se puede obtener del atributo Nombre de XMLTextReader.
2. Los datos de texto "Chongqing" se leen como un nodo de tipo XMLNodeType.Text. Los datos "Chongqing" se pueden obtener del atributo Valor de XMLTextReader.
3． La etiqueta </city> se lee como un nodo de tipo XMLNodeType.EndElement. Asimismo, el nombre del elemento "ciudad" está disponible en la propiedad Nombre del XMLTextReader.
Estos son tres tipos de nodos importantes. Otros tipos se describen en detalle en la documentación de .NET. Consulte la información relevante.
Si XMLTextReader encuentra un error, como una violación de la sintaxis XML, genera una excepción de tipo System.XML.XMLException. El código que utiliza esta clase siempre debe estar protegido (en un bloque Try...Catch), como verá más adelante en el programa de demostración.
Este artículo es sólo una introducción bastante sencilla a la clase XMLTextReader. La clase XMLTextReader tiene bastantes miembros y es imposible mencionarlos a todos aquí. XMLTextReader proporciona una flexibilidad considerable al leer datos XML. Aun así, todavía hablé mucho para garantizar que los lectores puedan escribir programas para lograr tareas que a menudo se requieren en el mundo real, que es leer datos de un archivo XML y luego generarlos en formato HTML para implementarlos en el navegador. mostrar.
Este programa ASP.NET (script) se ejecuta en el servidor y genera una página HTML en el navegador. El script se proporciona en el fragmento 1 y el archivo de datos XML con el que funciona se proporciona en el fragmento 2. Puede ver que este archivo XML contiene una lista de relaciones; el objetivo del programa es mostrar esta lista, que ha sido formateada para que nos resulte más fácil de ver.
Ejecute el programa:
1. Guarde el fragmento de código 1 como un archivo XMLTextReader.ASPx y el fragmento de código 2 como un archivo XMLData.XML.
2. Coloque ambos archivos en una carpeta virtual en un servidor web que tenga instalado .NET Framework.
3． Abra Internet Explorer y busque el archivo ASPx, por ejemplo, en un servidor LAN, la URL sería http://localhost/xmltextreader.ASPx ;.
La mayor parte del trabajo del programa lo realiza la clase XMLDisplay, específicamente el método ProcessXML(). Lee datos XML de un nodo a la vez. Para el elemento de interés, los datos del nodo y el nombre del nodo seguido de dos puntos se escribirán en el resultado de salida junto con la etiqueta de formato HTML correspondiente. En esta etapa, el "resultado de salida" consiste en un objeto StringBuilder en el que se almacena temporalmente el texto HTML.
El método ProcessXML() se llama desde el método LoadDocument(). La tarea realizada por este método es generar un programa de creación de instancias XMLTextReader y cargar el archivo XML antes de llamar a ProcessXML. También maneja excepciones y posteriormente genera mensajes de error y los muestra en el navegador. En última instancia, el método devuelve una cadena que contiene el contenido HTML generado o un mensaje de error si se produjo una excepción.
La ejecución del programa comienza con el programa Page_Load() Cuando el navegador solicita navegar por esta página, este paso se ejecutará automáticamente. El código aquí crea una instancia de la clase XMLDisplay y llama a su método LoadDocument(). Si todo funciona normalmente, el valor de retorno HTML formateado se copiará en una etiqueta <div> en la página y el documento HTML generado se enviará de regreso al navegador y se mostrará.
¿Cómo funcionan otras clases de .NET Framework, como la clase XMLDocument, al leer datos XML? La clase XMLDocument se diferencia de la clase XMLTextReader en que crea un árbol de nodos de todo el documento XML en la memoria. De esta forma, los datos XML se pueden obtener de forma aleatoria (justo lo contrario de la forma lineal en la que la clase XMLTextReader obtiene datos), y tiene perfecta flexibilidad a la hora de modificar los datos y la estructura del archivo XML. Además, XMLDocument le permite realizar transformaciones XSLT, pero estas funciones adicionales se obtienen a expensas de una velocidad de ejecución más lenta y un mayor uso de los recursos del sistema.
Fragmento de código 1: XmlTextReader.aspx
<%@ Import Namespace="System.Xml" %>
<script language="C#" runat=server>
clase pública XmlDisplay
file://Esta clase lee y procesa archivos XML.
{
cadena pública LoadDocument (String XmlFileName) {
XmlTextReader xmlReader = nulo;
StringBuilder html = nuevo StringBuilder();
intentar {
file:// crea una instancia de XMLTextReader.
xmlReader = nuevo XmlTextReader(XmlFileName);
// Procesar archivos XML
html.Append(ProcessXml(xmlReader));
}
capturar (XmlException ex){
html.Append("Se produjo una excepción XML: " +
ex.ToString());
}
captura (Excepción ex){
html.Append("Se produjo una excepción común: " +
ex.ToString());
}
finalmente
{
si (xmlReader! = nulo)
xmlReader.Close();
}
devolver html.ToString();
}
cadena privada ProcessXml(XmlTextReader xmlReader)
{
StringBuilder temp = new StringBuilder()
file://Este método lee el archivo XML y genera el documento HTML de salida.
mientras (xmlReader.Read())
{
// Maneja el inicio de un nodo de elemento.
si (xmlReader.NodeType == XmlNodeType.Element)
{
file://ignora los elementos <people> y <person>
if ((xmlReader.Name != "persona") && (xmlReader.Name != "personas"))
{
file://Si es un elemento <categoría>, comienza un nuevo párrafo
si (xmlReader.Name == "categoría")
temp.Append("＜p＞");
file://agrega nombres de elementos a la salida
temp.Append( xmlReader.Name + ": ");
}
}
// Procesar nodos de texto
de lo contrario si (xmlReader.NodeType == XmlNodeType.Text)
temp.Append(xmlReader.Value + "<br>");
file:// maneja el final del nodo del elemento
de lo contrario si (xmlReader.NodeType == XmlNodeType.EndElement)
{
Si file:// es un nodo <email>, agregue una etiqueta para finalizar el párrafo.
si (xmlReader.Name == "correo electrónico")
temp.Append("＜/p＞");
}
}//Finalizar el bucle while
return temp.ToString();
} file://End ProcessXML método
} file://End XmlDisplay class
private void Page_Load(Remitente del objeto, EventArgs e){
file://Crear una instancia de la clase XmlDisplay
XmlDisplay XmlDisplayDemo = nuevo XmlDisplay();
salida.InnerHtml = XmlDisplayDemo.LoadDocument(Server.MapPath("XMLData.xml"));
}
＜/guión＞
<html>
＜cabeza＞
＜/cabeza＞
<cuerpo>
＜h2＞Clase XmlTextReader de demostración＜/h2＞
＜div id="salida" runat="servidor"/＞
＜/cuerpo＞
＜/html＞
1 vacío estático Principal (cadena [] argumentos)
2 {
3 FechaHora d1 =FechaHora.Ahora;
4 PruebaDocumentoXml();
5 FechaHora d2 =FechaHora.Ahora;
6 períodos de tiempo =d2-d1;
7
8 Console.WriteLine(ts.TotalMillisegundos);
9 Consola.Leer();
10
11 }
12
13
14 cadena estática pública XmlFileName = "../../XML/1.xml";
15
16 vacío estático privado XmlTextReaderTest()
17 {
18 Lector XmlTextReader = nuevo XmlTextReader (XmlFileName);
19 mientras (lector.Read() )
20 {
21 salida bool =falso;
22 interruptores (lector.NodeType)
veintitrés {
24 casos XmlNodeType.Element:
25 descanso;
26 casos XmlNodeType.Text:
27 si (lector.Value=="último")
28 {
29 salida = verdadero;
30}
31 descanso;
32 casos XmlNodeType.EndElement:
33 descanso;
34 predeterminado:
35 descanso;
36}
37 si (salir)
38 {
39 regresan;
40
41 }
42
43}
44}
45
46 vacío estático privado XmlDocumentTest()
47 {
48 Documento Xml xd =nuevo Documento Xml();
49 xd.Load(XmlFileName);
50 nodo XmlNode = xd.SelectSingleNode("/people/person[category='last']");
51 Consola.Write(nodo.Nombre);
52 }
Resulta que el primero lleva mucho tiempo:
Resulta que el segundo lleva mucho tiempo:
http://www.cnblogs.com/goody9807/archive/2006/10/24/534888.html