XmlReader Clase

Definición

Representa un lector que proporciona acceso rápido a datos XML, sin almacenamiento en caché y con desplazamiento solo hacia delante.Represents a reader that provides fast, noncached, forward-only access to XML data.

public ref class XmlReader abstract : IDisposable
public abstract class XmlReader : IDisposable
type XmlReader = class
    interface IDisposable
Public MustInherit Class XmlReader
Implements IDisposable
Herencia
XmlReader
Derivado
Implementaciones

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar la API asincrónica para analizar XML.The following example code shows how to use the asynchronous API to parse 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 una secuencia.XmlReader provides forward-only, read-only access to XML data in a document or stream. Esta clase se ajusta a la lenguaje de marcado extensible W3C (XML) 1,0 (cuarta edición) y los espacios de nombres en las recomendaciones XML 1,0 (tercera edición) .This class conforms to the W3C Extensible Markup Language (XML) 1.0 (fourth edition) and the Namespaces in XML 1.0 (third edition) recommendations.

XmlReader métodos permiten desplazarse por los datos XML y leer el contenido de un nodo.XmlReader methods let you move through XML data and read the contents of a node. Las propiedades de la clase reflejan el valor del nodo actual, que es donde se coloca el lector. El valor de la propiedad ReadState indica el estado actual del lector XML.The properties of the class reflect the value of the current node, which is where the reader is positioned.The ReadState property value indicates the current state of the XML reader. Por ejemplo, la propiedad se establece en ReadState.Initial por el método XmlReader.Read y ReadState.Closed por el método XmlReader.Close.For example, the property is set to ReadState.Initial by the XmlReader.Read method and ReadState.Closed by the XmlReader.Close method. XmlReader también proporciona comprobaciones de cumplimiento de datos y validación en una DTD o un esquema.XmlReader also provides data conformance checks and validation against a DTD or schema.

XmlReader usa un modelo de extracción para recuperar los datos.XmlReader uses a pull model to retrieve data. Este modelo:This model:

  • Simplifica la administración de Estados mediante un perfeccionamiento natural y de arriba abajo.Simplifies state management by a natural, top-down procedural refinement.

  • Admite varios flujos de entrada y capas.Supports multiple input streams and layering.

  • Permite al cliente proporcionar al analizador un búfer en el que se escribe la cadena directamente y, por tanto, evita la necesidad de una copia de cadena adicional.Enables the client to give the parser a buffer into which the string is directly written, and thus avoids the necessity of an extra string copy.

  • Admite el procesamiento selectivo.Supports selective processing. El cliente puede omitir elementos y procesar los que son de interés para la aplicación.The client can skip items and process those that are of interest to the application. También puede establecer las propiedades de antemano para administrar cómo se procesa la secuencia XML (por ejemplo, la normalización).You can also set properties in advance to manage how the XML stream is processed (for example, normalization).

En esta sección:In this section:

Crear un lector XML Creating an XML reader
Validar de datos XMLValidating XML data
de cumplimiento de datosData conformance
Desplazarse por los nodos Navigating through nodes
Leer elementos XML Reading XML elements
Leer atributos XML Reading XML attributes
Leer de contenido XMLReading XML content
Convertir a tipos CLR Converting to CLR types
de programación asincrónicaAsynchronous programming
Consideraciones de seguridadSecurity considerations

Crear un lector XMLCreating an XML reader

Utilice el método Create para crear una instancia de XmlReader.Use the Create method to create an XmlReader instance.

