XmlReader XmlReader XmlReader XmlReader Class

Definição

Representa um leitor que fornece acesso rápido não armazenado em cache e somente de encaminhamento aos dados XML.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
Herança
XmlReaderXmlReaderXmlReaderXmlReader
Derivado
Implementações

Exemplos

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

Comentários

XmlReaderfornece acesso somente de encaminhamento e somente leitura a dados XML em um documento ou fluxo.XmlReader provides forward-only, read-only access to XML data in a document or stream. Essa classe está em conformidade com o W3C linguagem XML (XML) 1,0 (quarta edição) e os namespaces em XML 1,0 (terceira edição) recomendações.This class conforms to the W3C Extensible Markup Language (XML) 1.0 (fourth edition) and the Namespaces in XML 1.0 (third edition) recommendations.

XmlReaderos métodos permitem que você mova os dados XML e leia o conteúdo de um nó.XmlReader methods let you move through XML data and read the contents of a node. As propriedades da classe refletem o valor do nó atual, que é onde o leitor é posicionado. O ReadState valor da propriedade indica o estado atual do leitor de 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 exemplo, a propriedade é definida como ReadState.Initial XmlReader.Read pelo método e ReadState.Closed pelo XmlReader.Close método.For example, the property is set to ReadState.Initial by the XmlReader.Read method and ReadState.Closed by the XmlReader.Close method. XmlReadertambém fornece verificações de conformidade de dados e validação em um DTD ou esquema.XmlReader also provides data conformance checks and validation against a DTD or schema.

XmlReaderusa um modelo de pull para recuperar dados.XmlReader uses a pull model to retrieve data. Este modelo:This model:

  • Simplifica o gerenciamento de estado por um ajuste de procedimento natural e de cima para baixo.Simplifies state management by a natural, top-down procedural refinement.

  • Dá suporte a vários fluxos de entrada e camadas.Supports multiple input streams and layering.

  • Permite que o cliente dê 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.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.

  • Dá suporte ao processamento seletivo.Supports selective processing. O cliente pode ignorar itens e processar os que são de interesse para o aplicativo.The client can skip items and process those that are of interest to the application. Você também pode definir propriedades com antecedência para gerenciar como o fluxo XML é processado (por exemplo, normalização).You can also set properties in advance to manage how the XML stream is processed (for example, normalization).

Nesta seção:In this section:

Criando um leitor de XML Creating an XML reader
Validando dados XML Validating XML data
Conformidade de dados Data conformance
Navegando pelos nós Navigating through nodes
Lendo elementos XML Reading XML elements
Lendo atributos XML Reading XML attributes
Lendo conteúdo XML Reading XML content
Convertendo para tipos CLR Converting to CLR types
Programação assíncrona Asynchronous programming
Considerações sobre segurançaSecurity considerations

Criando um leitor de XMLCreating an XML reader

Use o Create método para criar uma XmlReader instância.Use the Create method to create an XmlReader instance.

Embora o .NET Framework forneça implementações concretas XmlReader da classe, como as XmlTextReader XmlValidatingReader classes XmlNodeReader, e, recomendamos que você use as classes especializadas somente nesses cenários: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:

  • Quando você quiser ler uma subárvore DOM XML de um XmlNode objeto, use a XmlNodeReader classe.When you want to read an XML DOM subtree from an XmlNode object, use the XmlNodeReader class. (No entanto, essa classe não dá suporte à validação de DTD ou de esquema.)(However, this class doesn't support DTD or schema validation.)

  • Se você precisar expandir entidades na solicitação, não deseja que o conteúdo do texto seja normalizado, ou você não deseja que os atributos padrão XmlTextReader sejam retornados, use a classe.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 o conjunto de recursos que você deseja habilitar no leitor de XML, passe um System.Xml.XmlReaderSettings objeto para o Create método.To specify the set of features you want to enable on the XML reader, pass an System.Xml.XmlReaderSettings object to the Create method. 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.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. Você também pode adicionar facilmente recursos a um leitor existente.You can also easily add features to an existing reader.

Se você não usar um System.Xml.XmlReaderSettings objeto, as configurações padrão serão usadas.If you don't use a System.Xml.XmlReaderSettings object, default settings are used. Consulte a Create página de referência para obter detalhes.See the Create reference page for details.

XmlReadergera um XmlException em erros de análise XML.XmlReader throws an XmlException on XML parse errors. Depois que uma exceção é lançada, o estado do leitor não é previsível.After an exception is thrown, the state of the reader is not predictable. Por exemplo, o tipo de nó relatado pode ser diferente do tipo de nó real do nó atual.For example, the reported node type may be different from the actual node type of the current node. Use a ReadState propriedade para verificar se o leitor está em estado de erro.Use the ReadState property to check whether the reader is in error state.

Validando dados XMLValidating XML data

Para definir a estrutura de um documento XML e suas relações de elementos, tipos de dados e restrições de conteúdo, você usa um esquema de definição de tipo de documento (DTD) ou linguagem de definição de esquema 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. Um documento XML será considerado bem formado se atender a todos os requisitos sintáticos definidos pela recomendação do W3C XML 1,0.An XML document is considered to be well formed if it meets all the syntactical requirements defined by the W3C XML 1.0 Recommendation. Ele é considerado válido se estiver bem formado e também estiver em conformidade com as restrições definidas por seu DTD ou esquema.It's considered valid if it's well formed and also conforms to the constraints defined by its DTD or schema. (Consulte o esquema XML W3C parte 1: Estruturas e o esquema XML W3C parte 2: Recomendações de tipos de texto.) Portanto, embora todos os documentos XML válidos sejam bem-formados, nem todos os documentos XML bem-formados são 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.

Você pode validar os dados em um DTD, um esquema XSD embutido ou um esquema XSD armazenado em um XmlSchemaSet objeto (um cache); esses cenários são descritos na página Create de referência.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. XmlReaderNão dá suporte à validação de esquema XML-Data Reduced (XDR).XmlReader doesn't support XML-Data Reduced (XDR) schema validation.

Use as configurações a seguir na XmlReaderSettings classe para especificar o tipo de validação, se houver suporte à instância do. XmlReaderYou use the following settings on the XmlReaderSettings class to specify what type of validation, if any, the XmlReader instance supports.

Usar este XmlReaderSettings membroUse this XmlReaderSettings member Para especificarTo specify
Propriedade DtdProcessingDtdProcessing property Se o processamento de DTD deve ser permitido.Whether to allow DTD processing. O padrão é não permitir o processamento de DTD.The default is to disallow DTD processing.
Propriedade ValidationTypeValidationType property Se o leitor deve validar dados e que tipo de validação deve ser executada (DTD ou esquema).Whether the reader should validate data, and what type of validation to perform (DTD or schema). A opção não é possível validação de dados.The default is no data validation.
Evento ValidationEventHandlerValidationEventHandler event Um manipulador de eventos para receber informações sobre eventos de validação.An event handler for receiving information about validation events. Se um manipulador de eventos não for fornecido, XmlException será apresentada no primeiro erro de validação.If an event handler is not provided, an XmlException is thrown on the first validation error.
Propriedade ValidationFlagsValidationFlags property Opções de validação adicionais por XmlSchemaValidationFlags meio dos membros da enumeração:Additional validation options through the XmlSchemaValidationFlags enumeration members:

- AllowXmlAttributes-Permite atributos XML (xml:*) em documentos de instância, mesmo quando eles não estiverem definidos no esquema.- AllowXmlAttributes-- Allow XML attributes (xml:*) in instance documents even when they're not defined in the schema. Os atributos são validados com base no tipo de dados.The attributes are validated based on their data type. Consulte a XmlSchemaValidationFlags página de referência para a configuração a ser usada em cenários específicos.See the XmlSchemaValidationFlags reference page for the setting to use in specific scenarios. (Desabilitado por padrão.)(Disabled by default.)
- - restrições de identidade de processo (ProcessIdentityConstraints, xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) encontrados durante a validação.- ProcessIdentityConstraints --Process identity constraints (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) encountered during validation. (Habilitado por padrão.)(Enabled by default.)
- ProcessSchemaLocation--Processar esquemas especificados pelo xsi:schemaLocation atributo ou. xsi:noNamespaceSchemaLocation- ProcessSchemaLocation --Process schemas specified by the xsi:schemaLocation or xsi:noNamespaceSchemaLocation attribute. (Habilitado por padrão.)(Enabled by default.)
- ProcessInlineSchema– Processe embutido esquemas XML durante a validação.- ProcessInlineSchema-- Process inline XML Schemas during validation. (Desabilitado por padrão.)(Disabled by default.)
- ReportValidationWarnings– Relatar eventos se ocorrer um aviso de validação.- ReportValidationWarnings--Report events if a validation warning occurs. Um aviso é emitida normalmente quando não há nenhum DTD ou esquema XML para validar um elemento ou atributo específico contra.A warning is typically issued when there is no DTD or XML Schema to validate a particular element or attribute against. ValidationEventHandler é usado para notificação.The ValidationEventHandler is used for notification. (Desabilitado por padrão.)(Disabled by default.)
Schemas O XmlSchemaSet a ser usado para validação.The XmlSchemaSet to use for validation.
Propriedade XmlResolverXmlResolver property O XmlResolver para resolver e acessar recursos externos.The XmlResolver for resolving and accessing external resources. Isso pode incluir entidades externas, como o DTD e esquemas e qualquer xs:include ou xs:import elementos contidos no 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. Se você não especificar um XmlResolver, o XmlReader usa um padrão XmlUrlResolver sem credenciais do usuário.If you don't specify an XmlResolver, the XmlReader uses a default XmlUrlResolver with no user credentials.

Conformidade de dadosData conformance

Os leitores XML que são criados pelo Create método cumprir os seguintes requisitos de conformidade por padrão:XML readers that are created by the Create method meet the following compliance requirements by default:

  • Novas linhas e o valor de atributo são normalizados de acordo com o W3C recomendação XML 1.0.New lines and attribute value are normalized according to the W3C XML 1.0 Recommendation.

  • Todas as entidades são expandidas automaticamente.All entities are automatically expanded.

  • Atributos padrão declarados na definição de tipo de documento são sempre adicionados mesmo quando o leitor não é validado.Default attributes declared in the document type definition are always added even when the reader doesn't validate.

  • A declaração do prefixo XML mapeado para o URI de namespace XML correto é permitida.Declaration of XML prefix mapped to the correct XML namespace URI is allowed.

  • 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.The notation names in a single NotationType attribute declaration and NmTokens in a single Enumeration attribute declaration are distinct.

Use essas XmlReaderSettings Propriedades para especificar o tipo de verificações de conformidade que você deseja habilitar:Use these XmlReaderSettings properties to specify the type of conformance checks you want to enable:

Use esta XmlReaderSettings propriedadeUse this XmlReaderSettings property ParaTo PadrãoDefault
Propriedade CheckCharactersCheckCharacters property Habilitar ou desabilitar verificações para o seguinte:Enable or disable checks for the following:

-Os caracteres estão dentro do intervalo de caracteres XML legais, conforme definido pela seção 2,2 caracteres da recomendação do W3C XML 1,0.- 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 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.- All XML names are valid, as defined by the 2.3 Common Syntactic Constructs section of the W3C XML 1.0 Recommendation.

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).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).
A verificação de caracteres e nomes está habilitada.Character and name checking is enabled.

A definição de CheckCharacters como false desativa a verificação de caracteres em referências de entidade de caracteres.Setting CheckCharacters to false turns off character checking for character entity references. Se o leitor estiver processando dados de texto, ele sempre verificará se os nomes de XML são válidos, independentemente dessa configuração.If the reader is processing text data, it always checks that XML names are valid, regardless of this setting. Observação: A recomendação XML 1,0 requer compatibilidade de um documento nível quando um DTD presente.Note: The XML 1.0 recommendation requires document-level conformance when a DTD is present. Portanto, se o leitor está configurado para suportar ConformanceLevel.Fragment, mas os dados XML contêm um document type definition (DTD), um XmlException é gerada.Therefore, if the reader is configured to support ConformanceLevel.Fragment, but the XML data contains a document type definition (DTD), an XmlException is thrown.
Propriedade ConformanceLevelConformanceLevel property Escolha o nível de conformidade a ser aplicado:Choose the level of conformance to enforce:

- Document.- Document. Está em conformidade com as regras para um documento XML bem formado 1,0.Conforms to the rules for a well-formed XML 1.0 document.
- Fragment.- Fragment. Está de acordo com as regras para um fragmento de documento bem formado que pode ser consumido como uma entidade analisada externa.Conforms to the rules for a well-formed document fragment that can be consumed as an external parsed entity.
- Auto.- Auto. Está em conformidade com o nível decidido pelo leitor.Conforms to the level decided by the reader.

Se os dados não estiverem em conformidade, um XmlException exceção é lançada.If the data isn't in conformance, an XmlException exception is thrown.
Document

O nó atual é o nó XML no qual o leitor de XML está posicionado no momento.The current node is the XML node on which the XML reader is currently positioned. 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.All XmlReader methods perform operations in relation to this node, and all XmlReader properties reflect the value of the current node.

Os métodos a seguir facilitam a navegação por nós e a análise de dados.The following methods make it easy to navigate through nodes and parse data.

Use esta XmlReaderSettings métodoUse this XmlReaderSettings method ParaTo
Read Leia o primeiro nó e avance pelo fluxo um nó por vez.Read the first node, and advance through the stream one node at a time. Essas chamadas são normalmente executadas dentro uma while loop.Such calls are typically performed inside a while loop.

Use o NodeType propriedade para obter o tipo (por exemplo, atributo, comentário, elemento e assim por diante) do nó atual.Use the NodeType property to get the type (for example, attribute, comment, element, and so on) of the current node.
Skip Ignore os filhos do nó atual e mova para o próximo nó.Skip the children of the current node and move to the next node.
MoveToContent e MoveToContentAsyncMoveToContent and MoveToContentAsync Ignore os nós que não são de conteúdo e mova para o próximo nó de conteúdo ou para o final do arquivo.Skip non-content nodes and move to the next content node or to the end of the file.

Os nós de conteúdo não incluem ProcessingInstruction, DocumentType, Comment, Whitespace, e SignificantWhitespace.Non-content nodes include ProcessingInstruction, DocumentType, Comment, Whitespace, and SignificantWhitespace.

Nós de conteúdo incluem texto não seja espaço em branco, CDATA, EntityReference , e EndEntity.Content nodes include non-white space text, CDATA, EntityReference , and EndEntity.
ReadSubtree Ler um elemento e todos os seus filhos e retornar uma nova XmlReader instância definida como ReadState.Initial.Read an element and all its children, and return a new XmlReader instance set to ReadState.Initial.

Esse método é útil para criar limites em elementos XML; por exemplo, se você quiser passar dados para outro componente para processamento e desejar limitar a quantidade de dados que o componente pode acessar.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.

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ó.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.

As seções a seguir descrevem como você pode ler tipos específicos de dados, como elementos, atributos e dados tipados.The following sections describe how you can read specific types of data, such as elements, attributes, and typed data.

Lendo elementos XMLReading XML elements

A tabela a seguir lista os métodos e propriedades que o XmlReader classe fornece para processar elementos.The following table lists the methods and properties that the XmlReader class provides for processing elements. Depois que XmlReader é posicionada em um elemento, as propriedades de nó, como Name, refletem os valores do elemento.After the XmlReader is positioned on an element, the node properties, such as Name, reflect the element values. 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.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 exemplo, é possível usar o método ReadInnerXml para ler o conteúdo de um elemento.For example, you can use the ReadInnerXml method to read the contents of an element.

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.See section 3.1 of the W3C XML 1.0 Recommendation for definitions of start tags, end tags, and empty element tags.

