XmlReader Clase

Referencia

Definición

Espacio de nombres:: System.Xml

Ensamblado:: System.Xml.ReaderWriter.dll

Ensamblado:: System.Xml.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Representa un lector que proporciona acceso rápido a datos XML, sin almacenamiento en caché y con desplazamiento solo hacia delante.

public ref class XmlReader abstract : IDisposable

public ref class XmlReader abstract

public abstract class XmlReader : IDisposable

public abstract class XmlReader

type XmlReader = class
    interface IDisposable

type XmlReader = class

Public MustInherit Class XmlReader
Implements IDisposable

Public MustInherit Class XmlReader

Herencia: Object
XmlReader

Derivado: System.Xml.XmlDictionaryReader

System.Xml.XmlNodeReader

System.Xml.XmlTextReader

System.Xml.XmlValidatingReader

Implementaciones: IDisposable

Ejemplos

En el código de ejemplo siguiente se muestra cómo usar la API asincrónica para analizar XML.

async Task TestReader(System.IO.Stream stream)
{
    XmlReaderSettings settings = new XmlReaderSettings();
    settings.Async = true;

    using (XmlReader reader = XmlReader.Create(stream, settings))
    {
        while (await reader.ReadAsync())
        {
            switch (reader.NodeType)
            {
                case XmlNodeType.Element:
                    Console.WriteLine("Start Element {0}", reader.Name);
                    break;
                case XmlNodeType.Text:
                    Console.WriteLine("Text Node: {0}",
                             await reader.GetValueAsync());
                    break;
                case XmlNodeType.EndElement:
                    Console.WriteLine("End Element {0}", reader.Name);
                    break;
                default:
                    Console.WriteLine("Other node {0} with value {1}",
                                    reader.NodeType, reader.Value);
                    break;
            }
        }
    }
}

Public Async Function TestReader(stream As System.IO.Stream) As Task
    Dim settings As New XmlReaderSettings()
    settings.Async = True

    Using reader As XmlReader = XmlReader.Create(stream, settings)
        While (Await reader.ReadAsync())
            Select Case (reader.NodeType)
                Case XmlNodeType.Element
                    Console.WriteLine("Start Element {0}", reader.Name)
                Case XmlNodeType.Text
                    Console.WriteLine("Text Node: {0}",
                             Await reader.GetValueAsync())
                Case XmlNodeType.EndElement
                    Console.WriteLine("End Element {0}", reader.Name)
                Case Else
                    Console.WriteLine("Other node {0} with value {1}",
                                    reader.NodeType, reader.Value)
            End Select
        End While
    End Using
End Function

Comentarios

XmlReader proporciona acceso de solo avance y de solo lectura a los datos XML de un documento o secuencia. Esta clase se ajusta a las recomendaciones W3C Extensible Markup Language (XML) 1.0 (cuarta edición) y los espacios de nombres en XML 1.0 (tercera edición).

XmlReader los métodos permiten desplazarse por datos XML y leer el contenido de un nodo. Las propiedades de la clase reflejan el valor del nodo actual, que es donde se coloca el lector. El ReadState valor de propiedad indica el estado actual del lector XML. Por ejemplo, la propiedad se establece ReadState.Initial en por el XmlReader.Read método y ReadState.Closed por el XmlReader.Close método . XmlReader también proporciona comprobaciones de conformidad de datos y validación con un DTD o un esquema.

XmlReader usa un modelo de extracción para recuperar datos. Este modelo:

Simplifica la administración del estado mediante un refinamiento de procedimientos natural y descendente.
Admite varios flujos de entrada y capas.
Permite al cliente proporcionar al analizador un búfer en el que se escribe directamente la cadena y, por tanto, evita la necesidad de una copia de cadena adicional.
Admite el procesamiento selectivo. El cliente puede omitir elementos y procesar aquellos que son de interés para la aplicación. También puede establecer propiedades de antemano para administrar cómo se procesa el flujo XML (por ejemplo, normalización).

En esta sección:

Creación de un lector XML Validando la conformidad de datos XML Navegación por los nodos Lectura de elementos XML Lectura de atributos XML Lectura de contenido XML Conversión a tipos CLR Consideraciones de seguridad asincrónicas de seguridad

Creación de un lector XML

Use el Create método para crear una XmlReader instancia.

Aunque .NET Framework proporciona implementaciones concretas de la XmlReader clase , como XmlTextReader, XmlNodeReadery las XmlValidatingReader clases, se recomienda usar las clases especializadas solo en estos escenarios:

Cuando desee leer un subárbol XML DOM de un XmlNode objeto, use la XmlNodeReader clase . (Sin embargo, esta clase no admite DTD ni la validación de esquemas).
Si debe expandir entidades bajo solicitud, no desea que el contenido de texto se normalice o no desee que se devuelvan los atributos predeterminados, use la XmlTextReader clase .

Para especificar el conjunto de características que desea habilitar en el lector XML, pase un System.Xml.XmlReaderSettings objeto al Create método . Puede usar un solo System.Xml.XmlReaderSettings objeto para crear varios lectores con la misma funcionalidad o modificar el System.Xml.XmlReaderSettings objeto para crear un nuevo lector con un conjunto diferente de características. También puede agregar fácilmente características a un lector existente.

Si no usa un System.Xml.XmlReaderSettings objeto , se usa la configuración predeterminada. Consulte la página de Create referencia para obtener más información.

XmlReader produce un XmlException en errores de análisis XML. Una vez iniciada una excepción, el estado del lector no es predecible. Por ejemplo, el tipo de nodo notificado puede ser diferente del tipo de nodo real del nodo actual. Utilice la ReadState propiedad para comprobar si el lector está en estado de error.

Validación de datos XML

Para definir la estructura de un documento XML y sus relaciones de elementos, tipos de datos y restricciones de contenido, use un esquema de definición de tipo de documento (DTD) o lenguaje de definición de esquemas XML (XSD). Un documento XML se considera correcto si cumple todos los requisitos sintácticos definidos por la recomendación W3C XML 1.0. Se considera válido si está bien formado y también se ajusta a las restricciones definidas por su DTD o esquema. (Vea el esquema XML W3C Parte 1: Estructuras y el esquema XML W3C Parte 2: recomendaciones de tipos de datos). Por lo tanto, aunque todos los documentos XML válidos tienen un formato correcto, no todos los documentos XML bien formados son válidos.

Puede validar los datos con un DTD, un esquema XSD insertado o un esquema XSD almacenado en un XmlSchemaSet objeto (una memoria caché); estos escenarios se describen en la Create página de referencia. XmlReader no admite la validación de esquemas reducidos (XDR) de XML-Data.

Use la siguiente configuración en la XmlReaderSettings clase para especificar qué tipo de validación, si existe, la XmlReader instancia admite.

Usar este XmlReaderSettings miembro	Para especificar
PropiedadDtdProcessing	Si se va a permitir el procesamiento de DTD. El valor predeterminado es no permitir el procesamiento de DTD.
PropiedadValidationType	Si el lector debe validar los datos y qué tipo de validación se va a realizar (DTD o esquema). El valor predeterminado es que no hay validación de datos.
EventoValidationEventHandler	Un controlador de eventos para recibir información sobre los eventos de validación. Si no se proporciona un controlador de eventos, se inicia una XmlException en el primer error de validación.
PropiedadValidationFlags	Opciones de validación adicionales a través de los miembros de la XmlSchemaValidationFlags enumeración: - `AllowXmlAttributes`-- Permitir atributos XML (`xml:*`) en documentos de instancia incluso cuando no están definidos en el esquema. Los atributos se validan basándose en su tipo de datos. Consulte la XmlSchemaValidationFlags página de referencia de la configuración que se va a usar en escenarios específicos. (Deshabilitado de forma predeterminada). - `ProcessIdentityConstraints`--Process identity constraints (`xs:ID`, `xs:IDREF`, `xs:keyxs:keyref`, , `xs:unique`) encontrados durante la validación. (Habilitado de forma predeterminada). - `ProcessSchemaLocation` --Process esquemas especificados por el `xsi:schemaLocation` atributo o `xsi:noNamespaceSchemaLocation` . (Habilitado de forma predeterminada). - `ProcessInlineSchema`-- Procesar esquemas XML insertados durante la validación. (Deshabilitado de forma predeterminada). - `ReportValidationWarnings`--Notificar eventos si se produce una advertencia de validación. Normalmente se produce una advertencia cuando no hay ninguna DTD ni esquema XML para validar un elemento o atributo en particular. ValidationEventHandler se utiliza para las notificaciones. (Deshabilitado de forma predeterminada).
Schemas	XmlSchemaSet que se va a usar para validación.
PropiedadXmlResolver	XmlResolver para resolver y acceder a recursos externos. Esto puede incluir entidades externas, como DTD y esquemas, y cualquier `xs:include` elemento o `xs:import` contenido en el esquema XML. Si no especifica un XmlResolver, usa XmlReader un valor predeterminado XmlUrlResolver sin credenciales de usuario.

Conformidad de datos

Los lectores XML creados por el Create método cumplen los siguientes requisitos de cumplimiento de forma predeterminada:

Las nuevas líneas y el valor de atributo se normalizan según la recomendación W3C XML 1.0.
Todas las entidades se expanden automáticamente.
Los atributos predeterminados declarados en la definición del tipo de documento siempre se agregan incluso cuando el lector no se valida.
Se permite la declaración del prefijo XML asignado al URI de espacio de nombres XML correcto.
Los nombres de notación de una sola NotationType declaración de atributo y NmTokens en una Enumeration sola declaración de atributo son distintos.

Use estas XmlReaderSettings propiedades para especificar el tipo de comprobaciones de conformidad que desea habilitar:

Usar esta XmlReaderSettings propiedad	En	Default
PropiedadCheckCharacters	Habilite o deshabilite las comprobaciones siguientes: - Los caracteres están dentro del intervalo de caracteres XML legales, tal y como se define en la sección 2.2 Caracteres de la recomendación W3C XML 1.0. - Todos los nombres XML son válidos, tal como se define en la sección Construcciones sintácticas comunes 2.3 de la recomendación W3C XML 1.0. Cuando esta propiedad se establece `true` en (valor predeterminado), se produce una XmlException excepción si el archivo XML contiene caracteres no válidos o nombres XML no válidos (por ejemplo, un nombre de elemento comienza con un número).	La comprobación de caracteres y nombres está habilitada. Al establecer la propiedad CheckCharacters en `false`, se desactiva la comprobación de caracteres en las referencias a entidades de caracteres. Si el lector está procesando datos de texto, siempre comprueba que los nombres XML son válidos, independientemente de esta configuración. Nota: La recomendación XML 1.0 requiere conformidad de nivel de documento cuando hay una DTD presente. Por lo tanto, si el lector está configurado para admitir ConformanceLevel.Fragment, pero los datos XML contienen una definición de tipo de documento (DTD), se produce una XmlException excepción .
PropiedadConformanceLevel	Elija el nivel de conformidad para aplicar: - Document. Se ajusta a las reglas de un documento XML 1.0 bien formado. - Fragment. Se ajusta a las reglas de un fragmento de documento bien formado que se puede consumir como una entidad analizada externa. - Auto. Se ajusta al nivel decidido por el lector. Si los datos no son conformes, se produce una XmlException excepción.	Document

Navegación por los nodos

El nodo actual es el nodo XML en el que está colocado actualmente el lector XML. Todos los XmlReader métodos realizan operaciones en relación con este nodo y todas las XmlReader propiedades reflejan el valor del nodo actual.

Los métodos siguientes facilitan la navegación por los nodos y analizar los datos.

Usar este XmlReaderSettings método	En
Read	Lea el primer nodo y avance por la secuencia de un nodo cada vez. Normalmente, estas llamadas se realizan dentro de un `while` bucle. Utilice la NodeType propiedad para obtener el tipo (por ejemplo, atributo, comentario, elemento, etc.) del nodo actual.
Skip	Omita los elementos secundarios del nodo actual y muévalo al siguiente nodo.
MoveToContent y MoveToContentAsync	Omita los nodos que no son de contenido y pase al siguiente nodo de contenido o al final del archivo. Los nodos que no son de contenido incluyen ProcessingInstruction, DocumentType, Comment, Whitespacey SignificantWhitespace. Los nodos de contenido incluyen texto de espacio no en blanco, CDATA, EntityReference y EndEntity.
ReadSubtree	Lea un elemento y todos sus elementos secundarios y devuelva una nueva XmlReader instancia establecida en ReadState.Initial. Este método es útil para crear límites alrededor de elementos XML; por ejemplo, si desea pasar datos a otro componente para su procesamiento y desea limitar la cantidad de datos a los que puede acceder el componente.

Consulte la XmlReader.Read página de referencia para obtener un ejemplo de navegación por un flujo de texto de un nodo cada vez y mostrar el tipo de cada nodo.

En las secciones siguientes se describe cómo puede leer tipos específicos de datos, como elementos, atributos y datos con tipo.

Lectura de elementos XML

En la tabla siguiente se enumeran los métodos y las propiedades que proporciona la XmlReader clase para procesar elementos. Después de que XmlReader se sitúe en un elemento, las propiedades del nodo como, por ejemplo, Name, reflejan los valores del elemento. Además de los miembros que se describen a continuación, también se puede utilizar cualquiera de los métodos y propiedades generales de la clase XmlReader para procesar elementos. Por ejemplo, puede utilizar el método ReadInnerXml para leer el contenido de un elemento.

Nota

Consulte la sección 3.1 de la recomendación XML 1.0 de W3C para ver las definiciones de etiquetas de inicio, etiquetas finales y etiquetas de elemento vacías.

Usar este XmlReader miembro	En
Método IsStartElement	Compruebe si el nodo actual es una etiqueta de inicio o una etiqueta de elemento vacía.
Método ReadStartElement	Compruebe que el nodo actual es un elemento y avance el lector al siguiente nodo (llamadas IsStartElement seguidas de Read).
Método ReadEndElement	Compruebe que el nodo actual es una etiqueta final y avance el lector al siguiente nodo.
Método ReadElementString	Lee un elemento de solo texto.
Método ReadToDescendant	Avance el lector XML al siguiente elemento descendiente (secundario) que tiene el nombre especificado.
Método ReadToNextSibling	Avance el lector XML al siguiente elemento relacionado que tiene el nombre especificado.
PropiedadIsEmptyElement	Compruebe si el elemento actual tiene una etiqueta de elemento final. Por ejemplo: - `<item num="123"/>` (IsEmptyElement es `true`). - `<item num="123"> </item>` (IsEmptyElement es `false`, aunque el contenido del elemento está vacío).

Para obtener un ejemplo de lectura del contenido de texto de los elementos, vea el ReadString método . En el ejemplo siguiente se procesan los elementos mediante un while bucle .

while (reader.Read()) {
  if (reader.IsStartElement()) {
    if (reader.IsEmptyElement)
                {
                    Console.WriteLine("<{0}/>", reader.Name);
                }
                else {
      Console.Write("<{0}> ", reader.Name);
      reader.Read(); // Read the start tag.
      if (reader.IsStartElement())  // Handle nested elements.
        Console.Write("\r\n<{0}>", reader.Name);
      Console.WriteLine(reader.ReadString());  //Read the text content of the element.
    }
  }
}

While reader.Read()
  If reader.IsStartElement() Then
    If reader.IsEmptyElement Then
      Console.WriteLine("<{0}/>", reader.Name)
    Else
      Console.Write("<{0}> ", reader.Name)
      reader.Read() ' Read the start tag.
      If reader.IsStartElement() Then ' Handle nested elements.
        Console.Write(vbCr + vbLf + "<{0}>", reader.Name)
      End If
      Console.WriteLine(reader.ReadString()) 'Read the text content of the element.
    End If
  End If
End While

Lectura de atributos XML

Los atributos XML se encuentran normalmente en los elementos, pero también se permiten en los nodos de tipo de documento y declaración XML.

Cuando se coloca en un nodo de elemento, el MoveToAttribute método permite recorrer la lista de atributos del elemento. Tenga en cuenta que después MoveToAttribute de llamar a , las propiedades de nodo como Name, NamespaceURIy Prefix reflejan las propiedades de ese atributo, no las propiedades del elemento al que pertenece el atributo.

La XmlReader clase proporciona estos métodos y propiedades para leer y procesar atributos en elementos.

Usar este XmlReader miembro	En
PropiedadHasAttributes	Compruebe si el nodo actual tiene atributos.
PropiedadAttributeCount	Obtiene el número de atributos en el elemento actual.
Método MoveToFirstAttribute	Vaya al primer atributo de un elemento.
Método MoveToNextAttribute	Vaya al siguiente atributo de un elemento .
Método MoveToAttribute	Vaya a un atributo especificado.
GetAttribute método o Item[] propiedad	Obtiene el valor de un atributo especificado.
PropiedadIsDefault	Compruebe si el nodo actual es un atributo que se generó a partir del valor predeterminado definido en el DTD o el esquema.
Método MoveToElement	Vaya al elemento que posee el atributo actual. Utilice este método para volver a un elemento después de navegar por sus atributos.
Método ReadAttributeValue	Analice el valor del atributo en uno o varios `Text`nodos , `EntityReference`o `EndEntity` .

También se puede utilizar cualquiera de las propiedades y los métodos XmlReader generales para procesar atributos. Por ejemplo, después de situar XmlReader en un atributo, las propiedades Name y Value reflejan los valores del atributo. También puede utilizar cualquiera de los métodos Read de contenido para obtener el valor del atributo.

En este ejemplo se usa la AttributeCount propiedad para navegar por todos los atributos de un elemento.

// Display all attributes.
if (reader.HasAttributes) {
  Console.WriteLine("Attributes of <" + reader.Name + ">");
  for (int i = 0; i < reader.AttributeCount; i++) {
    Console.WriteLine("  {0}", reader[i]);
  }
  // Move the reader back to the element node.
  reader.MoveToElement();
}

' Display all attributes.
If reader.HasAttributes Then
  Console.WriteLine("Attributes of <" + reader.Name + ">")
  Dim i As Integer
  For i = 0 To (reader.AttributeCount - 1)
    Console.WriteLine("  {0}", reader(i))
  Next i
  ' Move the reader back to the element node.
  reader.MoveToElement() 
End If

En este ejemplo se usa el MoveToNextAttribute método de un while bucle para navegar por los atributos.

if (reader.HasAttributes) {
  Console.WriteLine("Attributes of <" + reader.Name + ">");
  while (reader.MoveToNextAttribute()) {
    Console.WriteLine(" {0}={1}", reader.Name, reader.Value);
  }
  // Move the reader back to the element node.
  reader.MoveToElement();
}

If reader.HasAttributes Then
  Console.WriteLine("Attributes of <" + reader.Name + ">")
  While reader.MoveToNextAttribute()
    Console.WriteLine(" {0}={1}", reader.Name, reader.Value)
  End While
  ' Move the reader back to the element node.
  reader.MoveToElement()
End If

Lectura de atributos en nodos de declaración XML

Cuando el lector XML se coloca en un nodo de declaración XML, la Value propiedad devuelve la información de versión, independiente y codificación como una sola cadena. XmlReader objetos creados por el Create método , la XmlTextReader clase y la XmlValidatingReader clase exponen los elementos de versión, independiente y codificación como atributos.

Lectura de atributos en nodos de tipo de documento

Cuando el lector XML se coloca en un nodo de tipo de documento, el método y Item[] la GetAttribute propiedad se pueden usar para devolver los valores de los literales SYSTEM y PUBLIC. Por ejemplo, al llamar a reader.GetAttribute("PUBLIC"), se devuelve el valor PUBLIC.

Lectura de atributos en nodos de instrucción de procesamiento

Cuando XmlReader está situado en un nodo de instrucción de procesamiento, la propiedad Value devuelve el contenido de texto completo. Los elementos del nodo de instrucción de procesamiento no se tratan como atributos. No se pueden leer con el GetAttribute método o MoveToAttribute .

Lectura de contenido XML

La clase XmlReader incluye los siguientes miembros que leen contenido de un archivo XML y devuelven el contenido como valores de cadena. (Para devolver tipos CLR, consulte la sección siguiente).

Usar este XmlReader miembro	En
PropiedadValue	Obtiene el contenido de texto del nodo actual. El valor devuelto depende del tipo de nodo; consulte la página de Value referencia para obtener más información.
Método ReadString	Obtiene el contenido de un elemento o nodo de texto como una cadena. Este método se detiene en el procesamiento de instrucciones y comentarios. Para obtener más información sobre cómo este método controla tipos de nodo específicos, consulte la página de ReadString referencia.
Métodos ReadInnerXml y ReadInnerXmlAsync	Obtenga todo el contenido del nodo actual, incluido el marcado, pero sin incluir las etiquetas de inicio y finalización. Por ejemplo, para: `<node>this<child id="123"/></node>` ReadInnerXml devuelve lo siguiente: `this<child id="123"/>`
Métodos ReadOuterXml y ReadOuterXmlAsync	Obtenga todo el contenido del nodo actual y sus elementos secundarios, incluidas las etiquetas de marcado y de inicio y finalización. Por ejemplo, para: `<node>this<child id="123"/></node>` ReadOuterXml devuelve lo siguiente: `<node>this<child id="123"/></node>`

Conversión a tipos CLR

Puede usar los miembros de la XmlReader clase (enumeradas en la tabla siguiente) para leer datos XML y devolver valores como tipos de Common Language Runtime (CLR) en lugar de cadenas. Estos miembros permiten obtener valores en la representación más adecuada para la tarea de codificación sin tener que analizar o convertir manualmente valores de cadena.

Los métodos ReadElementContentAs solo se pueden llamar en tipos de nodo de elemento. Estos métodos no se pueden utilizar en elementos que contienen elementos segundarios o incluyen contenido mixto. Al llamar al objeto XmlReader, éste lee la etiqueta de inicio y el contenido del elemento y, a continuación, se mueve después de la etiqueta del elemento de fin. Las instrucciones de procesamiento y los comentarios se omiten y las entidades se expanden.
Los métodos ReadContentAs leen el contenido de texto en la posición del lector actual y, si los datos XML no tienen ningún esquema o información de tipo de datos asociada, convierta el contenido de texto al tipo de valor devuelto solicitado. El texto, el espacio en blanco, el espacio en blanco significativo y las secciones CDATA se concatenan. Los comentarios y las instrucciones de procesamiento se omiten y las referencias de entidad se resuelven automáticamente.

La XmlReader clase usa las reglas definidas por la recomendación W3C XML Schema Part 2: Datatypes .

Usar este XmlReader método	Para devolver este tipo CLR
ReadContentAsBoolean y ReadElementContentAsBoolean	Boolean
ReadContentAsDateTime y ReadElementContentAsDateTime	DateTime
ReadContentAsDouble y ReadElementContentAsDouble	Double
ReadContentAsLong y ReadElementContentAsLong	Int64
ReadContentAsInt y ReadElementContentAsInt	Int32
ReadContentAsString y ReadElementContentAsString	String
ReadContentAs y ReadElementContentAs	Tipo que se especifica con el `returnType` parámetro
ReadContentAsObject y ReadElementContentAsObject	Tipo más adecuado, según lo especificado por la XmlReader.ValueType propiedad . Consulte Compatibilidad de tipos en las clases de System.Xml para obtener información de asignación.

Si un elemento no se puede convertir fácilmente a un tipo CLR debido a su formato, puede usar una asignación de esquema para garantizar una conversión correcta. En el ejemplo siguiente se usa un archivo .xsd para convertir el hire-date elemento en el xs:date tipo y, a continuación, se usa el ReadElementContentAsDateTime método para devolver el elemento como un DateTime objeto .

Entrada (hireDate.xml):

<employee xmlns="urn:empl-hire">
    <ID>12365</ID>
    <hire-date>2003-01-08</hire-date>
    <title>Accountant</title>
</employee>

Esquema (hireDate.xsd):

<?xml version="1.0"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="urn:empl-hire" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="employee">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="ID" type="xs:unsignedShort" />
        <xs:element name="hire-date" type="xs:date" />
        <xs:element name="title" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

Código:

// Create a validating XmlReader object. The schema
// provides the necessary type information.
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas.Add("urn:empl-hire", "hireDate.xsd");
using (XmlReader reader = XmlReader.Create("hireDate.xml", settings)) {

  // Move to the hire-date element.
  reader.MoveToContent();
  reader.ReadToDescendant("hire-date");

  // Return the hire-date as a DateTime object.
  DateTime hireDate = reader.ReadElementContentAsDateTime();
  Console.WriteLine("Six Month Review Date: {0}", hireDate.AddMonths(6));
}

' Create a validating XmlReader object. The schema 
' provides the necessary type information.
Dim settings As XmlReaderSettings = New XmlReaderSettings()
settings.ValidationType = ValidationType.Schema
settings.Schemas.Add("urn:empl-hire", "hireDate.xsd")
Using reader As XmlReader = XmlReader.Create("hireDate.xml", settings) 
  ' Move to the hire-date element.
  reader.MoveToContent()
  reader.ReadToDescendant("hire-date")

  ' Return the hire-date as a DateTime object.
  Dim hireDate As DateTime = reader.ReadElementContentAsDateTime()
  Console.WriteLine("Six Month Review Date: {0}", hireDate.AddMonths(6))
End Using

Salida:

Six Month Review Date:  7/8/2003 12:00:00 AM

Programación asincrónica

La mayoría de los XmlReader métodos tienen homólogos asincrónicos que tienen "Async" al final de sus nombres de método. Por ejemplo, el equivalente asincrónico de ReadContentAsObject es ReadContentAsObjectAsync.

Los métodos siguientes se pueden usar con llamadas de método asincrónicas:

En las secciones siguientes se describe el uso asincrónico de los métodos que no tienen homólogos asincrónicos.

método ReadStartElement

public static async Task ReadStartElementAsync(this XmlReader reader, string localname, string ns)
{
    if (await reader.MoveToContentAsync() != XmlNodeType.Element)
    {
        throw new InvalidOperationException(reader.NodeType.ToString() + " is an invalid XmlNodeType");
    }
    if ((reader.LocalName == localname) && (reader.NamespaceURI == ns))
    {
        await reader.ReadAsync();
    }
    else
    {
        throw new InvalidOperationException("localName or namespace doesn’t match");
    }
}

<Extension()>
Public Async Function ReadStartElementAsync(reader As XmlReader, localname As String, ns As String) As Task
    If (Await reader.MoveToContentAsync() <> XmlNodeType.Element) Then
        Throw New InvalidOperationException(reader.NodeType.ToString() + " is an invalid XmlNodeType")
    End If

    If ((reader.LocalName = localname) And (reader.NamespaceURI = ns)) Then
        Await reader.ReadAsync()
    Else
        Throw New InvalidOperationException("localName or namespace doesn’t match")
    End If
End Function

Método ReadEndElement

public static async Task ReadEndElementAsync(this XmlReader reader)
{
    if (await reader.MoveToContentAsync() != XmlNodeType.EndElement)
    {
        throw new InvalidOperationException();
    }
    await reader.ReadAsync();
}

<Extension()>
Public Async Function ReadEndElementAsync(reader As XmlReader) As task
    If (Await reader.MoveToContentAsync() <> XmlNodeType.EndElement) Then
        Throw New InvalidOperationException()
    End If
    Await reader.ReadAsync()
End Function

Método ReadToNextSibling

public static async Task<bool> ReadToNextSiblingAsync(this XmlReader reader, string localName, string namespaceURI)
{
    if (localName == null || localName.Length == 0)
    {
        throw new ArgumentException("localName is empty or null");
    }
    if (namespaceURI == null)
    {
        throw new ArgumentNullException("namespaceURI");
    }

    // atomize local name and namespace
    localName = reader.NameTable.Add(localName);
    namespaceURI = reader.NameTable.Add(namespaceURI);

    // find the next sibling
    XmlNodeType nt;
    do
    {
        await reader.SkipAsync();
        if (reader.ReadState != ReadState.Interactive)
            break;
        nt = reader.NodeType;
        if (nt == XmlNodeType.Element &&
             ((object)localName == (object)reader.LocalName) &&
             ((object)namespaceURI ==(object)reader.NamespaceURI))
        {
            return true;
        }
    } while (nt != XmlNodeType.EndElement && !reader.EOF);
    
    return false;
}

<Extension()>
Public Async Function ReadToNextSiblingAsync(reader As XmlReader, localName As String, namespaceURI As String) As Task(Of Boolean)
    If (localName = Nothing Or localName.Length = 0) Then
        Throw New ArgumentException("localName is empty or null")
    End If

    If (namespaceURI = Nothing) Then
        Throw New ArgumentNullException("namespaceURI")
    End If

    ' atomize local name and namespace
    localName = reader.NameTable.Add(localName)
    namespaceURI = reader.NameTable.Add(namespaceURI)

    ' find the next sibling
    Dim nt As XmlNodeType
    Do

        Await reader.SkipAsync()
        If (reader.ReadState <> ReadState.Interactive) Then
            Exit Do
        End If
        nt = reader.NodeType
        If ((nt = XmlNodeType.Element) And
           ((CObj(localName) = CObj(reader.LocalName))) And
           (CObj(namespaceURI) = CObj(reader.NamespaceURI))) Then
            Return True
        End If
    Loop While (nt <> XmlNodeType.EndElement And (Not reader.EOF))

    Return False

End Function

Método ReadToFollowing

public static async Task<bool> ReadToFollowingAsync(this XmlReader reader, string localName, string namespaceURI)
{
    if (localName == null || localName.Length == 0)
    {
        throw new ArgumentException("localName is empty or null");
    }
    if (namespaceURI == null)
    {
        throw new ArgumentNullException("namespaceURI");
    }

    // atomize local name and namespace
    localName = reader.NameTable.Add(localName);
    namespaceURI = reader.NameTable.Add(namespaceURI);

    // find element with that name
    while (await reader.ReadAsync())
    {
        if (reader.NodeType == XmlNodeType.Element && ((object)localName == (object)reader.LocalName) && ((object)namespaceURI == (object)reader.NamespaceURI))
        {
            return true;
        }
    }
    return false;
}

<Extension()>
Public Async Function ReadToFollowingAsync(reader As XmlReader, localName As String, namespaceURI As String) As Task(Of Boolean)
    If (localName = Nothing Or localName.Length = 0) Then
        Throw New ArgumentException("localName is empty or null")
    End If

    If (namespaceURI = Nothing) Then
        Throw New ArgumentNullException("namespaceURI")
    End If

    ' atomize local name and namespace
    localName = reader.NameTable.Add(localName)
    namespaceURI = reader.NameTable.Add(namespaceURI)

    ' find element with that name
    While (Await reader.ReadAsync())
        If ((reader.NodeType = XmlNodeType.Element) And
           (CObj(localName) = CObj(reader.LocalName)) And
           (CObj(namespaceURI) = CObj(reader.NamespaceURI))) Then
            Return True
        End If
    End While

    Return False
End Function

Método ReadToDescendant

public static async Task<bool> ReadToDescendantAsync(this XmlReader reader, string localName, string namespaceURI)
{
    if (localName == null || localName.Length == 0)
    {
        throw new ArgumentException("localName is empty or null");
    }
    if (namespaceURI == null)
    {
        throw new ArgumentNullException("namespaceURI");
    }
    // save the element or root depth
    int parentDepth = reader.Depth;
    if (reader.NodeType != XmlNodeType.Element)
    {
        // adjust the depth if we are on root node
        if (reader.ReadState == ReadState.Initial)
        {
            parentDepth--;
        }
        else
        {
            return false;
        }
    }
    else if (reader.IsEmptyElement)
    {
        return false;
    }

    // atomize local name and namespace
    localName = reader.NameTable.Add(localName);
    namespaceURI = reader.NameTable.Add(namespaceURI);

    // find the descendant
    while (await reader.ReadAsync() && reader.Depth > parentDepth)
    {
        if (reader.NodeType == XmlNodeType.Element && ((object)localName == (object)reader.LocalName) && ((object)namespaceURI == (object)reader.NamespaceURI))
        {
            return true;
        }
    }
    return false;
}

<Extension()>
Public Async Function ReadToDescendantAsync(reader As XmlReader, localName As String, namespaceURI As String) As Task(Of Boolean)
    If (localName = Nothing Or localName.Length = 0) Then
        Throw New ArgumentException("localName is empty or null")
    End If

    If (namespaceURI = Nothing) Then
        Throw New ArgumentNullException("namespaceURI")
    End If

    ' save the element or root depth
    Dim parentDepth As Integer = reader.Depth
    If (reader.NodeType <> XmlNodeType.Element) Then
        ' adjust the depth if we are on root node
        If (reader.ReadState = ReadState.Initial) Then
            parentDepth -= 1
        Else
            Return False
        End If
    ElseIf (reader.IsEmptyElement) Then
        Return False
    End If
    ' atomize local name and namespace
    localName = reader.NameTable.Add(localName)
    namespaceURI = reader.NameTable.Add(namespaceURI)

    ' find the descendant
    While (Await reader.ReadAsync() And reader.Depth > parentDepth)
        If (reader.NodeType = XmlNodeType.Element And
           (CObj(localName) = CObj(reader.LocalName)) And
           (CObj(namespaceURI) = CObj(reader.NamespaceURI))) Then
            Return True
        End If
    End While

    Return False
End Function

Consideraciones de seguridad

Tenga en cuenta lo siguiente al trabajar con la XmlReader clase :

Las excepciones producidas desde XmlReader pueden revelar información de ruta de acceso que es posible que no desee propagarse a la aplicación. La aplicación debe detectar excepciones y procesarlas correctamente.
No habilite el procesamiento de DTD si le preocupan los problemas de denegación de servicio o si está tratando con orígenes que no son de confianza. El procesamiento de DTD está deshabilitado de forma predeterminada para XmlReader los objetos creados por el Create método .

Si tiene habilitado el procesamiento de DTD, puede utilizar XmlSecureResolver para restringir los recursos a los que tiene acceso XmlReader. También puede diseñar la aplicación para que el procesamiento XML sea memoria y tiempo restringido. Por ejemplo, puede configurar límites de tiempo de espera en la aplicación de ASP.NET.
Los datos XML pueden incluir referencias a recursos externos como, por ejemplo, un archivo de esquemas. De forma predeterminada, los recursos externos se resuelven mediante un XmlUrlResolver objeto sin credenciales de usuario. Puede aumentar la protección aún más realizando cualquiera de las siguientes acciones:
- Restrinja los recursos a los que puede tener acceso XmlReader estableciendo la propiedad XmlReaderSettings.XmlResolver en un objeto XmlSecureResolver.
- No permita que XmlReader abra ningún recurso externo estableciendo la propiedad XmlReaderSettings.XmlResolver en null.
Las ProcessInlineSchema marcas de validación y ProcessSchemaLocation de un XmlReaderSettings objeto no se establecen de forma predeterminada. Esto ayuda a proteger el XmlReader contra ataques basados en esquemas cuando está procesando datos XML de un origen que no es de confianza. Cuando se establecen estas marcas, se utiliza el XmlResolver del objeto XmlReaderSettings para resolver las ubicaciones de esquemas que se encuentra en el documento de la instancia de XmlReader. Si la XmlResolver propiedad se establece nullen , las ubicaciones de esquema no se resuelven aunque se establezcan las ProcessInlineSchema marcas de validación y ProcessSchemaLocation .

Los esquemas agregados durante la validación agregan nuevos tipos y pueden cambiar el resultado de la validación del documento. Como consecuencia, los esquemas externos solo se deberían resolver desde orígenes de confianza.

Se recomienda deshabilitar la ProcessIdentityConstraints marca al validar documentos XML de gran tamaño en escenarios de alta disponibilidad en un esquema que tenga restricciones de identidad en una gran parte del documento. Esta marca está habilitada de forma predeterminada.
Los datos XML pueden contener un gran número de atributos, declaraciones de espacios de nombres, elementos anidados, etc. cuyo procesamiento tarda una cantidad de tiempo importante. Para limitar el tamaño de la entrada que se envía a XmlReader, puede:
- Limite el tamaño del documento estableciendo la MaxCharactersInDocument propiedad .
- Limite el número de caracteres resultantes de expandir entidades estableciendo la MaxCharactersFromEntities propiedad .
- Cree una implementación personalizada IStream para .XmlReader
El ReadValueChunk método se puede usar para controlar grandes flujos de datos. Este método lee una pequeña cantidad de caracteres a la vez en lugar de asignar una única cadena para todo el valor.
Al leer un documento XML con un gran número de nombres locales únicos, espacios de nombres o prefijos, se puede producir un problema. Si usa una clase que deriva de XmlReadery llama a la LocalNamepropiedad , Prefixo NamespaceURI para cada elemento, la cadena devuelta se agrega a .NameTable La colección que mantiene NameTable el nunca disminuye de tamaño, creando una fuga de memoria virtual de los identificadores de cadena. Una mitigación para esto es derivar de la NameTable clase y aplicar una cuota de tamaño máximo. (No hay ninguna manera de evitar el uso de , NameTableo para cambiar cuando NameTable está lleno). Otra mitigación es evitar el uso de las propiedades mencionadas y, en su lugar, usar el MoveToAttribute método con el IsStartElement método siempre que sea posible; esos métodos no devuelven cadenas y, por tanto, evitan el problema de sobrerrellenar la NameTable colección.
Los objetos XmlReaderSettings pueden contener información confidencial como, por ejemplo, credenciales de usuario. Un componente que no sea de confianza podría utilizar el objeto XmlReaderSettings y sus credenciales de usuario para crear objetos XmlReader para leer datos. Tenga cuidado al almacenar en caché XmlReaderSettings objetos o al pasar el XmlReaderSettings objeto de un componente a otro.
No admita componentes como, por ejemplo, objetos NameTable, XmlNamespaceManager y XmlResolver, de un origen que no sea de confianza.

Constructores

XmlReader()

Inicializa una nueva instancia de la clase XmlReader.

Propiedades

AttributeCount	Cuando se invalida en una clase derivada, obtiene el número de atributos en el nodo actual.
BaseURI	Cuando se invalida en una clase derivada, obtiene el identificador URI base del nodo actual.
CanReadBinaryContent	Obtiene un valor que indica si XmlReader implementa los métodos de lectura de contenido binario.
CanReadValueChunk	Obtiene un valor que indica si XmlReader implementa el método ReadValueChunk(Char[], Int32, Int32).
CanResolveEntity	Obtiene un valor que indica si este lector puede analizar y resolver entidades.
Depth	Cuando se invalida en una clase derivada, obtiene la profundidad del nodo actual en el documento XML.
EOF	Cuando se invalida en una clase derivada, obtiene un valor que indica si el lector está situado al final del flujo.
HasAttributes	Obtiene un valor que indica si el nodo actual tiene algún atributo.
HasValue	Cuando se invalida en una clase derivada, obtiene un valor que indica si el nodo actual puede tener una propiedad Value.
IsDefault	Cuando se reemplaza en una clase derivada, obtiene un valor que indica si el nodo actual es un atributo generado a partir del valor predeterminado definido en la DTD o el esquema.
IsEmptyElement	Cuando se reemplaza en una clase derivada, obtiene un valor que indica si el nodo actual es un elemento vacío (por ejemplo, `<MyElement/>`).
Item[Int32]	Cuando se invalida en una clase derivada, obtiene el valor del atributo con el índice especificado.
Item[String, String]	Cuando se invalida en una clase derivada, obtiene el valor del atributo con las propiedades LocalName y NamespaceURI especificadas.
Item[String]	Cuando se invalida en una clase derivada, obtiene el valor del atributo con la propiedad Name especificada.
LocalName	Cuando se invalida en una clase derivada, obtiene el nombre local del nodo actual.
Name	Cuando se invalida en una clase derivada, obtiene el nombre completo del nodo actual.
NamespaceURI	Cuando se invalida en una clase derivada, obtiene el identificador URI de espacio de nombres (según se define en la especificación relativa a espacios de nombres del Consorcio W3C) del nodo en el que está situado el lector.
NameTable	Cuando se invalida en una clase derivada, obtiene el objeto XmlNameTable que está asociado a esta implementación.
NodeType	Cuando se invalida en una clase derivada, obtiene el tipo del nodo actual.
Prefix	Cuando se invalida en una clase derivada, obtiene el prefijo de espacio de nombres asociado al nodo actual.
QuoteChar	Cuando se reemplaza en una clase derivada, obtiene el carácter de comillas entre las que se encierra el valor de un nodo de atributo.
ReadState	Cuando se invalida en una clase derivada, obtiene el estado del lector.
SchemaInfo	Obtiene la información de esquema asignada al nodo actual como resultado de la validación del esquema.
Settings	Obtiene el objeto XmlReaderSettings que se usa para crear esta instancia de XmlReader.
Value	Cuando se invalida en una clase derivada, obtiene el valor de texto del nodo actual.
ValueType	Obtiene el tipo de Common Language Runtime (CLR) del nodo actual.
XmlLang	Cuando se invalida en una clase derivada, obtiene el ámbito de `xml:lang` actual.
XmlSpace	Cuando se invalida en una clase derivada, obtiene el ámbito de `xml:space` actual.

Métodos