Aunque el .NET Framework proporciona implementaciones concretas de la clase XmlReader, como las clases XmlTextReader, XmlNodeReadery XmlValidatingReader, se recomienda usar las clases especializadas solo en estos escenarios:Although the .NET Framework provides concrete implementations of the XmlReader class, such as the XmlTextReader, XmlNodeReader, and the XmlValidatingReader classes, we recommend that you use the specialized classes only in these scenarios:

  • Si desea leer un subárbol DOM XML de un objeto XmlNode, utilice la clase XmlNodeReader.When you want to read an XML DOM subtree from an XmlNode object, use the XmlNodeReader class. (Sin embargo, esta clase no admite la validación de DTD o esquema).(However, this class doesn't support DTD or schema validation.)

  • Si debe expandir entidades en la solicitud, no desea normalizar el contenido de texto o no desea que se devuelvan los atributos predeterminados, utilice la clase XmlTextReader.If you must expand entities on request, you don't want your text content normalized, or you don't want default attributes returned, use the XmlTextReader class.

Para especificar el conjunto de características que desea habilitar en el lector XML, pase un objeto System.Xml.XmlReaderSettings al método Create.To specify the set of features you want to enable on the XML reader, pass an System.Xml.XmlReaderSettings object to the Create method. Puede usar un solo System.Xml.XmlReaderSettings objeto para crear varios lectores con la misma funcionalidad, o modificar el objeto de System.Xml.XmlReaderSettings para crear un nuevo lector con un conjunto de características diferente.You can use a single System.Xml.XmlReaderSettings object to create multiple readers with the same functionality, or modify the System.Xml.XmlReaderSettings object to create a new reader with a different set of features. También puede agregar fácilmente características a un lector existente.You can also easily add features to an existing reader.

Si no utiliza un objeto de System.Xml.XmlReaderSettings, se utiliza la configuración predeterminada.If you don't use a System.Xml.XmlReaderSettings object, default settings are used. Consulte la página de referencia de Create para obtener más información.See the Create reference page for details.

XmlReader produce un XmlException en los errores de análisis de XML.XmlReader throws an XmlException on XML parse errors. Una vez que se produce una excepción, el estado del lector no es predecible.After an exception is thrown, the state of the reader is not predictable. Por ejemplo, el tipo de nodo indicado puede ser diferente del tipo de nodo real del nodo actual.For example, the reported node type may be different from the actual node type of the current node. Use la propiedad ReadState para comprobar si el lector está en estado de error.Use the ReadState property to check whether the reader is in error state.

Validar datos XMLValidating XML data

Para definir la estructura de un documento XML y sus relaciones de elementos, tipos de datos y restricciones de contenido, se utiliza una definición de tipo de documento (DTD) o un esquema del lenguaje de definición de esquemas XML (XSD).To define the structure of an XML document and its element relationships, data types, and content constraints, you use a document type definition (DTD) or XML Schema definition language (XSD) schema. Se considera que un documento XML es correcto si cumple todos los requisitos sintácticos definidos por la recomendación XML 1,0 de W3C.An XML document is considered to be well formed if it meets all the syntactical requirements defined by the W3C XML 1.0 Recommendation. Se considera válido si tiene el formato correcto y también se ajusta a las restricciones definidas por su DTD o esquema.It's considered valid if it's well formed and also conforms to the constraints defined by its DTD or schema. (Vea la parte 1 del esquema XML del consorcio W3C y las recomendaciones del W3C XML Schema Part 2: Datatypes ). Por lo tanto, aunque todos los documentos XML válidos sean correctos, no todos los documentos XML correctos son válidos.(See the W3C XML Schema Part 1: Structures and the W3C XML Schema Part 2: Datatypes recommendations.) Therefore, although all valid XML documents are well formed, not all well-formed XML documents are valid.

Puede validar los datos con una DTD, un esquema XSD insertado o un esquema XSD almacenado en un objeto XmlSchemaSet (una memoria caché); estos escenarios se describen en la página de referencia de Create.You can validate the data against a DTD, an inline XSD Schema, or an XSD Schema stored in an XmlSchemaSet object (a cache); these scenarios are described on the Create reference page. XmlReader no admite la validación de esquemas reducidos de datos XML (XDR).XmlReader doesn't support XML-Data Reduced (XDR) schema validation.

Utilice la siguiente configuración en la clase XmlReaderSettings para especificar qué tipo de validación es compatible con la instancia de XmlReader.You use the following settings on the XmlReaderSettings class to specify what type of validation, if any, the XmlReader instance supports.

Usar este miembro de XmlReaderSettingsUse this XmlReaderSettings member Para especificarTo specify
PropiedadDtdProcessingDtdProcessing property Indica si se va a permitir el procesamiento de DTD.Whether to allow DTD processing. El valor predeterminado es no permitir el procesamiento de DTD.The default is to disallow DTD processing.
PropiedadValidationTypeValidationType property Si el lector debe validar los datos y qué tipo de validación se va a realizar (DTD o esquema).Whether the reader should validate data, and what type of validation to perform (DTD or schema). El valor predeterminado es que no hay validación de datos.The default is no data validation.
EventoValidationEventHandlerValidationEventHandler event Un controlador de eventos para recibir información acerca de los eventos de validación.An event handler for receiving information about validation events. Si no se proporciona un controlador de eventos, se inicia una XmlException en el primer error de validación.If an event handler is not provided, an XmlException is thrown on the first validation error.
PropiedadValidationFlagsValidationFlags property Opciones de validación adicionales a través de los miembros de enumeración de XmlSchemaValidationFlags:Additional validation options through the XmlSchemaValidationFlags enumeration members:

- AllowXmlAttributes: permite atributos XML (xml:*) en documentos de instancia aunque no estén definidos en el esquema.- AllowXmlAttributes-- Allow XML attributes (xml:*) in instance documents even when they're not defined in the schema. Los atributos se validan basándose en su tipo de datos.The attributes are validated based on their data type. Vea la página de referencia de XmlSchemaValidationFlags para ver la configuración que se va a usar en escenarios específicos.See the XmlSchemaValidationFlags reference page for the setting to use in specific scenarios. (Deshabilitada de forma predeterminada).(Disabled by default.)
- ProcessIdentityConstraints--procesa las restricciones de identidad (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) detectadas durante la validación.- ProcessIdentityConstraints --Process identity constraints (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) encountered during validation. (Habilitado de forma predeterminada).(Enabled by default.)
- ProcessSchemaLocation: esquemas de proceso especificados por el atributo xsi:schemaLocation o xsi:noNamespaceSchemaLocation.- ProcessSchemaLocation --Process schemas specified by the xsi:schemaLocation or xsi:noNamespaceSchemaLocation attribute. (Habilitado de forma predeterminada).(Enabled by default.)
- ProcessInlineSchema: procesar esquemas XML en línea durante la validación.- ProcessInlineSchema-- Process inline XML Schemas during validation. (Deshabilitada de forma predeterminada).(Disabled by default.)
- ReportValidationWarnings--eventos de informe si se produce una advertencia de validación.- ReportValidationWarnings--Report events if a validation warning occurs. Normalmente se produce una advertencia cuando no hay ninguna DTD ni esquema XML para validar un elemento o atributo en particular.A warning is typically issued when there is no DTD or XML Schema to validate a particular element or attribute against. ValidationEventHandler se utiliza para las notificaciones.The ValidationEventHandler is used for notification. (Deshabilitada de forma predeterminada).(Disabled by default.)
Schemas XmlSchemaSet que se va a usar para validación.The XmlSchemaSet to use for validation.
PropiedadXmlResolverXmlResolver property El XmlResolver para resolver y tener acceso a recursos externos.The XmlResolver for resolving and accessing external resources. Esto puede incluir entidades externas como DTD y esquemas, y cualquier elemento xs:include o xs:import incluido en el esquema XML.This can include external entities such as DTD and schemas, and any xs:include or xs:import elements contained in the XML Schema. Si no especifica un XmlResolver, el XmlReader usa un XmlUrlResolver predeterminado sin credenciales de usuario.If you don't specify an XmlResolver, the XmlReader uses a default XmlUrlResolver with no user credentials.

Cumplimiento de datosData conformance

Los lectores XML creados por el método Create cumplen los siguientes requisitos de compatibilidad de forma predeterminada:XML readers that are created by the Create method meet the following compliance requirements by default:

  • Las nuevas líneas y el valor del atributo se normalizan según la recomendación XML 1,0del consorcio W3C.New lines and attribute value are normalized according to the W3C XML 1.0 Recommendation.

  • Todas las entidades se expanden automáticamente.All entities are automatically expanded.

  • Los atributos predeterminados que se declaran en la definición de tipo de documento siempre se agregan incluso cuando el lector no se valida.Default attributes declared in the document type definition are always added even when the reader doesn't validate.

  • Se permite la declaración del prefijo XML asignado al URI de espacio de nombres XML correcto.Declaration of XML prefix mapped to the correct XML namespace URI is allowed.

  • Los nombres de notación en una única declaración de atributo de NotationType y NmTokens en una única declaración de atributo de Enumeration son distintos.The notation names in a single NotationType attribute declaration and NmTokens in a single Enumeration attribute declaration are distinct.

Use estas propiedades de XmlReaderSettings para especificar el tipo de comprobaciones de conformidad que desea habilitar:Use these XmlReaderSettings properties to specify the type of conformance checks you want to enable:

Usar esta propiedad de XmlReaderSettingsUse this XmlReaderSettings property EnTo DefaultDefault
PropiedadCheckCharactersCheckCharacters property Habilitar o deshabilitar comprobaciones para lo siguiente:Enable or disable checks for the following:

-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 XML 1,0 del consorcio W3C.- Characters are within the range of legal XML characters, as defined by the 2.2 Characters section of the W3C XML 1.0 Recommendation.
-Todos los nombres XML son válidos, tal y como se define en la sección 2,3 construcciones sintácticas comunes de la recomendación XML 1,0 del W3C.- All XML names are valid, as defined by the 2.3 Common Syntactic Constructs section of the W3C XML 1.0 Recommendation.

Cuando esta propiedad se establece en true (valor predeterminado), se produce una excepción de XmlException si el archivo XML contiene caracteres no válidos o nombres XML no válidos (por ejemplo, un nombre de elemento empieza por un número).When this property is set to true (default), an XmlException exception is thrown if the XML file contains illegal characters or invalid XML names (for example, an element name starts with a number).
La comprobación de caracteres y nombres está habilitada.Character and name checking is enabled.

Al establecer la propiedad CheckCharacters en false, se desactiva la comprobación de caracteres en las referencias a entidades de caracteres.Setting CheckCharacters to false turns off character checking for character entity references. Si el lector está procesando datos de texto, siempre comprueba que los nombres XML sean válidos, independientemente de esta configuración.If the reader is processing text data, it always checks that XML names are valid, regardless of this setting. Nota: La recomendación XML 1,0 requiere la conformidad de nivel de documento cuando hay una DTD.Note: The XML 1.0 recommendation requires document-level conformance when a DTD is present. 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.Therefore, if the reader is configured to support ConformanceLevel.Fragment, but the XML data contains a document type definition (DTD), an XmlException is thrown.
PropiedadConformanceLevelConformanceLevel property Elija el nivel de cumplimiento que se va a aplicar:Choose the level of conformance to enforce:

- Document.- Document. Cumple las reglas de un documento XML 1,0correcto.Conforms to the rules for a well-formed XML 1.0 document.
- Fragment.- Fragment. Se ajusta a las reglas de un fragmento de documento bien formado que se puede usar como una entidad analizada externa.Conforms to the rules for a well-formed document fragment that can be consumed as an external parsed entity.
- Auto.- Auto. Se ajusta al nivel decidido por el lector.Conforms to the level decided by the reader.

Si los datos no están en cumplimiento, se produce una excepción XmlException.If the data isn't in conformance, an XmlException exception is thrown.
Document

El nodo actual es el nodo XML en el que está situado actualmente el lector XML.The current node is the XML node on which the XML reader is currently positioned. Todos los métodos de XmlReader realizan operaciones con respecto a este nodo y todas las propiedades de XmlReader reflejan el valor del nodo actual.All XmlReader methods perform operations in relation to this node, and all XmlReader properties reflect the value of the current node.

Los métodos siguientes permiten desplazarse fácilmente por los nodos y analizar los datos.The following methods make it easy to navigate through nodes and parse data.

Usar este método XmlReaderSettingsUse this XmlReaderSettings method EnTo
Read Leer el primer nodo y avanzar a través de la secuencia en un nodo cada vez.Read the first node, and advance through the stream one node at a time. Estas llamadas se realizan normalmente dentro de un bucle while.Such calls are typically performed inside a while loop.

Use la propiedad NodeType para obtener el tipo (por ejemplo, Attribute, comment, Element, etc.) del nodo actual.Use the NodeType property to get the type (for example, attribute, comment, element, and so on) of the current node.
Skip Omitir los elementos secundarios del nodo actual y desplace al siguiente nodo.Skip the children of the current node and move to the next node.
MoveToContent y MoveToContentAsyncMoveToContent and MoveToContentAsync Omitir los nodos que no son de contenido y desplace al siguiente nodo de contenido o al final del archivo.Skip non-content nodes and move to the next content node or to the end of the file.

Entre los nodos que no son de contenido se incluyen ProcessingInstruction, DocumentType, Comment, Whitespacey SignificantWhitespace.Non-content nodes include ProcessingInstruction, DocumentType, Comment, Whitespace, and SignificantWhitespace.

Los nodos de contenido incluyen texto que no es un espacio en blanco, CDATA, EntityReference y EndEntity.Content nodes include non-white space text, CDATA, EntityReference , and EndEntity.
ReadSubtree Lee un elemento y todos sus elementos secundarios, y devuelve una nueva instancia de XmlReader establecida en ReadState.Initial.Read an element and all its children, and return a new XmlReader instance set to ReadState.Initial.

Este método es útil para crear límites alrededor de los 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 tener acceso el componente.This method is useful for creating boundaries around XML elements; for example, if you want to pass data to another component for processing and you want to limit how much of your data the component can access.

Vea la página de referencia de XmlReader.Read para ver un ejemplo de Cómo desplazarse por un flujo de texto un nodo cada vez y mostrar el tipo de cada nodo.See the XmlReader.Read reference page for an example of navigating through a text stream one node at a time and displaying the type of each node.

En las secciones siguientes se describe cómo puede leer tipos específicos de datos, como elementos, atributos y datos con tipo.The following sections describe how you can read specific types of data, such as elements, attributes, and typed data.

Leer elementos XMLReading XML elements

En la tabla siguiente se enumeran los métodos y las propiedades que proporciona la clase XmlReader para procesar los elementos.The following table lists the methods and properties that the XmlReader class provides for processing elements. Después de que XmlReader se sitúe en un elemento, las propiedades del nodo como, por ejemplo, Name, reflejan los valores del elemento.After the XmlReader is positioned on an element, the node properties, such as Name, reflect the element values. 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.In addition to the members described below, any of the general methods and properties of the XmlReader class can also be used to process elements. Por ejemplo, puede utilizar el método ReadInnerXml para leer el contenido de un elemento.For example, you can use the ReadInnerXml method to read the contents of an element.

Nota

Vea la sección 3,1 de la recomendación XML 1,0 del consorcio W3C para ver las definiciones de las etiquetas de inicio, las etiquetas de cierre y las etiquetas de elementos vacíos.See section 3.1 of the W3C XML 1.0 Recommendation for definitions of start tags, end tags, and empty element tags.

Usar este miembro de XmlReaderUse this XmlReader member EnTo
Método IsStartElementIsStartElement method Compruebe si el nodo actual es una etiqueta de apertura o una etiqueta de elemento vacío.Check if the current node is a start tag or an empty element tag.
Método ReadStartElementReadStartElement method Compruebe que el nodo actual es un elemento y avance el lector hasta el siguiente nodo (llama a IsStartElement seguido de Read).Check that the current node is an element and advance the reader to the next node (calls IsStartElement followed by Read).
Método ReadEndElementReadEndElement method Compruebe que el nodo actual es una etiqueta de cierre y avance el lector hasta el siguiente nodo.Check that the current node is an end tag and advance the reader to the next node.
Método ReadElementStringReadElementString method Lee un elemento de solo texto.Read a text-only element.
Método ReadToDescendantReadToDescendant method Avance el lector XML hasta el siguiente elemento descendiente (secundario) que tenga el nombre especificado.Advance the XML reader to the next descendant (child) element that has the specified name.
Método ReadToNextSiblingReadToNextSibling method Avanza el lector XML hasta el siguiente elemento relacionado que tenga el nombre especificado.Advance the XML reader to the next sibling element that has the specified name.
PropiedadIsEmptyElementIsEmptyElement property Compruebe si el elemento actual tiene una etiqueta de elemento final.Check if the current element has an end element tag. Por ejemplo:For example:

- <item num="123"/> (IsEmptyElement es true).- <item num="123"/> (IsEmptyElement is true.)
- <item num="123"> </item> (IsEmptyElement se false, aunque el contenido del elemento esté vacío).- <item num="123"> </item> (IsEmptyElement is false, although the element's content is empty.)

Para obtener un ejemplo de cómo leer el contenido de texto de los elementos, vea el método ReadString.For an example of reading the text content of elements, see the ReadString method. En el siguiente ejemplo se procesan elementos mediante un bucle while.The following example processes elements by using a while loop.

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

Leer atributos XMLReading XML attributes

Los atributos XML se encuentran normalmente en los elementos, pero también se permiten en los nodos declaración XML y tipo de documento.XML attributes are most commonly found on elements, but they're also allowed on XML declaration and document type nodes.

Cuando se coloca en un nodo de elemento, el método MoveToAttribute le permite pasar por la lista de atributos del elemento.When positioned on an element node, the MoveToAttribute method lets you go through the attribute list of the element. Tenga en cuenta que, una vez que se ha llamado a MoveToAttribute, las propiedades de nodo como Name, NamespaceURIy Prefix reflejan las propiedades de ese atributo, no las propiedades del elemento al que pertenece el atributo.Note that after MoveToAttribute has been called, node properties such as Name, NamespaceURI, and Prefix reflect the properties of that attribute, not the properties of the element the attribute belongs to.

La clase XmlReader proporciona estos métodos y propiedades para leer y procesar atributos en elementos.The XmlReader class provides these methods and properties to read and process attributes on elements.

Usar este miembro de XmlReaderUse this XmlReader member EnTo
PropiedadHasAttributesHasAttributes property Compruebe si el nodo actual tiene atributos.Check whether the current node has any attributes.
PropiedadAttributeCountAttributeCount property Obtiene el número de atributos del elemento actual.Get the number of attributes on the current element.
Método MoveToFirstAttributeMoveToFirstAttribute method Moverse al primer atributo de un elemento.Move to the first attribute in an element.
Método MoveToNextAttributeMoveToNextAttribute method Moverse al siguiente atributo de un elemento.Move to the next attribute in an element.
Método MoveToAttributeMoveToAttribute method Moverse a un atributo especificado.Move to a specified attribute.
GetAttribute método o propiedad Item[String, String]GetAttribute method or Item[String, String] property Obtiene el valor de un atributo especificado.Get the value of a specified attribute.
PropiedadIsDefaultIsDefault property Compruebe si el nodo actual es un atributo generado a partir del valor predeterminado definido en la DTD o el esquema.Check whether the current node is an attribute that was generated from the default value defined in the DTD or schema.
Método MoveToElementMoveToElement method Desplácese hasta el elemento que posee el atributo actual.Move to the element that owns the current attribute. Utilice este método para volver a un elemento después de desplazarse por los atributos.Use this method to return to an element after navigating through its attributes.
Método ReadAttributeValueReadAttributeValue method Analiza el valor de atributo en uno o varios nodos Text, EntityReferenceo EndEntity.Parse the attribute value into one or more Text, EntityReference, or EndEntity nodes.

También se puede utilizar cualquiera de las propiedades y los métodos XmlReader generales para procesar atributos.Any of the general XmlReader methods and properties can also be used to process attributes. Por ejemplo, después de situar XmlReader en un atributo, las propiedades Name y Value reflejan los valores del atributo.For example, after the XmlReader is positioned on an attribute, the Name and Value properties reflect the values of the attribute. También puede utilizar cualquiera de los métodos Read de contenido para obtener el valor del atributo.You can also use any of the content Read methods to get the value of the attribute.

En este ejemplo se usa la propiedad AttributeCount para navegar por todos los atributos de un elemento.This example uses the AttributeCount property to navigate through all the attributes on an element.

// 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 método MoveToNextAttribute en un bucle de while para navegar por los atributos.This example uses the MoveToNextAttribute method in a while loop to navigate through the attributes.

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

Leer atributos en nodos de declaración XMLReading attributes on XML declaration nodes

Cuando el lector XML se coloca en un nodo de declaración XML, la propiedad Value devuelve la información de versión, independiente y de codificación como una sola cadena.When the XML reader is positioned on an XML declaration node, the Value property returns the version, standalone, and encoding information as a single string. XmlReader objetos creados por el método Create, la clase XmlTextReader y la clase XmlValidatingReader exponen los elementos de versión, independiente y de codificación como atributos.XmlReader objects created by the Create method, the XmlTextReader class, and the XmlValidatingReader class expose the version, standalone, and encoding items as attributes.

Leer atributos en nodos de tipo de documentoReading attributes on document type nodes

Cuando el lector XML se coloca en un nodo de tipo de documento, el método GetAttribute y la propiedad Item[String, String] se pueden usar para devolver los valores del sistema y los literales públicos.When the XML reader is positioned on a document type node, the GetAttribute method and Item[String, String] property can be used to return the values for the SYSTEM and PUBLIC literals. Por ejemplo, al llamar a reader.GetAttribute("PUBLIC"), se devuelve el valor PUBLIC.For example, calling reader.GetAttribute("PUBLIC") returns the PUBLIC value.

Leer atributos en nodos de instrucción de procesamientoReading attributes on processing instruction nodes

Cuando XmlReader está situado en un nodo de instrucción de procesamiento, la propiedad Value devuelve el contenido de texto completo.When the XmlReader is positioned on a processing instruction node, the Value property returns the entire text content. Los elementos del nodo de instrucción de procesamiento no se tratan como atributos.Items in the processing instruction node aren't treated as attributes. No se pueden leer con el método GetAttribute o MoveToAttribute.They can't be read with the GetAttribute or MoveToAttribute method.

Leer contenido XMLReading XML content

La clase XMLReader incluye los siguientes miembros que leen el contenido de un archivo XML y devuelven el contenido como valores de cadena.The XMLReader class includes the following members that read content from an XML file and return the content as string values. (Para devolver los tipos CLR, vea la sección siguiente).(To return CLR types, see the next section.)

Usar este miembro de XmlReaderUse this XmlReader member EnTo
PropiedadValueValue property Obtiene el contenido de texto del nodo actual.Get the text content of the current node. El valor devuelto depende del tipo de nodo; Consulte la página de referencia de Value para obtener más información.The value returned depends on the node type; see the Value reference page for details.
Método ReadStringReadString method Obtiene el contenido de un nodo de elemento o de texto como una cadena.Get the content of an element or text node as a string. Este método se detiene en las instrucciones de procesamiento y los comentarios.This method stops on processing instructions and comments.

Para obtener más información sobre cómo este método controla los tipos de nodo específicos, vea la página de referencia de ReadString.For details on how this method handles specific node types, see the ReadString reference page.
Métodos ReadInnerXml y ReadInnerXmlAsyncReadInnerXml and ReadInnerXmlAsync methods Obtiene todo el contenido del nodo actual, incluido el marcado, pero excluidas las etiquetas de inicio y fin.Get all the content of the current node, including the markup, but excluding start and end tags. Por ejemplo, para:For example, for:

<node>this<child id="123"/></node>

ReadInnerXml devuelve:ReadInnerXml returns:

this<child id="123"/>
Métodos ReadOuterXml y ReadOuterXmlAsyncReadOuterXml and ReadOuterXmlAsync methods Obtiene todo el contenido del nodo actual y sus elementos secundarios, incluidos el marcado y las etiquetas de inicio y fin.Get all the content of the current node and its children, including markup and start/end tags. Por ejemplo, para:For example, for:

<node>this<child id="123"/></node>

ReadOuterXml devuelve:ReadOuterXml returns:

<node>this<child id="123"/></node>

Convertir a tipos CLRConverting to CLR types

Puede usar los miembros de la clase XmlReader (que se enumeran en la tabla siguiente) para leer datos XML y devolver valores como tipos Common Language Runtime (CLR) en lugar de cadenas.You can use the members of the XmlReader class (listed in the following table) to read XML data and return values as common language runtime (CLR) types instead of strings. 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 los valores de cadena.These members enable you to get values in the representation that is most appropriate for your coding task without having to manually parse or convert string values.

  • Solo se puede llamar a los métodos ReadElementContentAs en los tipos de nodo de elemento.The ReadElementContentAs methods can only be called on element node types. Estos métodos no se pueden utilizar en elementos que contienen elementos segundarios o incluyen contenido mixto.These methods cannot be used on elements that contain child elements or mixed content. 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.When called, the XmlReader object reads the start tag, reads the element content, and then moves past the end element tag. Las instrucciones de procesamiento y los comentarios se omiten y las entidades se expanden.Processing instructions and comments are ignored and entities are expanded.

  • Los métodos de ReadContentAs leen el contenido de texto en la posición actual del lector y, si los datos XML no tienen ninguna información de esquema o de tipo de datos asociada, convierten el contenido de texto en el tipo de valor devuelto solicitado.The ReadContentAs methods read the text content at the current reader position, and if the XML data doesn't have any schema or data type information associated with it, convert the text content to the requested return type. El texto, el espacio en blanco, el espacio en blanco significativo y las secciones CDATA se concatenan.Text, white space, significant white space and CDATA sections are concatenated. Los comentarios y las instrucciones de procesamiento se omiten y las referencias de entidad se resuelven automáticamente.Comments and processing instructions are skipped, and entity references are automatically resolved.

La clase XmlReader utiliza las reglas definidas por la recomendación W3C XML Schema Part 2: Datatypes .The XmlReader class uses the rules defined by the W3C XML Schema Part 2: Datatypes recommendation.

Usar este método XmlReaderUse this XmlReader method Para devolver este tipo CLRTo return this CLR type
ReadContentAsBoolean y ReadElementContentAsBooleanReadContentAsBoolean and ReadElementContentAsBoolean Boolean
ReadContentAsDateTime y ReadElementContentAsDateTimeReadContentAsDateTime and ReadElementContentAsDateTime DateTime
ReadContentAsDouble y ReadElementContentAsDoubleReadContentAsDouble and ReadElementContentAsDouble Double
ReadContentAsLong y ReadElementContentAsLongReadContentAsLong and ReadElementContentAsLong Int64
ReadContentAsInt y ReadElementContentAsIntReadContentAsInt and ReadElementContentAsInt Int32
ReadContentAsString y ReadElementContentAsStringReadContentAsString and ReadElementContentAsString String
ReadContentAs y ReadElementContentAsReadContentAs and ReadElementContentAs El tipo que se especifica con el parámetro returnTypeThe type you specify with the returnType parameter
ReadContentAsObject y ReadElementContentAsObjectReadContentAsObject and ReadElementContentAsObject El tipo más adecuado, según lo especificado por la propiedad XmlReader.ValueType.The most appropriate type, as specified by the XmlReader.ValueType property. Vea compatibilidad de tipos en las clases System. XML para la asignación de información.See Type Support in the System.Xml Classes for mapping information.

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 asegurarse de que la conversión se realiza correctamente.If an element can't easily be converted to a CLR type because of its format, you can use a schema mapping to ensure a successful conversion. En el ejemplo siguiente se usa un archivo. xsd para convertir el elemento hire-date en el tipo xs:date y, a continuación, se usa el método ReadElementContentAsDateTime para devolver el elemento como un objeto DateTime.The following example uses an .xsd file to convert the hire-date element to the xs:date type, and then uses the ReadElementContentAsDateTime method to return the element as a DateTime object.

Entrada (hireDate. xml):Input (hireDate.xml):

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

Esquema (hireDate. xsd):Schema (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>

CodificaCode:

// 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:Output:

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

Programación asincrónicaAsynchronous programming

La mayoría de los métodos XmlReader tienen homólogos asincrónicos que tienen "Async" al final de sus nombres de método.Most of the XmlReader methods have asynchronous counterparts that have "Async" at the end of their method names. Por ejemplo, el equivalente asincrónico de ReadContentAsObject se ReadContentAsObjectAsync.For example, the asynchronous equivalent of ReadContentAsObject is ReadContentAsObjectAsync.

Los métodos siguientes se pueden usar con llamadas a métodos asincrónicos:The following methods can be used with asynchronous method calls:

En las secciones siguientes se describe el uso asincrónico de métodos que no tienen homólogos asincrónicos.The following sections describe asynchronous usage for methods that don't have asynchronous counterparts.

Método ReadStartElementReadStartElement method

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 ReadEndElementReadEndElement method

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 ReadToNextSiblingReadToNextSibling method

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 ReadToFollowingReadToFollowing method

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 ReadToDescendantReadToDescendant method

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 seguridadSecurity considerations

Tenga en cuenta lo siguiente al trabajar con la clase XmlReader:Consider the following when working with the XmlReader class:

  • Las excepciones que se producen desde el XmlReader pueden revelar información de la ruta de acceso que podría no querer pasar a la aplicación.Exceptions thrown from the XmlReader can disclose path information that you might not want bubbled up to your app. La aplicación debe detectar las excepciones y procesarlas de forma adecuada.Your app must catch exceptions and process them appropriately.

  • No habilite el procesamiento de DTD si le preocupa los problemas de denegación de servicio o si trabaja con orígenes que no son de confianza.Do not enable DTD processing if you're concerned about denial of service issues or if you're dealing with untrusted sources. El procesamiento de DTD está deshabilitado de forma predeterminada para los objetos XmlReader creados por el método Create.DTD processing is disabled by default for XmlReader objects created by the Create method.

    Si tiene habilitado el procesamiento de DTD, puede utilizar XmlSecureResolver para restringir los recursos a los que tiene acceso XmlReader.If you have DTD processing enabled, you can use the XmlSecureResolver to restrict the resources that the XmlReader can access. También puede diseñar la aplicación para que el procesamiento XML sea de memoria y de tiempo restringido.You can also design your app so that the XML processing is memory and time constrained. Por ejemplo, puede configurar límites de tiempo de espera en la aplicación ASP.NET.For example, you can configure time-out limits in your ASP.NET app.

  • Los datos XML pueden incluir referencias a recursos externos como, por ejemplo, un archivo de esquemas.XML data can include references to external resources such as a schema file. De forma predeterminada, los recursos externos se resuelven mediante el uso de un objeto XmlUrlResolver sin credenciales de usuario.By default, external resources are resolved by using an XmlUrlResolver object with no user credentials. Puede aumentar la protección aún más realizando cualquiera de las siguientes acciones:You can secure this further by doing one of the following:

  • Las marcas de validación ProcessInlineSchema y ProcessSchemaLocation de un objeto XmlReaderSettings no se establecen de forma predeterminada.The ProcessInlineSchema and ProcessSchemaLocation validation flags of an XmlReaderSettings object aren't set by default. Esto ayuda a proteger el XmlReader contra ataques basados en esquemas cuando está procesando datos XML de un origen que no es de confianza.This helps to protect the XmlReader against schema-based attacks when it is processing XML data from an untrusted source. 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.When these flags are set, the XmlResolver of the XmlReaderSettings object is used to resolve schema locations encountered in the instance document in the XmlReader. Si la propiedad XmlResolver está establecida en null, las ubicaciones de esquemas no se resuelven incluso si se establecen las marcas de validación ProcessInlineSchema y ProcessSchemaLocation.If the XmlResolver property is set to null, schema locations aren't resolved even if the ProcessInlineSchema and ProcessSchemaLocation validation flags are set.

    Los esquemas agregados durante la validación agregan nuevos tipos y pueden cambiar el resultado de la validación del documento.Schemas added during validation add new types and can change the validation outcome of the document being validated. Como consecuencia, los esquemas externos solo se deberían resolver desde orígenes de confianza.As a result, external schemas should only be resolved from trusted sources.

    Se recomienda deshabilitar la marca ProcessIdentityConstraints al validar documentos XML grandes que no son de confianza en escenarios de alta disponibilidad con respecto a un esquema que tiene restricciones de identidad en una gran parte del documento.We recommend disabling the ProcessIdentityConstraints flag when validating untrusted, large XML documents in high availability scenarios against a schema that has identity constraints over a large part of the document. Esta marca está habilitada de forma predeterminada.This flag is enabled by default.

  • 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.XML data can contain a large number of attributes, namespace declarations, nested elements and so on that require a substantial amount of time to process. Para limitar el tamaño de la entrada que se envía al XmlReader, puede:To limit the size of the input that is sent to the XmlReader, you can:

  • El método ReadValueChunk se puede usar para administrar grandes flujos de datos.The ReadValueChunk method can be used to handle large streams of data. Este método lee una pequeña cantidad de caracteres a la vez en lugar de asignar una única cadena para todo el valor.This method reads a small number of characters at a time instead of allocating a single string for the whole value.

  • Al leer un documento XML con un gran número de nombres locales únicos, espacios de nombres o prefijos, puede producirse un problema.When reading an XML document with a large number of unique local names, namespaces, or prefixes, a problem can occur. Si usa una clase que deriva de XmlReadery llama a la propiedad LocalName, Prefixo NamespaceURI para cada elemento, la cadena devuelta se agrega a un NameTable.If you are using a class that derives from XmlReader, and you call the LocalName, Prefix, or NamespaceURI property for each item, the returned string is added to a NameTable. La colección mantenida por el NameTable nunca disminuye de tamaño, lo que crea una pérdida de memoria virtual de los identificadores de cadena.The collection held by the NameTable never decreases in size, creating a virtual memory leak of the string handles. Una mitigación para esto es derivar de la clase NameTable y aplicar una cuota de tamaño máximo.One mitigation for this is to derive from the NameTable class and enforce a maximum size quota. (No hay ninguna manera de evitar el uso de un NameTable, o para cambiar el NameTable cuando está lleno).(There is no way to prevent the use of a NameTable, or to switch the NameTable when it is full). Otra mitigación es evitar el uso de las propiedades mencionadas y, en su lugar, usar el método MoveToAttribute con el método IsStartElement siempre que sea posible; Estos métodos no devuelven cadenas y, por tanto, evitan el problema de rellenar la colección de NameTable.Another mitigation is to avoid using the properties mentioned and instead use the MoveToAttribute method with the IsStartElement method where possible; those methods don't return strings and thus avoid the problem of overfilling the NameTable collection.

  • Los objetos XmlReaderSettings pueden contener información confidencial como, por ejemplo, credenciales de usuario.XmlReaderSettings objects can contain sensitive information such as user credentials. 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.An untrusted component could use the XmlReaderSettings object and its user credentials to create XmlReader objects to read data. Tenga cuidado al almacenar en caché XmlReaderSettings objetos o al pasar el XmlReaderSettings objeto de un componente a otro.Be careful when caching XmlReaderSettings objects, or when passing the XmlReaderSettings object from one component to another.

  • No admita componentes como, por ejemplo, objetos NameTable, XmlNamespaceManager y XmlResolver, de un origen que no sea de confianza.Do not accept supporting components, such as NameTable, XmlNamespaceManager, and XmlResolver objects, from an untrusted source.

Constructores

XmlReader()

Inicializa una nueva instancia de la clase XmlReader.Initializes a new instance of the XmlReader class.

Propiedades

AttributeCount

Cuando se invalida en una clase derivada, obtiene el número de atributos en el nodo actual.When overridden in a derived class, gets the number of attributes on the current node.

BaseURI

Cuando se invalida en una clase derivada, obtiene el identificador URI base del nodo actual.When overridden in a derived class, gets the base URI of the current node.

CanReadBinaryContent

Obtiene un valor que indica si XmlReader implementa los métodos de lectura de contenido binario.Gets a value indicating whether the XmlReader implements the binary content read methods.

CanReadValueChunk

Obtiene un valor que indica si XmlReader implementa el método ReadValueChunk(Char[], Int32, Int32).Gets a value indicating whether the XmlReader implements the ReadValueChunk(Char[], Int32, Int32) method.

CanResolveEntity

Obtiene un valor que indica si este lector puede analizar y resolver entidades.Gets a value indicating whether this reader can parse and resolve entities.

Depth

Cuando se invalida en una clase derivada, obtiene la profundidad del nodo actual en el documento XML.When overridden in a derived class, gets the depth of the current node in the XML document.

EOF

Cuando se invalida en una clase derivada, obtiene un valor que indica si el lector está situado al final del flujo.When overridden in a derived class, gets a value indicating whether the reader is positioned at the end of the stream.

HasAttributes

Obtiene un valor que indica si el nodo actual tiene algún atributo.Gets a value indicating whether the current node has any attributes.

HasValue

Cuando se invalida en una clase derivada, obtiene un valor que indica si el nodo actual puede tener una propiedad Value.When overridden in a derived class, gets a value indicating whether the current node can have a 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.When overridden in a derived class, gets a value indicating whether the current node is an attribute that was generated from the default value defined in the DTD or schema.

IsEmptyElement

Cuando se invalida en una clase derivada, obtiene un valor que indica si el nodo actual es un elemento vacío (por ejemplo, <MyElement/>).When overridden in a derived class, gets a value indicating whether the current node is an empty element (for example, <MyElement/>).

Item[Int32]

Cuando se invalida en una clase derivada, obtiene el valor del atributo con el índice especificado.When overridden in a derived class, gets the value of the attribute with the specified index.

Item[String, String]

Cuando se invalida en una clase derivada, obtiene el valor del atributo con las propiedades LocalName y NamespaceURI especificadas.When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

Item[String]

Cuando se invalida en una clase derivada, obtiene el valor del atributo con la propiedad Name especificada.When overridden in a derived class, gets the value of the attribute with the specified Name.

LocalName

Cuando se invalida en una clase derivada, obtiene el nombre local del nodo actual.When overridden in a derived class, gets the local name of the current node.

Name

Cuando se invalida en una clase derivada, obtiene el nombre completo del nodo actual.When overridden in a derived class, gets the qualified name of the current node.

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.When overridden in a derived class, gets the namespace URI (as defined in the W3C Namespace specification) of the node on which the reader is positioned.

NameTable

Cuando se invalida en una clase derivada, obtiene el objeto XmlNameTable que está asociado a esta implementación.When overridden in a derived class, gets the XmlNameTable associated with this implementation.

NodeType

Cuando se invalida en una clase derivada, obtiene el tipo del nodo actual.When overridden in a derived class, gets the type of the current node.

Prefix

Cuando se invalida en una clase derivada, obtiene el prefijo de espacio de nombres asociado al nodo actual.When overridden in a derived class, gets the namespace prefix associated with the current node.

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.When overridden in a derived class, gets the quotation mark character used to enclose the value of an attribute node.

ReadState

Cuando se invalida en una clase derivada, obtiene el estado del lector.When overridden in a derived class, gets the state of the reader.

SchemaInfo

Obtiene la información de esquema asignada al nodo actual como resultado de la validación del esquema.Gets the schema information that has been assigned to the current node as a result of schema validation.

Settings

Obtiene el objeto XmlReaderSettings que se usa para crear esta instancia de XmlReader.Gets the XmlReaderSettings object used to create this XmlReader instance.

Value

Cuando se invalida en una clase derivada, obtiene el valor de texto del nodo actual.When overridden in a derived class, gets the text value of the current node.

ValueType

Obtiene el tipo de Common Language Runtime (CLR) del nodo actual.Gets The Common Language Runtime (CLR) type for the current node.

XmlLang

Cuando se invalida en una clase derivada, obtiene el ámbito de xml:lang actual.When overridden in a derived class, gets the current xml:lang scope.

XmlSpace

Cuando se invalida en una clase derivada, obtiene el ámbito de xml:space actual.When overridden in a derived class, gets the current xml:space scope.

Métodos

Close()

Cuando se invalida en una clase derivada, cambia ReadState a Closed.When overridden in a derived class, changes the ReadState to Closed.

Create(Stream)

Crea una nueva instancia XmlReader mediante el flujo especificado con la configuración predeterminada.Creates a new XmlReader instance using the specified stream with default settings.

Create(Stream, XmlReaderSettings)

Crea una nueva instancia de XmlReader con el flujo y la configuración especificados.Creates a new XmlReader instance with the specified stream and settings.

Create(Stream, XmlReaderSettings, String)

Crea una nueva instancia de XmlReader usando el flujo, el URI base y la configuración especificados.Creates a new XmlReader instance using the specified stream, base URI, and settings.

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.Creates a new XmlReader instance using the specified stream, settings, and context information for parsing.

Create(String)

Crea una nueva instancia de XmlReader con el URI especificado.Creates a new XmlReader instance with specified URI.

Create(String, XmlReaderSettings)

Crea una nueva instancia de XmlReader usando el URI y la configuración especificados.Creates a new XmlReader instance by using the specified URI and settings.

Create(String, XmlReaderSettings, XmlParserContext)

Crea una nueva instancia de XmlReader usando el URI, la configuración y la información de contexto especificados.Creates a new XmlReader instance by using the specified URI, settings, and context information for parsing.

Create(TextReader)

Crea una nueva instancia de XmlReader mediante el lector de texto especificado.Creates a new XmlReader instance by using the specified text reader.

Create(TextReader, XmlReaderSettings)

Crea una nueva instancia XmlReader usando el lector de texto y la configuración especificados.Creates a new XmlReader instance by using the specified text reader and settings.

Create(TextReader, XmlReaderSettings, String)

Crea una nueva instancia de XmlReader mediante el lector de texto, la configuración y el URI base especificados.Creates a new XmlReader instance by using the specified text reader, settings, and base URI.

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.Creates a new XmlReader instance by using the specified text reader, settings, and context information for parsing.

Create(XmlReader, XmlReaderSettings)

Crea una nueva instancia de XmlReader con el lector XML y la configuración especificados.Creates a new XmlReader instance by using the specified XML reader and settings.

Dispose()

Libera todos los recursos usados por la instancia actual de la clase XmlReader.Releases all resources used by the current instance of the XmlReader class.

Dispose(Boolean)

Libera los recursos no administrados que usa XmlReader y, de forma opcional, libera los recursos administrados.Releases the unmanaged resources used by the XmlReader and optionally releases the managed resources.

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetAttribute(Int32)

Cuando se invalida en una clase derivada, obtiene el valor del atributo con el índice especificado.When overridden in a derived class, gets the value of the attribute with the specified index.

GetAttribute(String)

Cuando se invalida en una clase derivada, obtiene el valor del atributo con la propiedad Name especificada.When overridden in a derived class, gets the value of the attribute with the specified Name.

GetAttribute(String, String)

Cuando se invalida en una clase derivada, obtiene el valor del atributo con las propiedades LocalName y NamespaceURI especificadas.When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
GetValueAsync()

Obtiene de forma asincrónica el valor del nodo actual.Asynchronously gets the value of the current node.

IsName(String)

Devuelve un valor que indica si el argumento de cadena es un nombre XML válido.Returns a value indicating whether the string argument is a valid XML name.

IsNameToken(String)

Devuelve un valor que indica si el argumento de cadena es un token de nombre XML válido.Returns a value indicating whether or not the string argument is a valid XML name token.

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.Calls MoveToContent() and tests if the current content node is a start tag or empty element tag.

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.Calls MoveToContent() and tests if the current content node is a start tag or empty element tag and if the Name property of the element found matches the given argument.

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.Calls MoveToContent() and tests if the current content node is a start tag or empty element tag and if the LocalName and NamespaceURI properties of the element found match the given strings.

LookupNamespace(String)

Cuando se invalida en una clase derivada, resuelve un prefijo de espacio de nombres en el ámbito del elemento actual.When overridden in a derived class, resolves a namespace prefix in the current element's scope.

MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
MoveToAttribute(Int32)

Cuando se invalida en una clase derivada, se desplaza al atributo con el índice especificado.When overridden in a derived class, moves to the attribute with the specified index.

MoveToAttribute(String)

Cuando se invalida en una clase derivada, se desplaza al atributo con la propiedad Name especificada.When overridden in a derived class, moves to the attribute with the specified Name.

MoveToAttribute(String, String)

Cuando se invalida en una clase derivada, se desplaza al atributo con las propiedades LocalName y NamespaceURI especificadas.When overridden in a derived class, moves to the attribute with the specified LocalName and NamespaceURI.

MoveToContent()

Comprueba si el nodo actual es un nodo de contenido (texto sin espacios en blanco, CDATA, Element, EndElement, EntityReference o EndEntity).Checks whether the current node is a content (non-white space text, CDATA, Element, EndElement, EntityReference, or EndEntity) node. Si el nodo no es un nodo de contenido, el lector salta hasta el siguiente nodo de contenido o el final del archivo.If the node is not a content node, the reader skips ahead to the next content node or end of file. Omite los siguientes tipos de nodo: ProcessingInstruction, DocumentType, Comment, Whitespace o SignificantWhitespace.It skips over nodes of the following type: ProcessingInstruction, DocumentType, Comment, Whitespace, or SignificantWhitespace.

MoveToContentAsync()

De forma asincrónica comprueba si el nodo actual es un nodo de contenido.Asynchronously checks whether the current node is a content node. Si el nodo no es un nodo de contenido, el lector salta hasta el siguiente nodo de contenido o el final del archivo.If the node is not a content node, the reader skips ahead to the next content node or end of file.

MoveToElement()

Cuando se invalida en una clase derivada, se desplaza al elemento que contiene el nodo de atributo actual.When overridden in a derived class, moves to the element that contains the current attribute node.

MoveToFirstAttribute()

Cuando se invalida en una clase derivada, se desplaza hasta el primer atributo.When overridden in a derived class, moves to the first attribute.

MoveToNextAttribute()

Cuando se invalida en una clase derivada, se desplaza hasta el siguiente atributo.When overridden in a derived class, moves to the next attribute.

Read()

Cuando se invalida en una clase derivada, lee el siguiente nodo del flujo.When overridden in a derived class, reads the next node from the stream.

ReadAsync()

De forma asincrónica lee el nodo siguiente del flujo.Asynchronously reads the next node from the stream.

ReadAttributeValue()

Cuando se invalida en una clase derivada, analiza el valor de atributo en uno o varios nodos Text, EntityReference o EndEntity.When overridden in a derived class, parses the attribute value into one or more Text, EntityReference, or EndEntity nodes.

ReadContentAs(Type, IXmlNamespaceResolver)

Lee el contenido como objeto del tipo especificado.Reads the content as an object of the type specified.

ReadContentAsAsync(Type, IXmlNamespaceResolver)

Lee asincrónicamente el contenido como objeto del tipo especificado.Asynchronously reads the content as an object of the type specified.

ReadContentAsBase64(Byte[], Int32, Int32)

Lee el contenido y devuelve los bytes binarios descodificados en Base64.Reads the content and returns the Base64 decoded binary bytes.

ReadContentAsBase64Async(Byte[], Int32, Int32)

Lee asincrónicamente el contenido y devuelve los bytes binarios descodificados en Base64.Asynchronously reads the content and returns the Base64 decoded binary bytes.

ReadContentAsBinHex(Byte[], Int32, Int32)

Lee el contenido y devuelve los bytes binarios descodificados de BinHex.Reads the content and returns the BinHex decoded binary bytes.

ReadContentAsBinHexAsync(Byte[], Int32, Int32)

Lee asincrónicamente el contenido y devuelve los bytes binarios descodificados de BinHex.Asynchronously reads the content and returns the BinHex decoded binary bytes.

ReadContentAsBoolean()

Lee el contenido de texto en la posición actual como valor Boolean.Reads the text content at the current position as a Boolean.

ReadContentAsDateTime()

Lee el contenido de texto en la posición actual como un objeto DateTime.Reads the text content at the current position as a DateTime object.

ReadContentAsDateTimeOffset()

Lee el contenido de texto en la posición actual como un objeto DateTimeOffset.Reads the text content at the current position as a DateTimeOffset object.

ReadContentAsDecimal()

Lee el contenido de texto en la posición actual como un objeto Decimal.Reads the text content at the current position as a Decimal object.

ReadContentAsDouble()

Lee el contenido de texto en la posición actual como número de punto flotante de precisión doble.Reads the text content at the current position as a double-precision floating-point number.

ReadContentAsFloat()

Lee el contenido de texto en la posición actual como número de punto flotante de precisión sencilla.Reads the text content at the current position as a single-precision floating point number.

ReadContentAsInt()

Lee el contenido de texto en la posición actual como un entero de 32 bits con signo.Reads the text content at the current position as a 32-bit signed integer.

ReadContentAsLong()

Lee el contenido de texto en la posición actual como un entero de 64 bits con signo.Reads the text content at the current position as a 64-bit signed integer.

ReadContentAsObject()

Lee el contenido de texto en la posición actual como Object.Reads the text content at the current position as an Object.

ReadContentAsObjectAsync()

Lee asincrónicamente el contenido de texto en la posición actual como un objeto Object.Asynchronously reads the text content at the current position as an Object.

ReadContentAsString()

Lee el contenido de texto en la posición actual como un objeto String.Reads the text content at the current position as a String object.

ReadContentAsStringAsync()

Lee asincrónicamente el contenido de texto en la posición actual como un objeto String.Asynchronously reads the text content at the current position as a String object.

ReadElementContentAs(Type, IXmlNamespaceResolver)

Lee el contenido de los elementos como el tipo solicitado.Reads the element content as the requested type.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the element content as the requested type.

ReadElementContentAsAsync(Type, IXmlNamespaceResolver)

Lee asincrónicamente el contenido del elemento como el tipo solicitado.Asynchronously reads the element content as the requested type.

ReadElementContentAsBase64(Byte[], Int32, Int32)

Lee el elemento y descodifica el contenido de Base64.Reads the element and decodes the Base64 content.

ReadElementContentAsBase64Async(Byte[], Int32, Int32)

Lee asincrónicamente el elemento y descodifica el contenido de Base64.Asynchronously reads the element and decodes the Base64 content.

ReadElementContentAsBinHex(Byte[], Int32, Int32)

Lee el elemento y descodifica el contenido de BinHex.Reads the element and decodes the BinHex content.

ReadElementContentAsBinHexAsync(Byte[], Int32, Int32)

Lee asincrónicamente el elemento y descodifica el contenido de BinHex.Asynchronously reads the element and decodes the BinHex content.

ReadElementContentAsBoolean()

Lee el elemento actual y devuelve el contenido como un objeto Boolean.Reads the current element and returns the contents as a Boolean object.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a Boolean object.

ReadElementContentAsDateTime()

Lee el elemento actual y devuelve el contenido como un objeto DateTime.Reads the current element and returns the contents as a DateTime object.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a DateTime object.

ReadElementContentAsDecimal()

Lee el elemento actual y devuelve el contenido como un objeto Decimal.Reads the current element and returns the contents as a Decimal object.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a Decimal object.

ReadElementContentAsDouble()

Lee el elemento actual y devuelve el contenido como número de punto flotante de precisión doble.Reads the current element and returns the contents as a double-precision floating-point number.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a double-precision floating-point number.

ReadElementContentAsFloat()

Lee el elemento actual y devuelve el contenido como número de punto flotante de precisión sencilla.Reads the current element and returns the contents as single-precision floating-point number.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a single-precision floating-point number.

ReadElementContentAsInt()

Lee el elemento actual y devuelve el contenido como un entero de 32 bits con signo.Reads the current element and returns the contents as a 32-bit signed integer.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a 32-bit signed integer.

ReadElementContentAsLong()

Lee el elemento actual y devuelve el contenido como entero de 64 bits con signo.Reads the current element and returns the contents as a 64-bit signed integer.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a 64-bit signed integer.

ReadElementContentAsObject()

Lee el elemento actual y devuelve el contenido como objeto Object.Reads the current element and returns the contents as an 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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as an Object.

ReadElementContentAsObjectAsync()

Lee asincrónicamente el elemento actual y devuelve el contenido como objeto Object.Asynchronously reads the current element and returns the contents as an Object.

ReadElementContentAsString()

Lee el elemento actual y devuelve el contenido como un objeto String.Reads the current element and returns the contents as a String object.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a String object.

ReadElementContentAsStringAsync()

Lee asincrónicamente el elemento actual y devuelve el contenido como un objeto String.Asynchronously reads the current element and returns the contents as a String object.

ReadElementString()

Lee un elemento de solo texto.Reads a text-only element. Sin embargo, se recomienda usar el método ReadElementContentAsString() en su lugar, porque proporciona una manera más sencilla de controlar esta operación.However, we recommend that you use the ReadElementContentAsString() method instead, because it provides a more straightforward way to handle this operation.

ReadElementString(String)

Comprueba si la propiedad Name del elemento encontrado coincide con la cadena especificada antes de leer un elemento de sólo texto.Checks that the Name property of the element found matches the given string before reading a text-only element. Sin embargo, se recomienda usar el método ReadElementContentAsString() en su lugar, porque proporciona una manera más sencilla de controlar esta operación.However, we recommend that you use the ReadElementContentAsString() method instead, because it provides a more straightforward way to handle this operation.

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.Checks that the LocalName and NamespaceURI properties of the element found matches the given strings before reading a text-only element. 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.However, we recommend that you use the ReadElementContentAsString(String, String) method instead, because it provides a more straightforward way to handle this operation.

ReadEndElement()

Comprueba si el nodo de contenido actual es una etiqueta de cierre y desplaza el lector hasta el siguiente nodo.Checks that the current content node is an end tag and advances the reader to the next node.

ReadInnerXml()

Cuando se invalida en una clase derivada, lee todo el contenido, incluido el marcado, como una cadena.When overridden in a derived class, reads all the content, including markup, as a string.

ReadInnerXmlAsync()

De forma asincrónica lee todo el contenido, incluido el marcado, como una cadena.Asynchronously reads all the content, including markup, as a string.

ReadOuterXml()

Cuando se invalida en una clase derivada, lee el contenido, incluido el marcado, que representa este nodo y todos sus nodos secundarios.When overridden in a derived class, reads the content, including markup, representing this node and all its children.

ReadOuterXmlAsync()

De forma asincrónica lee el contenido, incluido el marcado, que representa este nodo y todos sus elementos secundarios.Asynchronously reads the content, including markup, representing this node and all its children.

ReadStartElement()

Comprueba si el nodo actual es un elemento y hace avanzar el sistema de lectura hasta el siguiente nodo.Checks that the current node is an element and advances the reader to the next node.

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.Checks that the current content node is an element with the given Name and advances the reader to the next node.

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.Checks that the current content node is an element with the given LocalName and NamespaceURI and advances the reader to the next node.

ReadString()

Cuando se reemplaza en una clase derivada, lee el contenido de un nodo de elemento o de texto como una cadena.When overridden in a derived class, reads the contents of an element or text node as a string. Sin embargo, se recomienda usar el método ReadElementContentAsString en su lugar, porque proporciona una manera más sencilla de controlar esta operación.However, we recommend that you use the ReadElementContentAsString method instead, because it provides a more straightforward way to handle this operation.

ReadSubtree()

Devuelve una nueva instancia de XmlReader que se puede utilizar para leer el nodo actual y todos sus descendientes.Returns a new XmlReader instance that can be used to read the current node, and all its descendants.

ReadToDescendant(String)

Hace avanzar el objeto XmlReader hasta al siguiente elemento descendiente con el nombre completo especificado.Advances the XmlReader to the next descendant element with the specified qualified name.

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.Advances the XmlReader to the next descendant element with the specified local name and namespace URI.

ReadToFollowing(String)

Lee hasta que encuentra un elemento con el nombre completo especificado.Reads until an element with the specified qualified name is found.

ReadToFollowing(String, String)

Lee hasta que encuentra un elemento con el nombre local y el URI de espacio de nombres especificados.Reads until an element with the specified local name and namespace URI is found.

ReadToNextSibling(String)

Hace avanzar el objeto XmlReader hasta al siguiente elemento relacionado con el nombre completo especificado.Advances the XmlReader to the next sibling element with the specified qualified name.

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.Advances the XmlReader to the next sibling element with the specified local name and namespace URI.

ReadValueChunk(Char[], Int32, Int32)

Lee grandes secuencias de texto incrustadas en un documento XML.Reads large streams of text embedded in an XML document.

ReadValueChunkAsync(Char[], Int32, Int32)

Lee asincrónicamente grandes secuencias de texto incrustadas en un documento XML.Asynchronously reads large streams of text embedded in an XML document.

ResolveEntity()

Cuando se invalida en una clase derivada, resuelve la referencia a entidad para los nodos EntityReference.When overridden in a derived class, resolves the entity reference for EntityReference nodes.

Skip()

Omite los nodos secundarios del nodo actual.Skips the children of the current node.

SkipAsync()

Omite de forma asincrónica los elementos secundarios del valor del nodo actual.Asynchronously skips the children of the current node.

ToString()

Devuelve un valor de tipo string que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)

Implementaciones de interfaz explícitas

IDisposable.Dispose()

Para una descripción de este miembro, vea Dispose().For a description of this member, see Dispose().

Se aplica a

Consulte también: