XmlReader Classe

Definição

Namespace:

System.Xml

Assembly:

System.Xml.ReaderWriter.dll

Assembly:

System.Xml.dll

Assembly:

netstandard.dll

Representa um leitor que fornece acesso rápido não armazenado em cache e somente de encaminhamento aos dados XML.

public ref class XmlReader abstract : IDisposable

public ref class XmlReader abstract

public abstract class XmlReader : IDisposable

public abstract class XmlReader

type XmlReader = class
    interface IDisposable

type XmlReader = class

Public MustInherit Class XmlReader
Implements IDisposable

Public MustInherit Class XmlReader

Herança

Object

XmlReader

Derivado

System.Xml.XmlDictionaryReader

System.Xml.XmlNodeReader

System.Xml.XmlTextReader

System.Xml.XmlValidatingReader

Implementações

IDisposable

Exemplos

O código de exemplo a seguir mostra como usar a API assíncrona para analisar 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

Comentários

XmlReader fornece acesso somente encaminhamento e somente leitura a dados XML em um documento ou fluxo. Essa classe está em conformidade com a XML (Linguagem de Marcação Extensível) do W3C 1.0 (quarta edição) e os Namespaces em recomendações XML 1.0 (terceira edição ).

XmlReader os métodos permitem mover dados XML e ler o conteúdo de um nó. As propriedades da classe refletem o valor do nó atual, que é onde o leitor está posicionado. O ReadState valor da propriedade indica o estado atual do leitor XML. Por exemplo, a propriedade é definida ReadState.Initial pelo XmlReader.Read método e ReadState.Closed pelo XmlReader.Close método. XmlReader também fornece verificações de conformidade de dados e validação em um DTD ou esquema.

XmlReader usa um modelo de pull para recuperar dados. Este modelo:

• Simplifica a gestão estadual por um refinamento de procedimento natural e de cima para baixo.

• Dá suporte a vários fluxos de entrada e camadas.

• Permite que o cliente forneça ao analisador um buffer no qual a cadeia de caracteres é gravada diretamente e, portanto, evita a necessidade de uma cópia de cadeia de caracteres extra.

• Dá suporte ao processamento seletivo. O cliente pode ignorar itens e processar aqueles que são de interesse do aplicativo. Você também pode definir propriedades com antecedência para gerenciar como o fluxo XML é processado (por exemplo, normalização).

Nesta seção:

Criando um leitor XML Validando dados XML Conformidade de dados Navegando por nós Lendo elementos XML Lendo atributos XML Lendo conteúdo XML Convertendo em tipos CLR Programação assíncrona Considerações de segurança

Criando um leitor XML

Use o Create método para criar uma XmlReader instância.

Embora o .NET Framework forneça implementações concretas da XmlReader classe, como o XmlTextReader, XmlNodeReadere as XmlValidatingReader classes, recomendamos que você use as classes especializadas somente nesses cenários:

• Quando você quiser ler uma subárvore XML DOM de um XmlNode objeto, use a XmlNodeReader classe. (No entanto, essa classe não dá suporte a DTD ou validação de esquema.)

• Se você precisar expandir entidades sob solicitação, não deseja que seu conteúdo de texto seja normalizado ou não queira que os atributos padrão sejam retornados, use a XmlTextReader classe.

Para especificar o conjunto de recursos que você deseja habilitar no leitor XML, passe um System.Xml.XmlReaderSettings objeto para o Create método. Você pode usar um único System.Xml.XmlReaderSettings objeto para criar vários leitores com a mesma funcionalidade ou modificar o System.Xml.XmlReaderSettings objeto para criar um novo leitor com um conjunto diferente de recursos. Você também pode adicionar recursos facilmente a um leitor existente.

Se você não usar um System.Xml.XmlReaderSettings objeto, as configurações padrão serão usadas. Consulte a Create página de referência para obter detalhes.

XmlReader gera um XmlException erro de análise XML. Depois que uma exceção é gerada, o estado do leitor não é previsível. Por exemplo, o tipo de nó relatado pode ser diferente do tipo de nó real do nó atual. Use a ReadState propriedade para verificar se o leitor está em estado de erro.

Validando dados XML

Para definir a estrutura de um documento XML e suas relações de elementos, tipos de dados e restrições de conteúdo, use um esquema de definição de tipo de documento (DTD) ou XSD (linguagem de definição de esquema XML). Um documento XML será considerado bem formado se atender a todos os requisitos sintáticos definidos pela Recomendação W3C XML 1.0. Ele será considerado válido se estiver bem formado e também estiver em conformidade com as restrições definidas por seu DTD ou esquema. (Consulte o esquema XML W3C parte 1: estruturas e o esquema XML W3C Parte 2: recomendações de tipos de dados.) Portanto, embora todos os documentos XML válidos sejam bem formados, nem todos os documentos XML bem formados são válidos.

Você pode validar os dados em um DTD, um esquema XSD embutido ou em um esquema XSD armazenado em um XmlSchemaSet objeto (um cache); esses cenários são descritos na Create página de referência. XmlReader não dá suporte à validação de esquema XML-Data Reduzida (XDR).

Use as seguintes configurações na XmlReaderSettings classe para especificar qual tipo de validação, se houver, a XmlReader instância dá suporte.