Close()	Cuando se invalida en una clase derivada, cambia ReadState a Closed.
Create(Stream)	Crea una nueva instancia XmlReader mediante el flujo especificado con la configuración predeterminada.
Create(Stream, XmlReaderSettings)	Crea una nueva instancia de XmlReader con el flujo y la configuración especificados.
Create(Stream, XmlReaderSettings, String)	Crea una nueva instancia de XmlReader usando el flujo, el URI base y la configuración especificados.
Create(Stream, XmlReaderSettings, XmlParserContext)	Crea una nueva instancia XmlReader con el flujo, la configuración y la información de contexto especificados para el análisis.
Create(String)	Crea una nueva instancia de XmlReader con el URI especificado.
Create(String, XmlReaderSettings)	Crea una nueva instancia de XmlReader usando el URI y la configuración especificados.
Create(String, XmlReaderSettings, XmlParserContext)	Crea una nueva instancia de XmlReader usando el URI, la configuración y la información de contexto especificados.
Create(TextReader)	Crea una nueva instancia de XmlReader mediante el lector de texto especificado.
Create(TextReader, XmlReaderSettings)	Crea una nueva instancia XmlReader usando el lector de texto y la configuración especificados.
Create(TextReader, XmlReaderSettings, String)	Crea una nueva instancia de XmlReader mediante el lector de texto, la configuración y el URI base especificados.
Create(TextReader, XmlReaderSettings, XmlParserContext)	Crea una nueva instancia de XmlReader con el lector de texto, la configuración y la información de contexto especificados para el análisis.
Create(XmlReader, XmlReaderSettings)	Crea una nueva instancia de XmlReader con el lector XML y la configuración especificados.
Dispose()	Libera todos los recursos usados por la instancia actual de la clase XmlReader.
Dispose(Boolean)	Libera los recursos no administrados que usa XmlReader y, de forma opcional, libera los recursos administrados.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetAttribute(Int32)	Cuando se invalida en una clase derivada, obtiene el valor del atributo con el índice especificado.
GetAttribute(String)	Cuando se invalida en una clase derivada, obtiene el valor del atributo con la propiedad Name especificada.
GetAttribute(String, String)	Cuando se invalida en una clase derivada, obtiene el valor del atributo con las propiedades LocalName y NamespaceURI especificadas.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
GetValueAsync()	Obtiene de forma asincrónica el valor del nodo actual.
IsName(String)	Devuelve un valor que indica si el argumento de cadena es un nombre XML válido.
IsNameToken(String)	Devuelve un valor que indica si el argumento de cadena es un token de nombre XML válido.
IsStartElement()	Llama al método MoveToContent() y comprueba si el nodo de contenido actual es una etiqueta de apertura o una etiqueta de elemento vacío.
IsStartElement(String)	Llama al método MoveToContent() y comprueba si el nodo de contenido actual es una etiqueta de apertura o una etiqueta de elemento vacío y si la propiedad Name del elemento encontrado coincide con el argumento especificado.
IsStartElement(String, String)	Llama al método MoveToContent() y comprueba si el nodo de contenido actual es una etiqueta de apertura o una etiqueta de elemento vacío y si las propiedades LocalName y NamespaceURI del elemento encontrado coinciden con las cadenas especificadas.
LookupNamespace(String)	Cuando se invalida en una clase derivada, resuelve un prefijo de espacio de nombres en el ámbito del elemento actual.
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
MoveToAttribute(Int32)	Cuando se invalida en una clase derivada, se desplaza al atributo con el índice especificado.
MoveToAttribute(String)	Cuando se invalida en una clase derivada, se desplaza al atributo con la propiedad Name especificada.
MoveToAttribute(String, String)	Cuando se invalida en una clase derivada, se desplaza al atributo con las propiedades LocalName y NamespaceURI especificadas.
MoveToContent()	Comprueba si el nodo actual es un nodo de contenido (texto sin espacios en blanco, `CDATA`, `Element`, `EndElement`, `EntityReference` o `EndEntity`). Si el nodo no es un nodo de contenido, el lector salta hasta el siguiente nodo de contenido o el final del archivo. Omite los siguientes tipos de nodo: `ProcessingInstruction`, `DocumentType`, `Comment`, `Whitespace` o `SignificantWhitespace`.
MoveToContentAsync()	De forma asincrónica comprueba si el nodo actual es un nodo de contenido. Si el nodo no es un nodo de contenido, el lector salta hasta el siguiente nodo de contenido o el final del archivo.
MoveToElement()	Cuando se invalida en una clase derivada, se desplaza al elemento que contiene el nodo de atributo actual.
MoveToFirstAttribute()	Cuando se invalida en una clase derivada, se desplaza hasta el primer atributo.
MoveToNextAttribute()	Cuando se invalida en una clase derivada, se desplaza hasta el siguiente atributo.
Read()	Cuando se invalida en una clase derivada, lee el siguiente nodo del flujo.
ReadAsync()	De forma asincrónica lee el nodo siguiente del flujo.
ReadAttributeValue()	Cuando se invalida en una clase derivada, analiza el valor de atributo en uno o varios nodos `Text`, `EntityReference` o `EndEntity`.
ReadContentAs(Type, IXmlNamespaceResolver)	Lee el contenido como objeto del tipo especificado.
ReadContentAsAsync(Type, IXmlNamespaceResolver)	Lee asincrónicamente el contenido como objeto del tipo especificado.
ReadContentAsBase64(Byte[], Int32, Int32)	Lee el contenido y devuelve los bytes binarios descodificados en Base64.
ReadContentAsBase64Async(Byte[], Int32, Int32)	Lee asincrónicamente el contenido y devuelve los bytes binarios descodificados en Base64.
ReadContentAsBinHex(Byte[], Int32, Int32)	Lee el contenido y devuelve los bytes binarios descodificados de `BinHex`.
ReadContentAsBinHexAsync(Byte[], Int32, Int32)	Lee asincrónicamente el contenido y devuelve los bytes binarios descodificados de `BinHex`.
ReadContentAsBoolean()	Lee el contenido de texto en la posición actual como valor `Boolean`.
ReadContentAsDateTime()	Lee el contenido de texto en la posición actual como un objeto DateTime.
ReadContentAsDateTimeOffset()	Lee el contenido de texto en la posición actual como un objeto DateTimeOffset.
ReadContentAsDecimal()	Lee el contenido de texto en la posición actual como un objeto Decimal.
ReadContentAsDouble()	Lee el contenido de texto en la posición actual como número de punto flotante de precisión doble.
ReadContentAsFloat()	Lee el contenido de texto en la posición actual como número de punto flotante de precisión sencilla.
ReadContentAsInt()	Lee el contenido de texto en la posición actual como un entero de 32 bits con signo.
ReadContentAsLong()	Lee el contenido de texto en la posición actual como un entero de 64 bits con signo.
ReadContentAsObject()	Lee el contenido de texto en la posición actual como Object.
ReadContentAsObjectAsync()	Lee asincrónicamente el contenido de texto en la posición actual como un objeto Object.
ReadContentAsString()	Lee el contenido de texto en la posición actual como un objeto String.
ReadContentAsStringAsync()	Lee asincrónicamente el contenido de texto en la posición actual como un objeto String.
ReadElementContentAs(Type, IXmlNamespaceResolver)	Lee el contenido de los elementos como el tipo solicitado.
ReadElementContentAs(Type, IXmlNamespaceResolver, String, String)	Comprueba que el nombre local especificado y el URI de espacio de nombres coinciden con los del elemento actual y, a continuación, lee el contenido de los elementos como el tipo solicitado.
ReadElementContentAsAsync(Type, IXmlNamespaceResolver)	Lee asincrónicamente el contenido del elemento como el tipo solicitado.
ReadElementContentAsBase64(Byte[], Int32, Int32)	Lee el elemento y descodifica el contenido de `Base64`.
ReadElementContentAsBase64Async(Byte[], Int32, Int32)	Lee asincrónicamente el elemento y descodifica el contenido de `Base64`.
ReadElementContentAsBinHex(Byte[], Int32, Int32)	Lee el elemento y descodifica el contenido de `BinHex`.
ReadElementContentAsBinHexAsync(Byte[], Int32, Int32)	Lee asincrónicamente el elemento y descodifica el contenido de `BinHex`.
ReadElementContentAsBoolean()	Lee el elemento actual y devuelve el contenido como un objeto Boolean.
ReadElementContentAsBoolean(String, String)	Comprueba que el nombre local especificado y el URI del espacio de nombres coinciden con los del elemento actual y, a continuación, lee este elemento y devuelve el contenido como objeto Boolean.
ReadElementContentAsDateTime()	Lee el elemento actual y devuelve el contenido como un objeto DateTime.
ReadElementContentAsDateTime(String, String)	Comprueba que el nombre local especificado y el URI del espacio de nombres coinciden con los del elemento actual y, a continuación, lee este elemento y devuelve el contenido como objeto DateTime.
ReadElementContentAsDecimal()	Lee el elemento actual y devuelve el contenido como un objeto Decimal.
ReadElementContentAsDecimal(String, String)	Comprueba que el nombre local especificado y el URI del espacio de nombres coinciden con los del elemento actual y, a continuación, lee este elemento y devuelve el contenido como objeto Decimal.
ReadElementContentAsDouble()	Lee el elemento actual y devuelve el contenido como número de punto flotante de precisión doble.
ReadElementContentAsDouble(String, String)	Comprueba que el nombre local especificado y el URI del espacio de nombres coinciden con los del elemento actual y, a continuación, lee este elemento y devuelve el contenido como número de punto flotante de precisión doble.
ReadElementContentAsFloat()	Lee el elemento actual y devuelve el contenido como número de punto flotante de precisión sencilla.
ReadElementContentAsFloat(String, String)	Comprueba que el nombre local especificado y el URI del espacio de nombres coinciden con los del elemento actual y, a continuación, lee este elemento y devuelve el contenido como número de punto flotante de precisión sencilla.
ReadElementContentAsInt()	Lee el elemento actual y devuelve el contenido como un entero de 32 bits con signo.
ReadElementContentAsInt(String, String)	Comprueba que el nombre local especificado y el URI del espacio de nombres coinciden con los del elemento actual y, a continuación, lee el elemento actual y devuelve el contenido como entero de 32 bits con signo.
ReadElementContentAsLong()	Lee el elemento actual y devuelve el contenido como entero de 64 bits con signo.
ReadElementContentAsLong(String, String)	Comprueba que el nombre local y el identificador URI del espacio de nombres especificados coinciden con los del elemento actual, luego lee el elemento actual y devuelve el contenido como entero de 64 bits con signo.
ReadElementContentAsObject()	Lee el elemento actual y devuelve el contenido como objeto Object.
ReadElementContentAsObject(String, String)	Comprueba que el nombre local especificado y el URI del espacio de nombres coinciden con los del elemento actual y, a continuación, lee este elemento y devuelve el contenido como objeto Object.
ReadElementContentAsObjectAsync()	Lee asincrónicamente el elemento actual y devuelve el contenido como objeto Object.
ReadElementContentAsString()	Lee el elemento actual y devuelve el contenido como un objeto String.
ReadElementContentAsString(String, String)	Comprueba que el nombre local especificado y el URI del espacio de nombres coinciden con los del elemento actual y, a continuación, lee este elemento y devuelve el contenido como objeto String.
ReadElementContentAsStringAsync()	Lee asincrónicamente el elemento actual y devuelve el contenido como un objeto String.
ReadElementString()	Lee un elemento de solo texto. Sin embargo, se recomienda usar el método ReadElementContentAsString() en su lugar, porque proporciona una manera más sencilla de controlar esta operación.
ReadElementString(String)	Comprueba si la propiedad Name del elemento encontrado coincide con la cadena especificada antes de leer un elemento de sólo texto. Sin embargo, se recomienda usar el método ReadElementContentAsString() en su lugar, porque proporciona una manera más sencilla de controlar esta operación.
ReadElementString(String, String)	Comprueba si las propiedades LocalName y NamespaceURI del elemento encontrado coinciden con las cadenas especificadas antes de leer un elemento de sólo texto. Sin embargo, se recomienda usar el método ReadElementContentAsString(String, String) en su lugar, porque proporciona una manera más sencilla de controlar esta operación.
ReadEndElement()	Comprueba si el nodo de contenido actual es una etiqueta de cierre y desplaza el lector hasta el siguiente nodo.
ReadInnerXml()	Cuando se invalida en una clase derivada, lee todo el contenido, incluido el marcado, como una cadena.
ReadInnerXmlAsync()	De forma asincrónica lee todo el contenido, incluido el marcado, como una cadena.
ReadOuterXml()	Cuando se invalida en una clase derivada, lee el contenido, incluido el marcado, que representa este nodo y todos sus nodos secundarios.
ReadOuterXmlAsync()	De forma asincrónica lee el contenido, incluido el marcado, que representa este nodo y todos sus elementos secundarios.
ReadStartElement()	Comprueba si el nodo actual es un elemento y hace avanzar el sistema de lectura hasta el siguiente nodo.
ReadStartElement(String)	Comprueba si el nodo de contenido actual es un elemento con la propiedad Name especificada y desplaza el lector hasta el siguiente nodo.
ReadStartElement(String, String)	Comprueba si el nodo de contenido actual es un elemento con las propiedades LocalName y NamespaceURI especificadas y desplaza el lector hasta el siguiente nodo.
ReadString()	Cuando se reemplaza en una clase derivada, lee el contenido de un nodo de elemento o de texto como una cadena. Sin embargo, se recomienda usar el método ReadElementContentAsString en su lugar, porque proporciona una manera más sencilla de controlar esta operación.
ReadSubtree()	Devuelve una nueva instancia de `XmlReader` que se puede utilizar para leer el nodo actual y todos sus descendientes.
ReadToDescendant(String)	Hace avanzar el objeto XmlReader hasta al siguiente elemento descendiente con el nombre completo especificado.
ReadToDescendant(String, String)	Hace avanzar el objeto XmlReader hasta el siguiente elemento descendiente que tenga el URI de espacio de nombres y el nombre local especificados.
ReadToFollowing(String)	Lee hasta que encuentra un elemento con el nombre completo especificado.
ReadToFollowing(String, String)	Lee hasta que encuentra un elemento con el nombre local y el URI de espacio de nombres especificados.
ReadToNextSibling(String)	Hace avanzar el objeto `XmlReader` hasta al siguiente elemento relacionado con el nombre completo especificado.
ReadToNextSibling(String, String)	Hace avanzar el objeto `XmlReader` al siguiente elemento del mismo nivel que tenga el URI del espacio de nombres y el nombre local especificados.
ReadValueChunk(Char[], Int32, Int32)	Lee grandes secuencias de texto incrustadas en un documento XML.
ReadValueChunkAsync(Char[], Int32, Int32)	Lee asincrónicamente grandes secuencias de texto incrustadas en un documento XML.
ResolveEntity()	Cuando se invalida en una clase derivada, resuelve la referencia a entidad para los nodos `EntityReference`.
Skip()	Omite los nodos secundarios del nodo actual.
SkipAsync()	Omite de forma asincrónica los elementos secundarios del valor del nodo actual.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Implementaciones de interfaz explícitas

IDisposable.Dispose()

Para obtener una descripción de este miembro, vea Dispose().

Se aplica a

Consulte también

Documentos y datos XML