Usar este XmlReader membroUse this XmlReader member ParaTo
Método IsStartElementIsStartElement method Verifique se o nó atual é uma marca de início ou um elemento vazio.Check if the current node is a start tag or an empty element tag.
Método ReadStartElementReadStartElement method Verifique se o nó atual é um elemento e avança o leitor para o próximo nó (chamadas IsStartElement seguido por 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 Verifique se o nó atual é uma marca de fim e avance o leitor para o próximo nó.Check that the current node is an end tag and advance the reader to the next node.
Método ReadElementStringReadElementString method Ler um elemento somente texto.Read a text-only element.
Método ReadToDescendantReadToDescendant method Avance o leitor de XML para o próximo elemento descendente (filho) que tem o nome especificado.Advance the XML reader to the next descendant (child) element that has the specified name.
Método ReadToNextSiblingReadToNextSibling method Avance o leitor de XML para o próximo elemento irmão que tem o nome especificado.Advance the XML reader to the next sibling element that has the specified name.
Propriedade IsEmptyElementIsEmptyElement property Verifique se o elemento atual tem uma marca de elemento final.Check if the current element has an end element tag. Por exemplo:For example:

- <item num="123"/>(IsEmptyElement étrue.)- <item num="123"/> (IsEmptyElement is true.)
- <item num="123"> </item>(IsEmptyElement éfalse, embora o conteúdo do elemento esteja vazio.)- <item num="123"> </item> (IsEmptyElement is false, although the element's content is empty.)

Para obter um exemplo de leitura do conteúdo de texto dos elementos, ReadString consulte o método.For an example of reading the text content of elements, see the ReadString method. O exemplo a seguir processa os elementos usando while um loop.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

Lendo atributos XMLReading XML attributes

Os atributos XML são mais comumente encontrados em elementos, mas também são permitidos na declaração XML e nós de tipo de documento.XML attributes are most commonly found on elements, but they're also allowed on XML declaration and document type nodes.

Quando posicionado em um nó de elemento MoveToAttribute , o método permite que você percorra a lista de atributos do elemento.When positioned on an element node, the MoveToAttribute method lets you go through the attribute list of the element. Observe que After MoveToAttribute foi chamado, as propriedades de nó, Namecomo NamespaceURI, e Prefix refletem as propriedades desse atributo, não as propriedades do elemento ao qual o atributo pertence.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.

A XmlReader classe fornece esses métodos e propriedades para ler e processar atributos em elementos.The XmlReader class provides these methods and properties to read and process attributes on elements.

Usar este XmlReader membroUse this XmlReader member ParaTo
Propriedade HasAttributesHasAttributes property Verifique se o nó atual tem algum atributo.Check whether the current node has any attributes.
Propriedade AttributeCountAttributeCount property Obtém o número de atributos no elemento atual.Get the number of attributes on the current element.
Método MoveToFirstAttributeMoveToFirstAttribute method Mover para o primeiro atributo em um elemento.Move to the first attribute in an element.
Método MoveToNextAttributeMoveToNextAttribute method Mover para o próximo atributo em um elemento.Move to the next attribute in an element.
Método MoveToAttributeMoveToAttribute method Mover para um atributo especificado.Move to a specified attribute.
GetAttributemétodo ou Item[String, String] PropriedadeGetAttribute method or Item[String, String] property Obtém o valor de um atributo especificado.Get the value of a specified attribute.
Propriedade IsDefaultIsDefault property Verifique se o nó atual é um atributo que foi gerado a partir do valor padrão definido no DTD ou no 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 Mover para o elemento que possui o atributo atual.Move to the element that owns the current attribute. Use este método para retornar a um elemento depois de navegar pelos seus atributos.Use this method to return to an element after navigating through its attributes.
Método ReadAttributeValueReadAttributeValue method Analise o valor do atributo em um ou Textmais EntityReferencenós, EndEntity ou.Parse the attribute value into one or more Text, EntityReference, or EndEntity nodes.

Alguns dos métodos e propriedades gerais de XmlReader também podem ser usados para processar atributos.Any of the general XmlReader methods and properties can also be used to process attributes. Por exemplo, depois que XmlReader é posicionado em um atributo, as propriedades Name e Value refletem os valores do atributo.For example, after the XmlReader is positioned on an attribute, the Name and Value properties reflect the values of the attribute. Você também pode usar qualquer um dos métodos de conteúdo de Read para obter o valor do atributo.You can also use any of the content Read methods to get the value of the attribute.

Este exemplo usa a AttributeCount propriedade para navegar por todos os atributos em um 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

Este exemplo usa o MoveToNextAttribute método em um while loop para navegar pelos 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

Lendo atributos em nós de declaração XMLReading attributes on XML declaration nodes

Quando o leitor de XML é posicionado em um nó de Declaração Value XML, a propriedade retorna as informações de versão, autônoma e codificação como uma única cadeia de caracteres.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. XmlReaderos objetos criados pelo Create método, a XmlTextReader classe e a XmlValidatingReader classe expõem os itens de versão, autônomo e de codificação 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.

Lendo atributos em nós de tipo de documentoReading attributes on document type nodes

Quando o leitor de XML é posicionado em um nó de tipo GetAttribute de documento Item[String, String] , o método e a propriedade podem ser usados para retornar os valores para o sistema e literais 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 exemplo, a chamada de reader.GetAttribute("PUBLIC") retorna o valor PUBLIC.For example, calling reader.GetAttribute("PUBLIC") returns the PUBLIC value.

Lendo atributos em nós de instrução de processamentoReading attributes on processing instruction nodes

Quando o XmlReader é posicionado em um nó de instrução de processamento, a propriedade Value retorna todo o conteúdo de texto.When the XmlReader is positioned on a processing instruction node, the Value property returns the entire text content. Os itens no nó de instrução de processamento não são tratados como atributos.Items in the processing instruction node aren't treated as attributes. Eles não podem ser lidos GetAttribute com MoveToAttribute o método ou.They can't be read with the GetAttribute or MoveToAttribute method.

Lendo conteúdo XMLReading XML content

A classe XMLReader inclui os membros a seguir que lêem o conteúdo de um arquivo XML e retornam o conteúdo como valores de cadeia de caracteres.The XMLReader class includes the following members that read content from an XML file and return the content as string values. (Para retornar tipos CLR, consulte a próxima seção.)(To return CLR types, see the next section.)

Usar este XmlReader membroUse this XmlReader member ParaTo
Propriedade ValueValue property Obter o conteúdo de texto do nó atual.Get the text content of the current node. O valor retornado depende do tipo de nó; consulte a Value página de referência para obter detalhes.The value returned depends on the node type; see the Value reference page for details.
Método ReadStringReadString method Obtenha o conteúdo de um elemento ou nó de texto como uma cadeia de caracteres.Get the content of an element or text node as a string. Esse método é interrompido em instruções de processamento e comentários.This method stops on processing instructions and comments.

Para obter detalhes sobre como esse método trata tipos de nó específicos, ReadString consulte a página de referência.For details on how this method handles specific node types, see the ReadString reference page.
Métodos ReadInnerXml e ReadInnerXmlAsyncReadInnerXml and ReadInnerXmlAsync methods Obter todo o conteúdo do nó atual, incluindo a marcação, mas excluindo marcas de início e de fim.Get all the content of the current node, including the markup, but excluding start and end tags. Por exemplo, para:For example, for:

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

ReadInnerXmlapresentaReadInnerXml returns:

this<child id="123"/>
Métodos ReadOuterXml e ReadOuterXmlAsyncReadOuterXml and ReadOuterXmlAsync methods Obtenha todo o conteúdo do nó atual e seus filhos, incluindo marcação e marcas de início/término.Get all the content of the current node and its children, including markup and start/end tags. Por exemplo, para:For example, for:

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

ReadOuterXmlapresentaReadOuterXml returns:

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

Convertendo para tipos CLRConverting to CLR types

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

  • Os métodos ReadElementContentAs só podem ser chamados em tipos de nó de elemento.The ReadElementContentAs methods can only be called on element node types. Esses métodos não podem ser usados em elementos que contêm os elementos filho ou o conteúdo misturado.These methods cannot be used on elements that contain child elements or mixed content. 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.When called, the XmlReader object reads the start tag, reads the element content, and then moves past the end element tag. Instruções de processamento e comentários são ignorados e as entidades são expandidas.Processing instructions and comments are ignored and entities are expanded.

  • Os métodos ReadContentAs lêem o conteúdo de texto na posição atual do leitor e, se os dados XML não tiverem informações de tipo de esquema ou de dados associados a ele, converta o conteúdo de texto para o tipo de retorno 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. Texto, o espaço em branco, o espaço em branco significativo e seções CDATA são concatenados.Text, white space, significant white space and CDATA sections are concatenated. Os comentários e as instruções de processamento são ignorados e as referências de entidade são automaticamente resolvidas.Comments and processing instructions are skipped, and entity references are automatically resolved.

A XmlReader classe usa as regras definidas pelo esquema XML W3C parte 2: Recomendação de tipos de texto.The XmlReader class uses the rules defined by the W3C XML Schema Part 2: Datatypes recommendation.

Use esta XmlReader métodoUse this XmlReader method Para retornar este tipo CLRTo return this CLR type
ReadContentAsBoolean e ReadElementContentAsBooleanReadContentAsBoolean and ReadElementContentAsBoolean Boolean
ReadContentAsDateTime e ReadElementContentAsDateTimeReadContentAsDateTime and ReadElementContentAsDateTime DateTime
ReadContentAsDouble e ReadElementContentAsDoubleReadContentAsDouble and ReadElementContentAsDouble Double
ReadContentAsLong e ReadElementContentAsLongReadContentAsLong and ReadElementContentAsLong Int64
ReadContentAsInt e ReadElementContentAsIntReadContentAsInt and ReadElementContentAsInt Int32
ReadContentAsString e ReadElementContentAsStringReadContentAsString and ReadElementContentAsString String
ReadContentAs e ReadElementContentAsReadContentAs and ReadElementContentAs O tipo que você especifica com returnType o parâmetroThe type you specify with the returnType parameter
ReadContentAsObject e ReadElementContentAsObjectReadContentAsObject and ReadElementContentAsObject O tipo mais apropriado, conforme especificado pela XmlReader.ValueType propriedade.The most appropriate type, as specified by the XmlReader.ValueType property. Consulte suporte de tipo nas classes System. xml para informações de mapeamento.See Type Support in the System.Xml Classes for mapping information.

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

Schema (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>

Auto-completarCode:

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

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

Programação assíncronaAsynchronous programming

A maioria dos XmlReader métodos tem contrapartes assíncronas que têm "Async" no final de seus nomes de método.Most of the XmlReader methods have asynchronous counterparts that have "Async" at the end of their method names. Por exemplo, o equivalente assíncrono de ReadContentAsObject é ReadContentAsObjectAsync.For example, the asynchronous equivalent of ReadContentAsObject is ReadContentAsObjectAsync.

Os métodos a seguir podem ser usados com chamadas de método assíncronas:The following methods can be used with asynchronous method calls:

As seções a seguir descrevem o uso assíncrono de métodos que não têm contrapartes assíncronas.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

Considerações sobre segurançaSecurity considerations

Considere o seguinte ao trabalhar com a XmlReader classe:Consider the following when working with the XmlReader class:

  • As exceções geradas XmlReader pelo podem divulgar informações de caminho que você talvez não queira emergir em seu aplicativo.Exceptions thrown from the XmlReader can disclose path information that you might not want bubbled up to your app. Seu aplicativo deve capturar exceções e processá-las adequadamente.Your app must catch exceptions and process them appropriately.

  • Não habilite o processamento de DTD se estiver preocupado com problemas de negação de serviço ou se estiver lidando com fontes não confiáveis.Do not enable DTD processing if you're concerned about denial of service issues or if you're dealing with untrusted sources. XmlReader OCreate processamento de DTD é desabilitado por padrão para objetos criados pelo método.DTD processing is disabled by default for XmlReader objects created by the Create method.

    Se você tiver o processamento de DTD ativado, você pode usar XmlSecureResolver para restringir os recursos que XmlReader pode acessar.If you have DTD processing enabled, you can use the XmlSecureResolver to restrict the resources that the XmlReader can access. Você também pode criar seu aplicativo para que o processamento de XML seja de memória e tempo restrito.You can also design your app so that the XML processing is memory and time constrained. Por exemplo, você pode configurar limites de tempo limite em seu aplicativo ASP.NET.For example, you can configure time-out limits in your ASP.NET app.

  • Os dados XML podem incluir referências a recursos externos como um arquivo de esquema.XML data can include references to external resources such as a schema file. Por padrão, os recursos externos são resolvidos usando XmlUrlResolver um objeto sem credenciais de usuário.By default, external resources are resolved by using an XmlUrlResolver object with no user credentials. Você pode proteger este adicional seguindo um destes procedimentos:You can secure this further by doing one of the following:

  • Os ProcessInlineSchema sinalizadores ProcessSchemaLocation de validação e de XmlReaderSettings um objeto não são definidos por padrão.The ProcessInlineSchema and ProcessSchemaLocation validation flags of an XmlReaderSettings object aren't set by default. Isso ajuda a proteger contra ataques XmlReader baseados esquema- quando está processando dados de uma fonte não confiável.This helps to protect the XmlReader against schema-based attacks when it is processing XML data from an untrusted source. 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.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. Se a XmlResolver propriedade for definida como null, os locais de esquema não serão resolvidos ProcessSchemaLocation mesmo se os sinalizadores de ProcessInlineSchema validação e estiverem definidos.If the XmlResolver property is set to null, schema locations aren't resolved even if the ProcessInlineSchema and ProcessSchemaLocation validation flags are set.

    Os esquemas adicionados durante a validação adicionar novos tipos e podem alterar o resultado de validação de documento que está sendo validada.Schemas added during validation add new types and can change the validation outcome of the document being validated. Como resultado, os esquemas externos só devem ser resolvidos de fontes confiáveis.As a result, external schemas should only be resolved from trusted sources.

    É recomendável desabilitar o ProcessIdentityConstraints sinalizador ao validar documentos XML grandes e não confiáveis em cenários de alta disponibilidade em um esquema com restrições de identidade em uma grande parte do 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. Esse sinalizador é habilitado por padrão.This flag is enabled by default.

  • 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.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 o tamanho da entrada que é enviada para o XmlReader, você pode:To limit the size of the input that is sent to the XmlReader, you can:

  • O ReadValueChunk método pode ser usado para lidar com grandes fluxos de dados.The ReadValueChunk method can be used to handle large streams of data. 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.This method reads a small number of characters at a time instead of allocating a single string for the whole value.

  • Ao ler um documento XML com um grande número de nomes locais, namespaces ou prefixos exclusivos, pode ocorrer um problema.When reading an XML document with a large number of unique local names, namespaces, or prefixes, a problem can occur. Se você estiver usando uma classe XmlReaderderivada de e chamar a LocalNamePropriedade, Prefixou NamespaceURI para cada item, a cadeia de caracteres retornada será adicionada a um 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. A coleção mantida pelo NameTable nunca diminui em tamanho, criando um vazamento de memória virtual dos identificadores de cadeia de caracteres.The collection held by the NameTable never decreases in size, creating a virtual memory leak of the string handles. Uma mitigação para isso é derivar da NameTable classe e impor uma cota de tamanho máximo.One mitigation for this is to derive from the NameTable class and enforce a maximum size quota. (Não há como evitar o uso de um NameTableou de mudar o NameTable quando estiver cheio).(There is no way to prevent the use of a NameTable, or to switch the NameTable when it is full). Outra mitigação é evitar o uso das propriedades mencionadas e, em MoveToAttribute vez disso, IsStartElement usar o método com o método onde for possível; esses métodos não retornam cadeias de caracteres NameTable e, portanto, evitam o problema de preencher a coleção.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.

  • os objetos deXmlReaderSettings podem conter informações sigilosas como credenciais do usuário.XmlReaderSettings objects can contain sensitive information such as user credentials. 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.An untrusted component could use the XmlReaderSettings object and its user credentials to create XmlReader objects to read data. Tenha cuidado ao armazenar XmlReaderSettings objetos em cache ou ao passar XmlReaderSettings o objeto de um componente para outro.Be careful when caching XmlReaderSettings objects, or when passing the XmlReaderSettings object from one component to another.

  • Aceitar componentes de suporte, como NameTable, XmlNamespaceManager, e objetos de XmlResolver , de uma fonte não confiável.Do not accept supporting components, such as NameTable, XmlNamespaceManager, and XmlResolver objects, from an untrusted source.

Construtores

XmlReader() XmlReader() XmlReader() XmlReader()

Inicializa uma nova instância da classe XmlReader.Initializes a new instance of the XmlReader class.

Propriedades

AttributeCount AttributeCount AttributeCount AttributeCount

Quando substituído em uma classe derivada, obtém o número de atributos no nó atual.When overridden in a derived class, gets the number of attributes on the current node.

BaseURI BaseURI BaseURI BaseURI

Quando substituído em uma classe derivada, obtém o URI base do nó atual.When overridden in a derived class, gets the base URI of the current node.

CanReadBinaryContent CanReadBinaryContent CanReadBinaryContent CanReadBinaryContent

Obtém um valor que indica se o XmlReader implementa os métodos de leitura de conteúdo binário.Gets a value indicating whether the XmlReader implements the binary content read methods.

CanReadValueChunk CanReadValueChunk CanReadValueChunk CanReadValueChunk

Obtém um valor que indica se o XmlReader implementa o método ReadValueChunk(Char[], Int32, Int32).Gets a value indicating whether the XmlReader implements the ReadValueChunk(Char[], Int32, Int32) method.

CanResolveEntity CanResolveEntity CanResolveEntity CanResolveEntity

Obtém um valor que indica se este leitor pode analisar e resolver entidades.Gets a value indicating whether this reader can parse and resolve entities.

Depth Depth Depth Depth

Quando é substituído em uma classe derivada, obtém a profundidade do nó atual no documento XML.When overridden in a derived class, gets the depth of the current node in the XML document.

EOF EOF EOF EOF

Quando substituído em uma classe derivada, obtém um valor que indica se o leitor está posicionado no final do fluxo.When overridden in a derived class, gets a value indicating whether the reader is positioned at the end of the stream.

HasAttributes HasAttributes HasAttributes HasAttributes

Obtém um valor que indica se o nó atual tem atributos.Gets a value indicating whether the current node has any attributes.

HasValue HasValue HasValue HasValue

Quando substituído em uma classe derivada, obtém um valor que indica se o nó atual pode ter um Value.When overridden in a derived class, gets a value indicating whether the current node can have a Value.

IsDefault IsDefault IsDefault 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.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 IsEmptyElement IsEmptyElement IsEmptyElement

Quando substituído em uma classe derivada, obtém um valor que indica se o nó atual é um elemento vazio (por exemplo, <MyElement/>).When overridden in a derived class, gets a value indicating whether the current node is an empty element (for example, <MyElement/>).

Item[Int32] Item[Int32] Item[Int32] Item[Int32]

Quando substituído em uma classe derivada, obtém o valor do atributo com o índice especificado.When overridden in a derived class, gets the value of the attribute with the specified index.

Item[String, String] Item[String, String] Item[String, String] Item[String, String]

Quando substituído em uma classe derivada, obtém o valor do atributo com o LocalName e o NamespaceURI especificados.When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

Item[String] Item[String] Item[String] Item[String]

Quando substituído em uma classe derivada, obtém o valor do atributo com o Name especificado.When overridden in a derived class, gets the value of the attribute with the specified Name.

LocalName LocalName LocalName LocalName

Quando é substituído em uma classe derivada, obtém o nome local do nó atual.When overridden in a derived class, gets the local name of the current node.

Name Name Name Name

Quando é substituído em uma classe derivada, obtém o nome qualificado do nó atual.When overridden in a derived class, gets the qualified name of the current node.

NamespaceURI NamespaceURI NamespaceURI 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.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 NameTable NameTable NameTable

Quando substituído em uma classe derivada, obtém o XmlNameTable associado a essa implementação.When overridden in a derived class, gets the XmlNameTable associated with this implementation.

NodeType NodeType NodeType NodeType

Quando é substituído em uma classe derivada, obtém o tipo do nó atual.When overridden in a derived class, gets the type of the current node.

Prefix Prefix Prefix Prefix

Quando substituído em uma classe derivada, obtém o prefixo de namespace associado com o nó atual.When overridden in a derived class, gets the namespace prefix associated with the current node.

QuoteChar QuoteChar QuoteChar QuoteChar

Quando substituído em uma classe derivada, obtém o caractere de aspas usado para circunscrever o valor de um nó de atributo.When overridden in a derived class, gets the quotation mark character used to enclose the value of an attribute node.

ReadState ReadState ReadState ReadState

Quando substituído em uma classe derivada, obtém o estado do leitor.When overridden in a derived class, gets the state of the reader.

SchemaInfo SchemaInfo SchemaInfo SchemaInfo

Obtém as informações de esquema que foram atribuídas ao nó atual como resultado da validação de esquema.Gets the schema information that has been assigned to the current node as a result of schema validation.

Settings Settings Settings Settings

Obtém o objeto XmlReaderSettings usado para criar essa instância XmlReader.Gets the XmlReaderSettings object used to create this XmlReader instance.

Value Value Value Value

Quando é substituído em uma classe derivada, obtém o valor do texto do nó atual.When overridden in a derived class, gets the text value of the current node.

ValueType ValueType ValueType ValueType

Obtém o tipo CLR (Common Language Runtime) para o nó atual.Gets The Common Language Runtime (CLR) type for the current node.

XmlLang XmlLang XmlLang XmlLang

Quando substituído em uma classe derivada, obtém o escopo xml:lang atual.When overridden in a derived class, gets the current xml:lang scope.

XmlSpace XmlSpace XmlSpace XmlSpace

Quando substituído em uma classe derivada, obtém o escopo xml:space atual.When overridden in a derived class, gets the current xml:space scope.

Métodos

Close() Close() Close() Close()

Quando substituído em uma classe derivada, altera o ReadState para Closed.When overridden in a derived class, changes the ReadState to Closed.

Create(Stream) Create(Stream) Create(Stream) Create(Stream)

Cria uma nova instância XmlReader usando o fluxo especificado com as configurações padrão.Creates a new XmlReader instance using the specified stream with default settings.

Create(Stream, XmlReaderSettings) Create(Stream, XmlReaderSettings) Create(Stream, XmlReaderSettings) Create(Stream, XmlReaderSettings)

Cria uma nova instância XmlReader com as configurações e o fluxo especificado.Creates a new XmlReader instance with the specified stream and settings.

Create(Stream, XmlReaderSettings, String) Create(Stream, XmlReaderSettings, String) Create(Stream, XmlReaderSettings, String) Create(Stream, XmlReaderSettings, String)

Cria uma nova instância XmlReader usando o fluxo, o URI base e as configurações especificadas.Creates a new XmlReader instance using the specified stream, base URI, and settings.

Create(Stream, XmlReaderSettings, XmlParserContext) Create(Stream, XmlReaderSettings, XmlParserContext) Create(Stream, XmlReaderSettings, XmlParserContext) Create(Stream, XmlReaderSettings, XmlParserContext)

Cria uma nova instância XmlReader usando as informações de fluxo, configurações e contexto especificadas para análise.Creates a new XmlReader instance using the specified stream, settings, and context information for parsing.

Create(String) Create(String) Create(String) Create(String)

Cria uma nova instância XmlReader com o URI especificado.Creates a new XmlReader instance with specified URI.

Create(String, XmlReaderSettings) Create(String, XmlReaderSettings) Create(String, XmlReaderSettings) Create(String, XmlReaderSettings)

Cria uma nova instância XmlReader usando o URI e as configurações especificados.Creates a new XmlReader instance by using the specified URI and settings.

Create(String, XmlReaderSettings, XmlParserContext) Create(String, XmlReaderSettings, XmlParserContext) Create(String, XmlReaderSettings, XmlParserContext) 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.Creates a new XmlReader instance by using the specified URI, settings, and context information for parsing.

Create(TextReader) Create(TextReader) Create(TextReader) Create(TextReader)

Cria uma nova instância de XmlReader usando o leitor de texto especificado.Creates a new XmlReader instance by using the specified text reader.

Create(TextReader, XmlReaderSettings) Create(TextReader, XmlReaderSettings) Create(TextReader, XmlReaderSettings) Create(TextReader, XmlReaderSettings)

Cria uma nova instância do XmlReader usando as configurações e o leitor de texto especificados.Creates a new XmlReader instance by using the specified text reader and settings.

Create(TextReader, XmlReaderSettings, String) Create(TextReader, XmlReaderSettings, String) Create(TextReader, XmlReaderSettings, String) Create(TextReader, XmlReaderSettings, String)

Cria uma nova instância XmlReader usando o leitor de texto especificado, as configurações e o URI base.Creates a new XmlReader instance by using the specified text reader, settings, and base URI.

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

Create(XmlReader, XmlReaderSettings) Create(XmlReader, XmlReaderSettings) Create(XmlReader, XmlReaderSettings) Create(XmlReader, XmlReaderSettings)

Cria uma nova instância XmlReader usando as configurações e o leitor XML especificados.Creates a new XmlReader instance by using the specified XML reader and settings.

Dispose() Dispose() Dispose() Dispose()

Libera todos os recursos usados pela instância atual da classe XmlReader.Releases all resources used by the current instance of the XmlReader class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Libera os recursos não gerenciados usados pelo XmlReader e opcionalmente libera os recursos gerenciados.Releases the unmanaged resources used by the XmlReader and optionally releases the managed resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAttribute(Int32) GetAttribute(Int32) GetAttribute(Int32) GetAttribute(Int32)

Quando substituído em uma classe derivada, obtém o valor do atributo com o índice especificado.When overridden in a derived class, gets the value of the attribute with the specified index.

GetAttribute(String) GetAttribute(String) GetAttribute(String) GetAttribute(String)

Quando substituído em uma classe derivada, obtém o valor do atributo com o Name especificado.When overridden in a derived class, gets the value of the attribute with the specified Name.

GetAttribute(String, String) GetAttribute(String, String) GetAttribute(String, String) GetAttribute(String, String)

Quando substituído em uma classe derivada, obtém o valor do atributo com o LocalName e o NamespaceURI especificados.When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Inherited from Object)
GetValueAsync() GetValueAsync() GetValueAsync() GetValueAsync()

Obtém o valor do nó atual de forma assíncrona.Asynchronously gets the value of the current node.

IsName(String) IsName(String) IsName(String) IsName(String)

Retorna um valor que indica se o argumento de cadeia de caracteres é um nome XML válido.Returns a value indicating whether the string argument is a valid XML name.

IsNameToken(String) IsNameToken(String) IsNameToken(String) IsNameToken(String)

Retorna um valor que indica se o argumento de cadeia de caracteres é um token de nome XML válido.Returns a value indicating whether or not the string argument is a valid XML name token.

IsStartElement() IsStartElement() IsStartElement() IsStartElement()

Chama MoveToContent() e testa se o nó de conteúdo atual é uma marca de início ou uma marca de elemento vazia.Calls MoveToContent() and tests if the current content node is a start tag or empty element tag.

IsStartElement(String) IsStartElement(String) IsStartElement(String) 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.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) IsStartElement(String, String) IsStartElement(String, String) 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.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) LookupNamespace(String) LookupNamespace(String) LookupNamespace(String)

Quando substituído em uma classe derivada, resolve um prefixo de namespace no escopo do elemento atual.When overridden in a derived class, resolves a namespace prefix in the current element's scope.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
MoveToAttribute(Int32) MoveToAttribute(Int32) MoveToAttribute(Int32) MoveToAttribute(Int32)

Quando substituído em uma classe derivada, é movido para o atributo com o índice especificado.When overridden in a derived class, moves to the attribute with the specified index.

MoveToAttribute(String) MoveToAttribute(String) MoveToAttribute(String) MoveToAttribute(String)

Quando substituído em uma classe derivada, é movido para o atributo com o Name especificado.When overridden in a derived class, moves to the attribute with the specified Name.

MoveToAttribute(String, String) MoveToAttribute(String, String) MoveToAttribute(String, String) MoveToAttribute(String, String)

Quando substituído em uma classe derivada, passa para o atributo com os LocalName e NamespaceURI especificados.When overridden in a derived class, moves to the attribute with the specified LocalName and NamespaceURI.

MoveToContent() MoveToContent() MoveToContent() MoveToContent()

Verifica se o nó atual é um nó de conteúdo (texto sem espaço em branco, CDATA, Element, EndElement, EntityReference ou EndEntity).Checks whether the current node is a content (non-white space text, CDATA, Element, EndElement, EntityReference, or EndEntity) node. 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.If the node is not a content node, the reader skips ahead to the next content node or end of file. Pula nós de tipo seguir: ProcessingInstruction, DocumentType, Comment, Whitespace, ou SignificantWhitespace.It skips over nodes of the following type: ProcessingInstruction, DocumentType, Comment, Whitespace, or SignificantWhitespace.

MoveToContentAsync() MoveToContentAsync() MoveToContentAsync() MoveToContentAsync()

Verifica de forma assíncrona se o nó atual é um nó de conteúdo.Asynchronously checks whether the current node is a content node. 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.If the node is not a content node, the reader skips ahead to the next content node or end of file.

MoveToElement() MoveToElement() MoveToElement() MoveToElement()

Quando substituído em uma classe derivada, move para o elemento que contém o nó de atributo atual.When overridden in a derived class, moves to the element that contains the current attribute node.

MoveToFirstAttribute() MoveToFirstAttribute() MoveToFirstAttribute() MoveToFirstAttribute()

Quando substituído em uma classe derivada, move o primeiro atributo.When overridden in a derived class, moves to the first attribute.

MoveToNextAttribute() MoveToNextAttribute() MoveToNextAttribute() MoveToNextAttribute()

Quando substituído em uma classe derivada, vai para o atributo seguinte.When overridden in a derived class, moves to the next attribute.

Read() Read() Read() Read()

Quando substituído em uma classe derivada, lê o próximo nó do fluxo.When overridden in a derived class, reads the next node from the stream.

ReadAsync() ReadAsync() ReadAsync() ReadAsync()

Lê assincronamente o próximo nó do fluxo.Asynchronously reads the next node from the stream.

ReadAttributeValue() ReadAttributeValue() ReadAttributeValue() ReadAttributeValue()

Quando substituído em uma classe derivada, analisa o valor do atributo em um ou mais nós Text, EntityReference ou EndEntity.When overridden in a derived class, parses the attribute value into one or more Text, EntityReference, or EndEntity nodes.

ReadContentAs(Type, IXmlNamespaceResolver) ReadContentAs(Type, IXmlNamespaceResolver) ReadContentAs(Type, IXmlNamespaceResolver) ReadContentAs(Type, IXmlNamespaceResolver)

Lê o conteúdo como um objeto do tipo especificado.Reads the content as an object of the type specified.

ReadContentAsAsync(Type, IXmlNamespaceResolver) ReadContentAsAsync(Type, IXmlNamespaceResolver) ReadContentAsAsync(Type, IXmlNamespaceResolver) ReadContentAsAsync(Type, IXmlNamespaceResolver)

Lê de forma assíncrona o conteúdo como um objeto do tipo especificado.Asynchronously reads the content as an object of the type specified.

ReadContentAsBase64(Byte[], Int32, Int32) ReadContentAsBase64(Byte[], Int32, Int32) ReadContentAsBase64(Byte[], Int32, Int32) ReadContentAsBase64(Byte[], Int32, Int32)

Lê o conteúdo e retorna os bytes binários decodificados de Base64.Reads the content and returns the Base64 decoded binary bytes.

ReadContentAsBase64Async(Byte[], Int32, Int32) ReadContentAsBase64Async(Byte[], Int32, Int32) ReadContentAsBase64Async(Byte[], Int32, Int32) ReadContentAsBase64Async(Byte[], Int32, Int32)