Use este XmlReaderSettings membro	Para especificar
Propriedade DtdProcessing	Se deseja permitir o processamento de DTD. O padrão é não permitir o processamento de DTD.
Propriedade ValidationType	Se o leitor deve validar dados e qual tipo de validação executar (DTD ou esquema). A opção não é possível validação de dados.
Evento ValidationEventHandler	Um manipulador de eventos para receber informações sobre eventos de validação. Se um manipulador de eventos não for fornecido, XmlException será apresentada no primeiro erro de validação.
Propriedade ValidationFlags	Opções de validação adicionais por meio dos membros de XmlSchemaValidationFlags enumeração: - AllowXmlAttributes-Permite atributos XML (xml:*) em documentos de instância, mesmo quando eles não estiverem definidos no esquema. Os atributos são validados com base no tipo de dados. Consulte a XmlSchemaValidationFlags página de referência para a configuração a ser usada em cenários específicos. (Desabilitado por padrão.) - - restrições de identidade de processo (ProcessIdentityConstraints, xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) encontrados durante a validação. (Habilitado por padrão.) - ProcessSchemaLocation--Esquemas de processo especificados pelo atributo ou xsi:noNamespaceSchemaLocation pelo xsi:schemaLocation atributo. (Habilitado por padrão.) - ProcessInlineSchema– Processe embutido esquemas XML durante a validação. (Desabilitado por padrão.) - ReportValidationWarnings– Relatar eventos se ocorrer um aviso de validação. Um aviso é emitida normalmente quando não há nenhum DTD ou esquema XML para validar um elemento ou atributo específico contra. ValidationEventHandler é usado para notificação. (Desabilitado por padrão.)
Schemas	O XmlSchemaSet a ser usado para validação.
Propriedade XmlResolver	O XmlResolver para resolver e acessar recursos externos. Isso pode incluir entidades externas, como o DTD e esquemas e qualquer xs:include ou xs:import elementos contidos no esquema XML. Se você não especificar um XmlResolver, o XmlReader usa um padrão XmlUrlResolver sem credenciais do usuário.

Conformidade de dados

Os leitores XML que são criados pelo Create método cumprir os seguintes requisitos de conformidade por padrão:

• Novas linhas e o valor de atributo são normalizados de acordo com o W3C recomendação XML 1.0.

• Todas as entidades são expandidas automaticamente.

• Atributos padrão declarados na definição de tipo de documento sempre são adicionados mesmo quando o leitor não valida.

• A declaração de prefixo XML mapeada para o URI de namespace XML correto é permitida.

• Os nomes de notação em uma única NotationType declaração de atributo e NmTokens em uma única Enumeration declaração de atributo são diferentes.

Use essas XmlReaderSettings propriedades para especificar o tipo de verificações de conformidade que você deseja habilitar:

Use esta XmlReaderSettings propriedade	Para	Padrão
Propriedade CheckCharacters	Habilite ou desabilite as verificações para o seguinte: - Os caracteres estão dentro do intervalo de caracteres XML legais, conforme definido pela seção 2.2 Caracteres da Recomendação W3C XML 1.0. -Todos os nomes XML são válidos, conforme definido pela 2.3 comuns sintática constrói seção recomendação W3C XML 1.0. Quando essa propriedade é definida como true (padrão), um XmlException exceção será lançada se o arquivo XML contém caracteres inválidos ou nomes XML inválidos (por exemplo, um nome de elemento inicia com um número).	A verificação de caracteres e nomes está habilitada. A definição de CheckCharacters como false desativa a verificação de caracteres em referências de entidade de caracteres. Se o leitor estiver processando dados de texto, ele sempre verificará se os nomes XML são válidos, independentemente dessa configuração. Nota: A recomendação XML 1.0 requer conformidade no nível do documento quando um DTD está presente. Portanto, se o leitor está configurado para suportar ConformanceLevel.Fragment, mas os dados XML contêm um document type definition (DTD), um XmlException é gerada.
Propriedade ConformanceLevel	Escolha o nível de conformidade a ser aplicado: - Document. Está em conformidade com as regras para um documento XML bem formado 1,0. - Fragment. Está de acordo com as regras de um fragmento de documento bem formado que pode ser consumido como uma entidade analisada externa. - Auto. Está em conformidade com o nível decidido pelo leitor. Se os dados não estiverem em conformidade, um XmlException exceção é lançada.	Document

Navegando por nós

O nó atual é o nó XML no qual o leitor XML está posicionado no momento. Todos os XmlReader métodos executam operações em relação a esse nó e todos os XmlReader propriedades refletem o valor do nó atual.

Os métodos a seguir facilitam a navegação por nós e analisam dados.

Use esta XmlReaderSettings método	Para
Read	Leia o primeiro nó e avance pelo nó do fluxo um de cada vez. Essas chamadas são normalmente executadas dentro uma while loop. Use o NodeType propriedade para obter o tipo (por exemplo, atributo, comentário, elemento e assim por diante) do nó atual.
Skip	Ignore os filhos do nó atual e vá para o próximo nó.
MoveToContent e MoveToContentAsync	Ignore os nós sem conteúdo e vá para o próximo nó de conteúdo ou para o final do arquivo. Os nós de conteúdo não incluem ProcessingInstruction, DocumentType, Comment, Whitespace, e SignificantWhitespace. Nós de conteúdo incluem texto não seja espaço em branco, CDATA, EntityReference , e EndEntity.
ReadSubtree	Ler um elemento e todos os seus filhos e retornar uma nova XmlReader instância definida como ReadState.Initial. Esse método é útil para criar limites em torno de elementos XML; por exemplo, se você quiser passar dados para outro componente para processamento e quiser limitar a quantidade de dados que o componente pode acessar.

Consulte o XmlReader.Read página de referência para obter um exemplo de navegar por meio de um nó de um de fluxo de texto por vez e exibir o tipo de cada nó.

As seções a seguir descrevem como você pode ler tipos específicos de dados, como elementos, atributos e dados tipado.

Leitura de elementos XML

A tabela a seguir lista os métodos e propriedades que o XmlReader classe fornece para processar elementos. Depois que XmlReader é posicionada em um elemento, as propriedades de nó, como Name, refletem os valores do elemento. Além dos membros descritos a seguir, alguns dos métodos e das propriedades gerais da classe XmlReader também podem ser usados para processar elementos. Por exemplo, é possível usar o método ReadInnerXml para ler o conteúdo de um elemento.

Observação

Consulte a seção 3.1 do recomendação do W3C XML 1.0 para definições de marcas de início, término marcas e marcas de elemento vazio.

Usar este XmlReader membro	Para
Método IsStartElement	Verifique se o nó atual é uma marca inicial ou uma marca de elemento vazia.
Método ReadStartElement	Verifique se o nó atual é um elemento e avança o leitor para o próximo nó (chamadas IsStartElement seguido por Read).
Método ReadEndElement	Verifique se o nó atual é uma marca final e avance o leitor para o próximo nó.
Método ReadElementString	Leia um elemento somente texto.
Método ReadToDescendant	Avance o leitor XML para o próximo elemento descendente (filho) que tem o nome especificado.
Método ReadToNextSibling	Avance o leitor XML para o próximo elemento irmão que tem o nome especificado.
Propriedade IsEmptyElement	Verifique se o elemento atual tem uma marca de elemento final. Por exemplo: - <item num="123"/> (IsEmptyElement é true.) - <item num="123"> </item> (IsEmptyElement é false, embora o conteúdo do elemento esteja vazio.)

Para obter um exemplo de leitura do conteúdo de texto dos elementos, consulte o ReadString método. O exemplo a seguir processa elementos usando um 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

Lendo atributos XML

Os atributos XML são mais comumente encontrados em elementos, mas também são permitidos em nós de tipo de documento e declaração XML.

Quando posicionado em um nó de elemento, o MoveToAttribute método permite que você passe pela lista de atributos do elemento. Observe que depois MoveToAttribute de ter sido chamado, propriedades de nó, como Name, NamespaceURIe Prefix refletir as propriedades desse atributo, não as propriedades do elemento ao qual o atributo pertence.

A XmlReader classe fornece esses métodos e propriedades para ler e processar atributos em elementos.

Usar este XmlReader membro	Para
Propriedade HasAttributes	Verifique se o nó atual tem atributos.
Propriedade AttributeCount	Obtenha o número de atributos no elemento atual.
Método MoveToFirstAttribute	Mover para o primeiro atributo em um elemento.
Método MoveToNextAttribute	Mova para o próximo atributo em um elemento.
Método MoveToAttribute	Mover para um atributo especificado.
GetAttribute método ou Item[] propriedade	Obtenha o valor de um atributo especificado.
Propriedade IsDefault	Verifique se o nó atual é um atributo que foi gerado a partir do valor padrão definido no DTD ou no esquema.
Método MoveToElement	Mova para o elemento que possui o atributo atual. Use esse método para retornar a um elemento depois de navegar por seus atributos.
Método ReadAttributeValue	Analise o valor do atributo em um ou mais Text``EntityReferencenós ou EndEntity nós.

Alguns dos métodos e propriedades gerais de XmlReader também podem ser usados para processar atributos. Por exemplo, depois que XmlReader é posicionado em um atributo, as propriedades Name e Value refletem os valores do atributo. Você também pode usar qualquer um dos métodos de conteúdo de Read para obter o valor do atributo.

Este exemplo usa a AttributeCount propriedade para navegar por todos os atributos em um elemento.

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

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

Este exemplo usa o MoveToNextAttribute método em um while loop para navegar pelos atributos.

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

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

Ler atributos em nós de declaração XML

Quando o leitor XML é posicionado em um nó de declaração XML, a Value propriedade retorna as informações de versão, autônoma e codificação como uma única cadeia de caracteres. XmlReaderobjetos criados pelo método, pela XmlTextReader classe e pela Create XmlValidatingReader classe expõem a versão, os itens autônomos e de codificação como atributos.

Ler atributos em nós de tipo de documento

Quando o leitor XML é posicionado em um nó de tipo de documento, o método e Item[] a GetAttribute propriedade podem ser usados para retornar os valores para os literais SYSTEM e PUBLIC. Por exemplo, a chamada de reader.GetAttribute("PUBLIC") retorna o valor PUBLIC.

Ler atributos em nós de instrução de processamento

Quando o XmlReader é posicionado em um nó de instrução de processamento, a propriedade Value retorna todo o conteúdo de texto. Os itens no nó de instrução de processamento não são tratados como atributos. Eles não podem ser lidos com o método ou MoveToAttribute o GetAttribute método.

Lendo conteúdo XML

A classe XmlReader inclui os membros a seguir que leem conteúdo de um arquivo XML e retornam o conteúdo como valores de cadeia de caracteres. (Para retornar tipos CLR, consulte a próxima seção.)

Usar este XmlReader membro	Para
Propriedade Value	Obtenha o conteúdo de texto do nó atual. O valor retornado depende do tipo de nó; consulte a Value página de referência para obter detalhes.
Método ReadString	Obtenha o conteúdo de um elemento ou nó de texto como uma cadeia de caracteres. Esse método interrompe o processamento de instruções e comentários. Para obter detalhes sobre como esse método lida com tipos de nó específicos, consulte a ReadString página de referência.
Métodos ReadInnerXml e ReadInnerXmlAsync	Obtenha todo o conteúdo do nó atual, incluindo a marcação, mas excluindo marcas de início e de término. Por exemplo, para: <node>this<child id="123"/></node> O ReadInnerXml retorna: this<child id="123"/>
Métodos ReadOuterXml e ReadOuterXmlAsync	Obtenha todo o conteúdo do nó atual e seus filhos, incluindo marcação e marcas de início/término. Por exemplo, para: <node>this<child id="123"/></node> O ReadOuterXml retorna: <node>this<child id="123"/></node>

Convertendo em tipos CLR

Você pode usar os membros da XmlReader classe (listados na tabela a seguir) para ler dados XML e retornar valores como tipos CLR (Common Language Runtime) em vez de cadeias de caracteres. Esses membros permitem que você obtenha valores na representação mais apropriada para sua tarefa de codificação sem precisar analisar ou converter valores de cadeia de caracteres manualmente.

• Os métodos ReadElementContentAs só podem ser chamados em tipos de nó de elemento. Esses métodos não podem ser usados em elementos que contêm os elementos filho ou o conteúdo misturado. Quando chamado, o objeto de XmlReader ler a tag de início, lê o conteúdo do elemento, e então move após a marca do elemento de extremidade. Instruções de processamento e comentários são ignorados e as entidades são expandidas.

• Os métodos ReadContentAs leem o conteúdo do texto na posição atual do leitor e, se os dados XML não tiverem informações de tipo de dados ou esquema associadas a ele, converta o conteúdo do texto no tipo de retorno solicitado. Texto, o espaço em branco, o espaço em branco significativo e seções CDATA são concatenados. Comentários e instruções de processamento são ignorados e as referências de entidade são resolvidas automaticamente.

A XmlReader classe usa as regras definidas pela recomendação W3C XML Schema Part 2: Datatypes .

Use esta XmlReader método	Para retornar esse tipo CLR
ReadContentAsBoolean e ReadElementContentAsBoolean	Boolean
ReadContentAsDateTime e ReadElementContentAsDateTime	DateTime
ReadContentAsDouble e ReadElementContentAsDouble	Double
ReadContentAsLong e ReadElementContentAsLong	Int64
ReadContentAsInt e ReadElementContentAsInt	Int32
ReadContentAsString e ReadElementContentAsString	String
ReadContentAs e ReadElementContentAs	O tipo que você especificar com o returnType parâmetro
ReadContentAsObject e ReadElementContentAsObject	O tipo mais apropriado, conforme especificado pela XmlReader.ValueType propriedade. Consulte o Suporte ao Tipo nas classes System.Xml para obter informações de mapeamento.

Se um elemento não puder ser convertido facilmente em um tipo CLR devido ao seu formato, você poderá usar um mapeamento de esquema para garantir uma conversão bem-sucedida. O exemplo a seguir usa um arquivo .xsd para converter o hire-date elemento no xs:date tipo e, em seguida, usa o ReadElementContentAsDateTime método para retornar o elemento como um DateTime objeto.

Entrada (hireDate.xml):

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

Esquema (hireDate.xsd):

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

Código:

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

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

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

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

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

Saída:

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

Programação assíncrona

A maioria dos XmlReader métodos tem equivalentes assíncronos que têm "Async" no final de seus nomes de método. Por exemplo, o equivalente ReadContentAsObject assíncrono é ReadContentAsObjectAsync.

Os métodos a seguir podem ser usados com chamadas de método assíncronas:

• GetAttribute

• MoveToAttribute

• MoveToFirstAttribute

• MoveToNextAttribute

• MoveToElement

• ReadAttributeValue

• ReadSubtree

• ResolveEntity

As seções a seguir descrevem o uso assíncrono para métodos que não têm equivalentes assíncronos.

Método ReadStartElement

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

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

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

Método ReadEndElement

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

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

Método ReadToNextSibling

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

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

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

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

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

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

    ' find the next sibling
    Dim nt As XmlNodeType
    Do

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

    Return False

End Function

Método ReadToFollowing

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

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

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

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

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

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

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

    Return False
End Function

Método ReadToDescendant

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

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

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

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

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

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

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

    Return False
End Function

Considerações sobre segurança

Considere o seguinte ao trabalhar com a XmlReader classe:

• As exceções geradas do XmlReader caminho podem revelar informações de caminho que talvez você não queira que sejam geradas em seu aplicativo. Seu aplicativo deve capturar exceções e processá-las adequadamente.

• Não habilite o processamento de DTD se você estiver preocupado com problemas de negação de serviço ou se estiver lidando com fontes não confiáveis. O processamento DTD é desabilitado por padrão para XmlReader objetos criados pelo Create método.

  Se você tiver o processamento de DTD ativado, você pode usar XmlSecureResolver para restringir os recursos que XmlReader pode acessar. Você também pode projetar seu aplicativo para que o processamento XML seja de memória e tempo restritos. Por exemplo, você pode configurar limites de tempo limite em seu aplicativo ASP.NET.

• Os dados XML podem incluir referências a recursos externos como um arquivo de esquema. Por padrão, os recursos externos são resolvidos usando um XmlUrlResolver objeto sem credenciais de usuário. Você pode proteger este adicional seguindo um destes procedimentos:

  • Restringir os recursos que XmlReader pode acessar definindo a propriedade de XmlReaderSettings.XmlResolver a um objeto de XmlSecureResolver .

  • Não permita que XmlReader abra os recursos externos definindo a propriedade de XmlReaderSettings.XmlResolver a null.

• Os ProcessInlineSchema sinalizadores de validação e ProcessSchemaLocation de um XmlReaderSettings objeto não são definidos por padrão. Isso ajuda a proteger contra ataques XmlReader baseados esquema- quando está processando dados de uma fonte não confiável. Quando esses sinalizadores são definidos, XmlResolver do objeto de XmlReaderSettings é usado para resolver os locais de esquema encontrados no documento de instância em XmlReader. Se a XmlResolver propriedade estiver definida comonull, os locais de esquema não serão resolvidos mesmo se os sinalizadores e ProcessSchemaLocation de ProcessInlineSchema validação estiverem definidos.

  Os esquemas adicionados durante a validação adicionar novos tipos e podem alterar o resultado de validação de documento que está sendo validada. Como resultado, os esquemas externos só devem ser resolvidos de fontes confiáveis.

  É recomendável desabilitar o ProcessIdentityConstraints sinalizador ao validar documentos XML grandes e não confiáveis em cenários de alta disponibilidade em relação a um esquema que tenha restrições de identidade em grande parte do documento. Esse sinalizador está habilitado por padrão.

• Os dados XML podem conter um grande número de declarações de atributos, namespace, elementos aninhados e assim por diante que exigem um montante considerável de tempo de processamento. Para limitar o tamanho da entrada que é enviada para o XmlReader, você pode:

  • Limite o tamanho do documento definindo a MaxCharactersInDocument propriedade.

  • Limite o número de caracteres resultantes da expansão de entidades definindo a MaxCharactersFromEntities propriedade.

  • Criar uma implementação personalizada IStream para o XmlReader.

• O ReadValueChunk método pode ser usado para lidar com grandes fluxos de dados. Este método lê um pequeno número de caracteres de cada vez em vez de atribuir uma única cadeia de caracteres para o valor inteiro.

• Ao ler um documento XML com um grande número de nomes locais exclusivos, namespaces ou prefixos, pode ocorrer um problema. Se você estiver usando uma classe que deriva de XmlReader, e você chamar o LocalName, Prefixou NamespaceURI propriedade para cada item, a cadeia de caracteres retornada será adicionada a um NameTable. A coleção mantida pelo NameTable nunca diminui de tamanho, criando um vazamento de memória virtual das alças de cadeia de caracteres. Uma mitigação para isso é derivar da NameTable classe e impor uma cota de tamanho máximo. (Não há como impedir o uso de um NameTableou alternar quando NameTable estiver cheio). Outra mitigação é evitar o uso das propriedades mencionadas e, em vez disso, usar o MoveToAttribute método com o IsStartElement método sempre que possível; esses métodos não retornam cadeias de caracteres e, portanto, evitam o problema de preenchimento excessivo da NameTable coleção.

• os objetos deXmlReaderSettings podem conter informações sigilosas como credenciais do usuário. Um componente não confiável pode usar o objeto de XmlReaderSettings e suas credenciais de usuário para criar objetos de XmlReader para ler dados. Tenha cuidado ao armazenar objetos em cache XmlReaderSettings ou ao passar o XmlReaderSettings objeto de um componente para outro.

• Aceitar componentes de suporte, como NameTable, XmlNamespaceManager, e objetos de XmlResolver , de uma fonte não confiável.

Construtores

XmlReader()

Inicializa uma nova instância da classe XmlReader.

Propriedades

AttributeCount	Quando substituído em uma classe derivada, obtém o número de atributos no nó atual.
BaseURI	Quando substituído em uma classe derivada, obtém o URI base do nó atual.
CanReadBinaryContent	Obtém um valor que indica se o XmlReader implementa os métodos de leitura de conteúdo binário.
CanReadValueChunk	Obtém um valor que indica se o XmlReader implementa o método ReadValueChunk(Char[], Int32, Int32).
CanResolveEntity	Obtém um valor que indica se este leitor pode analisar e resolver entidades.
Depth	Quando é substituído em uma classe derivada, obtém a profundidade do nó atual no documento XML.
EOF	Quando substituído em uma classe derivada, obtém um valor que indica se o leitor está posicionado no final do fluxo.
HasAttributes	Obtém um valor que indica se o nó atual tem atributos.
HasValue	Quando substituído em uma classe derivada, obtém um valor que indica se o nó atual pode ter um Value.
IsDefault	Quando substituído em uma classe derivada, obtém um valor que indica se o nó atual é um atributo que foi gerado com base no valor padrão definido no DTD ou no esquema.
IsEmptyElement	Quando substituído em uma classe derivada, obtém um valor que indica se o nó atual é um elemento vazio (por exemplo, <MyElement/>).
Item[Int32]	Quando substituído em uma classe derivada, obtém o valor do atributo com o índice especificado.
Item[String, String]	Quando substituído em uma classe derivada, obtém o valor do atributo com o LocalName e o NamespaceURI especificados.
Item[String]	Quando substituído em uma classe derivada, obtém o valor do atributo com o Name especificado.
LocalName	Quando é substituído em uma classe derivada, obtém o nome local do nó atual.
Name	Quando é substituído em uma classe derivada, obtém o nome qualificado do nó atual.
NamespaceURI	Quando substituído em uma classe derivada, obtém o URI do namespace (conforme definido na especificação de Namespace do W3C) do nó no qual o leitor está posicionado.
NameTable	Quando substituído em uma classe derivada, obtém o XmlNameTable associado a essa implementação.
NodeType	Quando é substituído em uma classe derivada, obtém o tipo do nó atual.
Prefix	Quando substituído em uma classe derivada, obtém o prefixo de namespace associado com o nó atual.
QuoteChar	Quando substituído em uma classe derivada, obtém o caractere de aspas usado para circunscrever o valor de um nó de atributo.
ReadState	Quando substituído em uma classe derivada, obtém o estado do leitor.
SchemaInfo	Obtém as informações de esquema que foram atribuídas ao nó atual como resultado da validação de esquema.
Settings	Obtém o objeto XmlReaderSettings usado para criar essa instância XmlReader.
Value	Quando é substituído em uma classe derivada, obtém o valor do texto do nó atual.
ValueType	Obtém o tipo CLR (Common Language Runtime) para o nó atual.
XmlLang	Quando substituído em uma classe derivada, obtém o escopo xml:lang atual.
XmlSpace	Quando substituído em uma classe derivada, obtém o escopo xml:space atual.

Métodos

Close()	Quando substituído em uma classe derivada, altera o ReadState para Closed.
Create(Stream)	Cria uma nova instância XmlReader usando o fluxo especificado com as configurações padrão.
Create(Stream, XmlReaderSettings)	Cria uma nova instância XmlReader com as configurações e o fluxo especificado.
Create(Stream, XmlReaderSettings, String)	Cria uma nova instância XmlReader usando o fluxo, o URI base e as configurações especificadas.
Create(Stream, XmlReaderSettings, XmlParserContext)	Cria uma nova instância XmlReader usando as informações de fluxo, configurações e contexto especificadas para análise.
Create(String)	Cria uma nova instância XmlReader com o URI especificado.
Create(String, XmlReaderSettings)	Cria uma nova instância XmlReader usando o URI e as configurações especificados.
Create(String, XmlReaderSettings, XmlParserContext)	Cria uma nova instância XmlReader usando as informações de URI, de configurações e de contexto especificadas para análise.
Create(TextReader)	Cria uma nova instância de XmlReader usando o leitor de texto especificado.
Create(TextReader, XmlReaderSettings)	Cria uma nova instância do XmlReader usando as configurações e o leitor de texto especificados.
Create(TextReader, XmlReaderSettings, String)	Cria uma nova instância XmlReader usando o leitor de texto especificado, as configurações e o URI base.
Create(TextReader, XmlReaderSettings, XmlParserContext)	Cria uma nova instância XmlReader usando as informações de contexto, de configurações e do leitor de texto especificadas para análise.
Create(XmlReader, XmlReaderSettings)	Cria uma nova instância XmlReader usando as configurações e o leitor XML especificados.
Dispose()	Libera todos os recursos usados pela instância atual da classe XmlReader.
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo XmlReader e opcionalmente libera os recursos gerenciados.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetAttribute(Int32)	Quando substituído em uma classe derivada, obtém o valor do atributo com o índice especificado.
GetAttribute(String)	Quando substituído em uma classe derivada, obtém o valor do atributo com o Name especificado.
GetAttribute(String, String)	Quando substituído em uma classe derivada, obtém o valor do atributo com o LocalName e o NamespaceURI especificados.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
GetValueAsync()	Obtém o valor do nó atual de forma assíncrona.
IsName(String)	Retorna um valor que indica se o argumento de cadeia de caracteres é um nome XML válido.
IsNameToken(String)	Retorna um valor que indica se o argumento de cadeia de caracteres é um token de nome XML válido.
IsStartElement()	Chama MoveToContent() e testa se o nó de conteúdo atual é uma marca de início ou uma marca de elemento vazia.
IsStartElement(String)	Chama MoveToContent() e testa se o nó de conteúdo atual é uma marca de início ou uma marca de elemento vazio e se a propriedade Name que o elemento encontrou corresponde ao argumento fornecido.
IsStartElement(String, String)	Chama MoveToContent() e testa se o nó de conteúdo atual é uma marca de início ou uma marca de elemento vazio e, se as propriedades LocalName e NamespaceURI do elemento encontrado correspondem às cadeias de caracteres fornecidas.
LookupNamespace(String)	Quando substituído em uma classe derivada, resolve um prefixo de namespace no escopo do elemento atual.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
MoveToAttribute(Int32)	Quando substituído em uma classe derivada, é movido para o atributo com o índice especificado.
MoveToAttribute(String)	Quando substituído em uma classe derivada, é movido para o atributo com o Name especificado.
MoveToAttribute(String, String)	Quando substituído em uma classe derivada, passa para o atributo com os LocalName e NamespaceURI especificados.
MoveToContent()	Verifica se o nó atual é um nó de conteúdo (texto sem espaço em branco, CDATA, Element, EndElement, EntityReference ou EndEntity). Se o nó não for um nó de conteúdo, o leitor avançará para o próximo nó de conteúdo ou para o final do arquivo. Pula nós de tipo seguir: ProcessingInstruction, DocumentType, Comment, Whitespace, ou SignificantWhitespace.
MoveToContentAsync()	Verifica de forma assíncrona se o nó atual é um nó de conteúdo. Se o nó não for um nó de conteúdo, o leitor avançará para o próximo nó de conteúdo ou para o final do arquivo.
MoveToElement()	Quando substituído em uma classe derivada, move para o elemento que contém o nó de atributo atual.
MoveToFirstAttribute()	Quando substituído em uma classe derivada, move o primeiro atributo.
MoveToNextAttribute()	Quando substituído em uma classe derivada, vai para o atributo seguinte.
Read()	Quando substituído em uma classe derivada, lê o próximo nó do fluxo.
ReadAsync()	Lê assincronamente o próximo nó do fluxo.
ReadAttributeValue()	Quando substituído em uma classe derivada, analisa o valor do atributo em um ou mais nós Text, EntityReference ou EndEntity.
ReadContentAs(Type, IXmlNamespaceResolver)	Lê o conteúdo como um objeto do tipo especificado.
ReadContentAsAsync(Type, IXmlNamespaceResolver)	Lê de forma assíncrona o conteúdo como um objeto do tipo especificado.
ReadContentAsBase64(Byte[], Int32, Int32)	Lê o conteúdo e retorna os bytes binários decodificados de Base64.
ReadContentAsBase64Async(Byte[], Int32, Int32)	Lê de forma assíncrona o conteúdo e retorna que os bytes binários decodificados de Base64.
ReadContentAsBinHex(Byte[], Int32, Int32)	Lê o conteúdo e retorna os bytes binários decodificados BinHex.
ReadContentAsBinHexAsync(Byte[], Int32, Int32)	Lê de forma assíncrona o conteúdo e retorna os bytes binários decodificados BinHex.
ReadContentAsBoolean()	Lê o conteúdo de texto na posição atual como um Boolean.
ReadContentAsDateTime()	Lê o conteúdo de texto na posição atual como um objeto DateTime.
ReadContentAsDateTimeOffset()	Lê o conteúdo de texto na posição atual como um objeto DateTimeOffset.
ReadContentAsDecimal()	Lê o conteúdo de texto na posição atual como um objeto Decimal.
ReadContentAsDouble()	Lê o conteúdo de texto na posição atual como um número de ponto flutuante de precisão dupla.
ReadContentAsFloat()	Lê o conteúdo de texto na posição atual como um número de ponto flutuante de precisão simples.
ReadContentAsInt()	Lê o conteúdo de texto na posição atual como um inteiro com sinal de 32 bits.
ReadContentAsLong()	Lê o conteúdo de texto na posição atual como um inteiro com sinal de 64 bits.
ReadContentAsObject()	Lê o conteúdo do texto na posição atual como um Object.
ReadContentAsObjectAsync()	Lê de forma assíncrona o conteúdo do texto na posição atual como um Object.
ReadContentAsString()	Lê o conteúdo de texto na posição atual como um objeto String.
ReadContentAsStringAsync()	Lê de forma assíncrona o conteúdo do texto na posição atual como um objeto String.
ReadElementContentAs(Type, IXmlNamespaceResolver)	Lê o conteúdo do elemento como o tipo solicitado.
ReadElementContentAs(Type, IXmlNamespaceResolver, String, String)	Verifica se o nome local e o URI de namespace especificados são iguais aos do elemento atual e, em seguida, lê o conteúdo do elemento atual como o tipo solicitado.
ReadElementContentAsAsync(Type, IXmlNamespaceResolver)	Lê de forma assíncrona o conteúdo do elemento como o tipo solicitado.
ReadElementContentAsBase64(Byte[], Int32, Int32)	Lê o elemento e decodifica o conteúdo de Base64.
ReadElementContentAsBase64Async(Byte[], Int32, Int32)	Lê de forma assíncrona o elemento e decodifica o conteúdo Base64.
ReadElementContentAsBinHex(Byte[], Int32, Int32)	Lê o elemento e decodifica o conteúdo de BinHex.
ReadElementContentAsBinHexAsync(Byte[], Int32, Int32)	Lê de forma assíncrona o elemento e decodifica o conteúdo BinHex.
ReadElementContentAsBoolean()	Lê o elemento atual e retorna o conteúdo como um objeto Boolean.
ReadElementContentAsBoolean(String, String)	Verifica se o nome do local especificado e o URI de namespace correspondem àqueles do elemento atual, em seguida, lê o elemento atual e retorna o conteúdo como um objeto Boolean.
ReadElementContentAsDateTime()	Lê o elemento atual e retorna o conteúdo como um objeto DateTime.
ReadElementContentAsDateTime(String, String)	Verifica se o nome do local especificado e o URI de namespace correspondem àqueles do elemento atual, em seguida, lê o elemento atual e retorna o conteúdo como um objeto DateTime.
ReadElementContentAsDecimal()	Lê o elemento atual e retorna o conteúdo como um objeto Decimal.
ReadElementContentAsDecimal(String, String)	Verifica se o nome do local especificado e o URI de namespace correspondem àqueles do elemento atual, em seguida, lê o elemento atual e retorna o conteúdo como um objeto Decimal.
ReadElementContentAsDouble()	Lê o elemento atual e retorna o conteúdo como um número de ponto flutuante de precisão dupla.
ReadElementContentAsDouble(String, String)	Verifica se o nome local e o URI de namespace especificados são iguais aos do elemento atual, lê o elemento atual e retorna o conteúdo como um número de ponto flutuante de precisão dupla.
ReadElementContentAsFloat()	Lê o elemento atual e retorna o conteúdo como um número de ponto flutuante de precisão simples.
ReadElementContentAsFloat(String, String)	Verifica se o nome local e o URI de namespace especificados são iguais aos do elemento atual, lê o elemento atual e retorna o conteúdo como um número de ponto flutuante de precisão simples.
ReadElementContentAsInt()	Lê o elemento atual e retorna o conteúdo como um inteiro com sinal de 32 bits.
ReadElementContentAsInt(String, String)	Verifica se o nome local e o URI de namespace especificados são iguais aos do elemento atual, lê o elemento atual e retorna o conteúdo como um inteiro com sinal de 32 bits.
ReadElementContentAsLong()	Lê o elemento atual e retorna o conteúdo como um inteiro com sinal de 64 bits.
ReadElementContentAsLong(String, String)	Verifica se o nome local e o URI de namespace especificados são iguais aos do elemento atual, lê o elemento atual e retorna o conteúdo como um inteiro com sinal de 64 bits.
ReadElementContentAsObject()	Lê o elemento atual e retorna os conteúdos como um Object.
ReadElementContentAsObject(String, String)	Verifica se o nome local e o URI de namespace especificados são iguais aos do elemento atual, lê o elemento atual e retorna o conteúdo como um Object.
ReadElementContentAsObjectAsync()	Lê de forma assíncrona o elemento atual e retorna o conteúdo como um Object.
ReadElementContentAsString()	Lê o elemento atual e retorna o conteúdo como um objeto String.
ReadElementContentAsString(String, String)	Verifica se o nome do local especificado e o URI de namespace correspondem àqueles do elemento atual, em seguida, lê o elemento atual e retorna o conteúdo como um objeto String.
ReadElementContentAsStringAsync()	Lê de forma assíncrona o elemento atual e retorna o conteúdo como um objeto String.
ReadElementString()	Lê um elemento somente texto. No entanto, é recomendável que você use o método ReadElementContentAsString() em vez disso, porque ele fornece uma maneira mais simples de lidar com essa operação.
ReadElementString(String)	Verifica se a propriedade Name do elemento encontrado corresponde à cadeia de caracteres fornecida antes de ler um elemento somente texto. No entanto, é recomendável que você use o método ReadElementContentAsString() em vez disso, porque ele fornece uma maneira mais simples de lidar com essa operação.
ReadElementString(String, String)	Verifica se as propriedades LocalName e NamespaceURI do elemento encontrado correspondem às cadeias de caracteres fornecidas antes de ler um elemento somente de texto. No entanto, é recomendável que você use o método ReadElementContentAsString(String, String) em vez disso, porque ele fornece uma maneira mais simples de lidar com essa operação.
ReadEndElement()	Verifica se o nó de conteúdo atual é uma marca de fim e avança o leitor para o próximo nó.
ReadInnerXml()	Quando substituído em uma classe derivada, lê todo o conteúdo, incluindo a marcação, como uma cadeia de caracteres.
ReadInnerXmlAsync()	Lê de forma assíncrona todo o conteúdo, inclusive a marcação, como uma cadeia de caracteres.
ReadOuterXml()	Quando substituído em uma classe derivada, lê o conteúdo, inclusive a marcação, que representa esse nó e todos os seus filhos.
ReadOuterXmlAsync()	Lê de forma assíncrona o conteúdo, inclusive a marcação, representando este nó e todos os seus filhos.
ReadStartElement()	Verifica se o nó atual é um elemento e avança o leitor para o próximo nó.
ReadStartElement(String)	Verifica se o nó de conteúdo atual é um elemento com o Name fornecido e avança o leitor para o próximo nó.
ReadStartElement(String, String)	Verifica se o nó de conteúdo atual é um elemento com o LocalName e NamespaceURI fornecidos e avança o leitor para o próximo nó.
ReadString()	Quando substituído em uma classe derivada, lê o conteúdo de um nó de elemento ou texto como uma cadeia de caracteres. No entanto, é recomendável que você use o método ReadElementContentAsString em vez disso, porque ele fornece uma maneira mais simples de lidar com essa operação.
ReadSubtree()	Retorna uma nova instância XmlReader que pode ser usada para ler o nó atual e todos os seus descendentes.
ReadToDescendant(String)	Avança o XmlReader para o próximo elemento descendente com o nome qualificado especificado.
ReadToDescendant(String, String)	Avança o XmlReader para o próximo elemento descendente com o nome local e URI do namespace especificados.
ReadToFollowing(String)	Lê até que seja encontrado um elemento com o nome qualificado especificado.
ReadToFollowing(String, String)	Lê até que seja encontrado um elemento com o nome do local e o URI do namespace especificados.
ReadToNextSibling(String)	Avança o XmlReader para o próximo elemento irmão com o nome qualificado especificado.
ReadToNextSibling(String, String)	Avança o XmlReader para o próximo elemento irmão com o nome local e o URI de namespace especificados.
ReadValueChunk(Char[], Int32, Int32)	Lê grandes fluxos de texto inseridos em um documento XML.
ReadValueChunkAsync(Char[], Int32, Int32)	Lê de forma assíncrona grandes fluxos de texto inserido em um documento XML.
ResolveEntity()	Quando substituído em uma classe derivada, resolve a referência da entidade para nós EntityReference.
Skip()	Ignora os filhos do nó atual.
SkipAsync()	Ignora de forma assíncrona os filhos do nó atual.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Implantações explícitas de interface

IDisposable.Dispose()

Para obter uma descrição desse membro, confira Dispose().

Confira também

• Documentos e dados XML