Lê de forma assíncrona o conteúdo e retorna que os bytes binários decodificados de Base64.Asynchronously reads the content and returns the Base64 decoded binary bytes.

ReadContentAsBinHex(Byte[], Int32, Int32) ReadContentAsBinHex(Byte[], Int32, Int32) ReadContentAsBinHex(Byte[], Int32, Int32) ReadContentAsBinHex(Byte[], Int32, Int32)

Lê o conteúdo e retorna os bytes binários decodificados BinHex.Reads the content and returns the BinHex decoded binary bytes.

ReadContentAsBinHexAsync(Byte[], Int32, Int32) ReadContentAsBinHexAsync(Byte[], Int32, Int32) ReadContentAsBinHexAsync(Byte[], Int32, Int32) ReadContentAsBinHexAsync(Byte[], Int32, Int32)

Lê de forma assíncrona o conteúdo e retorna os bytes binários decodificados BinHex.Asynchronously reads the content and returns the BinHex decoded binary bytes.

ReadContentAsBoolean() ReadContentAsBoolean() ReadContentAsBoolean() ReadContentAsBoolean()

Lê o conteúdo de texto na posição atual como um Boolean.Reads the text content at the current position as a Boolean.

ReadContentAsDateTime() ReadContentAsDateTime() ReadContentAsDateTime() ReadContentAsDateTime()

Lê o conteúdo de texto na posição atual como um objeto DateTime.Reads the text content at the current position as a DateTime object.

ReadContentAsDateTimeOffset() ReadContentAsDateTimeOffset() ReadContentAsDateTimeOffset() ReadContentAsDateTimeOffset()

Lê o conteúdo de texto na posição atual como um objeto DateTimeOffset.Reads the text content at the current position as a DateTimeOffset object.

ReadContentAsDecimal() ReadContentAsDecimal() ReadContentAsDecimal() ReadContentAsDecimal()

Lê o conteúdo de texto na posição atual como um objeto Decimal.Reads the text content at the current position as a Decimal object.

ReadContentAsDouble() ReadContentAsDouble() ReadContentAsDouble() ReadContentAsDouble()

Lê o conteúdo de texto na posição atual como um número de ponto flutuante de precisão dupla.Reads the text content at the current position as a double-precision floating-point number.

ReadContentAsFloat() ReadContentAsFloat() ReadContentAsFloat() ReadContentAsFloat()

Lê o conteúdo de texto na posição atual como um número de ponto flutuante de precisão simples.Reads the text content at the current position as a single-precision floating point number.

ReadContentAsInt() ReadContentAsInt() ReadContentAsInt() ReadContentAsInt()

Lê o conteúdo de texto na posição atual como um inteiro com sinal de 32 bits.Reads the text content at the current position as a 32-bit signed integer.

ReadContentAsLong() ReadContentAsLong() ReadContentAsLong() ReadContentAsLong()

Lê o conteúdo de texto na posição atual como um inteiro com sinal de 64 bits.Reads the text content at the current position as a 64-bit signed integer.

ReadContentAsObject() ReadContentAsObject() ReadContentAsObject() ReadContentAsObject()

Lê o conteúdo do texto na posição atual como um Object.Reads the text content at the current position as an Object.

ReadContentAsObjectAsync() ReadContentAsObjectAsync() ReadContentAsObjectAsync() ReadContentAsObjectAsync()

Lê de forma assíncrona o conteúdo do texto na posição atual como um Object.Asynchronously reads the text content at the current position as an Object.

ReadContentAsString() ReadContentAsString() ReadContentAsString() ReadContentAsString()

Lê o conteúdo de texto na posição atual como um objeto String.Reads the text content at the current position as a String object.

ReadContentAsStringAsync() ReadContentAsStringAsync() ReadContentAsStringAsync() ReadContentAsStringAsync()

Lê de forma assíncrona o conteúdo do texto na posição atual como um objeto String.Asynchronously reads the text content at the current position as a String object.

ReadElementContentAs(Type, IXmlNamespaceResolver) ReadElementContentAs(Type, IXmlNamespaceResolver) ReadElementContentAs(Type, IXmlNamespaceResolver) ReadElementContentAs(Type, IXmlNamespaceResolver)

Lê o conteúdo do elemento como o tipo solicitado.Reads the element content as the requested type.

ReadElementContentAs(Type, IXmlNamespaceResolver, String, String) ReadElementContentAs(Type, IXmlNamespaceResolver, String, String) ReadElementContentAs(Type, IXmlNamespaceResolver, String, String) 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.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) ReadElementContentAsAsync(Type, IXmlNamespaceResolver) ReadElementContentAsAsync(Type, IXmlNamespaceResolver) ReadElementContentAsAsync(Type, IXmlNamespaceResolver)

Lê de forma assíncrona o conteúdo do elemento como o tipo solicitado.Asynchronously reads the element content as the requested type.

ReadElementContentAsBase64(Byte[], Int32, Int32) ReadElementContentAsBase64(Byte[], Int32, Int32) ReadElementContentAsBase64(Byte[], Int32, Int32) ReadElementContentAsBase64(Byte[], Int32, Int32)

Lê o elemento e decodifica o conteúdo de Base64.Reads the element and decodes the Base64 content.

ReadElementContentAsBase64Async(Byte[], Int32, Int32) ReadElementContentAsBase64Async(Byte[], Int32, Int32) ReadElementContentAsBase64Async(Byte[], Int32, Int32) ReadElementContentAsBase64Async(Byte[], Int32, Int32)

Lê de forma assíncrona o elemento e decodifica o conteúdo Base64.Asynchronously reads the element and decodes the Base64 content.

ReadElementContentAsBinHex(Byte[], Int32, Int32) ReadElementContentAsBinHex(Byte[], Int32, Int32) ReadElementContentAsBinHex(Byte[], Int32, Int32) ReadElementContentAsBinHex(Byte[], Int32, Int32)

Lê o elemento e decodifica o conteúdo de BinHex.Reads the element and decodes the BinHex content.

ReadElementContentAsBinHexAsync(Byte[], Int32, Int32) ReadElementContentAsBinHexAsync(Byte[], Int32, Int32) ReadElementContentAsBinHexAsync(Byte[], Int32, Int32) ReadElementContentAsBinHexAsync(Byte[], Int32, Int32)

Lê de forma assíncrona o elemento e decodifica o conteúdo BinHex.Asynchronously reads the element and decodes the BinHex content.

ReadElementContentAsBoolean() ReadElementContentAsBoolean() ReadElementContentAsBoolean() ReadElementContentAsBoolean()

Lê o elemento atual e retorna o conteúdo como um objeto Boolean.Reads the current element and returns the contents as a Boolean object.

ReadElementContentAsBoolean(String, String) ReadElementContentAsBoolean(String, String) ReadElementContentAsBoolean(String, String) 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.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() ReadElementContentAsDateTime() ReadElementContentAsDateTime() ReadElementContentAsDateTime()

Lê o elemento atual e retorna o conteúdo como um objeto DateTime.Reads the current element and returns the contents as a DateTime object.

ReadElementContentAsDateTime(String, String) ReadElementContentAsDateTime(String, String) ReadElementContentAsDateTime(String, String) 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.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() ReadElementContentAsDecimal() ReadElementContentAsDecimal() ReadElementContentAsDecimal()

Lê o elemento atual e retorna o conteúdo como um objeto Decimal.Reads the current element and returns the contents as a Decimal object.

ReadElementContentAsDecimal(String, String) ReadElementContentAsDecimal(String, String) ReadElementContentAsDecimal(String, String) 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.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() ReadElementContentAsDouble() ReadElementContentAsDouble() ReadElementContentAsDouble()

Lê o elemento atual e retorna o conteúdo como um número de ponto flutuante de precisão dupla.Reads the current element and returns the contents as a double-precision floating-point number.

ReadElementContentAsDouble(String, String) ReadElementContentAsDouble(String, String) ReadElementContentAsDouble(String, String) 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.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() ReadElementContentAsFloat() ReadElementContentAsFloat() ReadElementContentAsFloat()

Lê o elemento atual e retorna o conteúdo como um número de ponto flutuante de precisão simples.Reads the current element and returns the contents as single-precision floating-point number.

ReadElementContentAsFloat(String, String) ReadElementContentAsFloat(String, String) ReadElementContentAsFloat(String, String) 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.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() ReadElementContentAsInt() ReadElementContentAsInt() ReadElementContentAsInt()

Lê o elemento atual e retorna o conteúdo como um inteiro com sinal de 32 bits.Reads the current element and returns the contents as a 32-bit signed integer.

ReadElementContentAsInt(String, String) ReadElementContentAsInt(String, String) ReadElementContentAsInt(String, String) 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.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() ReadElementContentAsLong() ReadElementContentAsLong() ReadElementContentAsLong()

Lê o elemento atual e retorna o conteúdo como um inteiro com sinal de 64 bits.Reads the current element and returns the contents as a 64-bit signed integer.

ReadElementContentAsLong(String, String) ReadElementContentAsLong(String, String) ReadElementContentAsLong(String, String) 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.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() ReadElementContentAsObject() ReadElementContentAsObject() ReadElementContentAsObject()

Lê o elemento atual e retorna os conteúdos como um Object.Reads the current element and returns the contents as an Object.

ReadElementContentAsObject(String, String) ReadElementContentAsObject(String, String) ReadElementContentAsObject(String, String) 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.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() ReadElementContentAsObjectAsync() ReadElementContentAsObjectAsync() ReadElementContentAsObjectAsync()

Lê de forma assíncrona o elemento atual e retorna o conteúdo como um Object.Asynchronously reads the current element and returns the contents as an Object.

ReadElementContentAsString() ReadElementContentAsString() ReadElementContentAsString() ReadElementContentAsString()

Lê o elemento atual e retorna o conteúdo como um objeto String.Reads the current element and returns the contents as a String object.

ReadElementContentAsString(String, String) ReadElementContentAsString(String, String) ReadElementContentAsString(String, 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.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() ReadElementContentAsStringAsync() ReadElementContentAsStringAsync() ReadElementContentAsStringAsync()

Lê de forma assíncrona o elemento atual e retorna o conteúdo como um objeto String.Asynchronously reads the current element and returns the contents as a String object.

ReadElementString() ReadElementString() ReadElementString() ReadElementString()

Lê um elemento somente texto.Reads a text-only element. 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.However, we recommend that you use the ReadElementContentAsString() method instead, because it provides a more straightforward way to handle this operation.

ReadElementString(String) ReadElementString(String) ReadElementString(String) ReadElementString(String)

Verifica se a propriedade Name do elemento encontrado corresponde à cadeia de caracteres fornecida antes de ler um elemento somente texto.Checks that the Name property of the element found matches the given string before reading a text-only element. 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.However, we recommend that you use the ReadElementContentAsString() method instead, because it provides a more straightforward way to handle this operation.

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

ReadEndElement() ReadEndElement() ReadEndElement() ReadEndElement()

Verifica se o nó de conteúdo atual é uma marca de fim e avança o leitor para o próximo nó.Checks that the current content node is an end tag and advances the reader to the next node.

ReadInnerXml() ReadInnerXml() ReadInnerXml() ReadInnerXml()

Quando substituído em uma classe derivada, lê todo o conteúdo, incluindo a marcação, como uma cadeia de caracteres.When overridden in a derived class, reads all the content, including markup, as a string.

ReadInnerXmlAsync() ReadInnerXmlAsync() ReadInnerXmlAsync() ReadInnerXmlAsync()

Lê de forma assíncrona todo o conteúdo, inclusive a marcação, como uma cadeia de caracteres.Asynchronously reads all the content, including markup, as a string.

ReadOuterXml() ReadOuterXml() ReadOuterXml() 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.When overridden in a derived class, reads the content, including markup, representing this node and all its children.

ReadOuterXmlAsync() ReadOuterXmlAsync() ReadOuterXmlAsync() ReadOuterXmlAsync()

Lê de forma assíncrona o conteúdo, inclusive a marcação, representando este nó e todos os seus filhos.Asynchronously reads the content, including markup, representing this node and all its children.

ReadStartElement() ReadStartElement() ReadStartElement() ReadStartElement()

Verifica se o nó atual é um elemento e avança o leitor para o próximo nó.Checks that the current node is an element and advances the reader to the next node.

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

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

ReadString() ReadString() ReadString() ReadString()

Quando substituído em uma classe derivada, lê o conteúdo de um nó de elemento ou texto como uma cadeia de caracteres.When overridden in a derived class, reads the contents of an element or text node as a string. 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.However, we recommend that you use the ReadElementContentAsString method instead, because it provides a more straightforward way to handle this operation.

ReadSubtree() ReadSubtree() ReadSubtree() ReadSubtree()

Retorna uma nova instância XmlReader que pode ser usada para ler o nó atual e todos os seus descendentes.Returns a new XmlReader instance that can be used to read the current node, and all its descendants.

ReadToDescendant(String) ReadToDescendant(String) ReadToDescendant(String) ReadToDescendant(String)

Avança o XmlReader para o próximo elemento descendente com o nome qualificado especificado.Advances the XmlReader to the next descendant element with the specified qualified name.

ReadToDescendant(String, String) ReadToDescendant(String, String) ReadToDescendant(String, String) ReadToDescendant(String, String)

Avança o XmlReader para o próximo elemento descendente com o nome local e URI do namespace especificados.Advances the XmlReader to the next descendant element with the specified local name and namespace URI.

ReadToFollowing(String) ReadToFollowing(String) ReadToFollowing(String) ReadToFollowing(String)

Lê até que seja encontrado um elemento com o nome qualificado especificado.Reads until an element with the specified qualified name is found.

ReadToFollowing(String, String) ReadToFollowing(String, String) ReadToFollowing(String, String) ReadToFollowing(String, String)

Lê até que seja encontrado um elemento com o nome do local e o URI do namespace especificados.Reads until an element with the specified local name and namespace URI is found.

ReadToNextSibling(String) ReadToNextSibling(String) ReadToNextSibling(String) ReadToNextSibling(String)

Avança o XmlReader para o próximo elemento irmão com o nome qualificado especificado.Advances the XmlReader to the next sibling element with the specified qualified name.

ReadToNextSibling(String, String) ReadToNextSibling(String, String) ReadToNextSibling(String, String) ReadToNextSibling(String, String)

Avança o XmlReader para o próximo elemento irmão com o nome local e o URI de namespace especificados.Advances the XmlReader to the next sibling element with the specified local name and namespace URI.

ReadValueChunk(Char[], Int32, Int32) ReadValueChunk(Char[], Int32, Int32) ReadValueChunk(Char[], Int32, Int32) ReadValueChunk(Char[], Int32, Int32)

Lê grandes fluxos de texto inseridos em um documento XML.Reads large streams of text embedded in an XML document.

ReadValueChunkAsync(Char[], Int32, Int32) ReadValueChunkAsync(Char[], Int32, Int32) ReadValueChunkAsync(Char[], Int32, Int32) ReadValueChunkAsync(Char[], Int32, Int32)

Lê de forma assíncrona grandes fluxos de texto inserido em um documento XML.Asynchronously reads large streams of text embedded in an XML document.

ResolveEntity() ResolveEntity() ResolveEntity() ResolveEntity()

Quando substituído em uma classe derivada, resolve a referência da entidade para nós EntityReference.When overridden in a derived class, resolves the entity reference for EntityReference nodes.

Skip() Skip() Skip() Skip()

Ignora os filhos do nó atual.Skips the children of the current node.

SkipAsync() SkipAsync() SkipAsync() SkipAsync()

Ignora de forma assíncrona os filhos do nó atual.Asynchronously skips the children of the current node.

ToString() ToString() ToString() ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Inherited from Object)

Implantações explícitas de interface

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Para obter uma descrição desse membro, consulte Dispose().For a description of this member, see Dispose().

Aplica-se a

Veja também