XmlReader Classe

Definizione

Rappresenta un lettore che fornisce accesso veloce, non in cache e di tipo forward-only ai dati XML.

public ref class XmlReader abstract : IDisposable
public ref class XmlReader abstract
public abstract class XmlReader : IDisposable
public abstract class XmlReader
type XmlReader = class
    interface IDisposable
type XmlReader = class
Public MustInherit Class XmlReader
Implements IDisposable
Public MustInherit Class XmlReader
Ereditarietà
XmlReader
Derivato
Implementazioni

Esempio

Il codice di esempio seguente illustra come usare l'API asincrona per analizzare il codice 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

Commenti

XmlReader fornisce l'accesso forward-only e di sola lettura ai dati XML in un documento o in un flusso. Questa classe è conforme alle raccomandazioni W3C Extensible Markup Language (XML) 1.0 (quarta edizione) e Spazi dei nomi in XML 1.0 (terza edizione).

XmlReader I metodi consentono di spostarsi tra i dati XML e leggere il contenuto di un nodo. Le proprietà della classe riflettono il valore del nodo corrente, ovvero la posizione del lettore. Il ReadState valore della proprietà indica lo stato corrente del lettore XML. Ad esempio, la proprietà viene ReadState.Initial impostata su dal XmlReader.Read metodo e dal metodo ReadState.Closed XmlReader.Close . XmlReader fornisce anche controlli di conformità dei dati e la convalida in base a una DTD o a uno schema.

XmlReader usa un modello pull per recuperare i dati. Questo modello:

  • Semplifica la gestione dello stato mediante un perfezionamento procedurale dall'alto verso il basso naturale.

  • Supporta più flussi di input e la strating.

  • Consente al client di assegnare al parser un buffer in cui la stringa viene scritta direttamente ed evita quindi la necessità di una copia aggiuntiva della stringa.

  • Supporta l'elaborazione selettiva. Il client può ignorare gli elementi ed elaborare quelli di interesse per l'applicazione. È anche possibile impostare le proprietà in anticipo per gestire la modalità di elaborazione del flusso XML, ad esempio la normalizzazione.

Contenuto della sezione:

Creazione di un lettore XML
Convalida dei dati XML
Conformità dei dati
Esplorazione dei nodi
Lettura di elementi XML
Lettura degli attributi XML
Lettura di contenuto XML
Conversione in tipi CLR
Programmazione asincrona
Considerazioni sulla sicurezza

Creazione di un lettore XML

Usare il Create metodo per creare XmlReader un'istanza di .

Anche se .NET Framework implementazioni concrete della classe, ad esempio , e le classi , è consigliabile usare le classi specializzate solo XmlReader XmlTextReader in questi XmlNodeReader XmlValidatingReader scenari:

  • Quando si vuole leggere un sottoalbero DOM XML da un XmlNode oggetto , usare la classe XmlNodeReader . Questa classe, tuttavia, non supporta la convalida DTD o dello schema.

  • Se è necessario espandere le entità su richiesta, non si vuole normalizzare il contenuto di testo o non si vogliono restituire attributi predefiniti, usare la XmlTextReader classe .

Per specificare il set di funzionalità da abilitare nel lettore XML, passare un System.Xml.XmlReaderSettings oggetto al Create metodo . È possibile usare un singolo oggetto per creare più lettori con la stessa funzionalità o modificare l'oggetto per creare un nuovo lettore System.Xml.XmlReaderSettings con un set diverso di System.Xml.XmlReaderSettings funzionalità. È anche possibile aggiungere facilmente funzionalità a un lettore esistente.

Se non si usa un System.Xml.XmlReaderSettings oggetto , vengono usate le impostazioni predefinite. Per informazioni Create dettagliate, vedere la pagina di riferimento.

XmlReader genera un errore XmlException di analisi XML. Dopo la generazione di un'eccezione, lo stato del lettore non è prevedibile. Ad esempio, il tipo di nodo segnalato può essere diverso dal tipo di nodo effettivo del nodo corrente. Usare la ReadState proprietà per verificare se il lettore è in stato di errore.

Convalida dei dati XML

Per definire la struttura di un documento XML e le relative relazioni tra elementi, tipi di dati e vincoli di contenuto, usare uno schema DTD (Document Type Definition) o XSD (XML Schema Definition Language). Un documento XML viene considerato ben formato se soddisfa tutti i requisiti sintattici definiti dalla raccomandazione W3C XML 1.0. È considerato valido se è ben formato e è conforme anche ai vincoli definiti dalla DTD o dallo schema. Vedere le raccomandazioni W3C XML Schema Part 1: Structures and the W3C XML Schema Part 2: Datatypes(W3C XML Schema Part 1: Structures and the W3C XML Schema Part 2: Datatypes) (W3C XML Schema Part 1: Structures and the W3C XML Schema Part 2: Datatypes recommendations(W3C XML Schema Part 1: Structures Pertanto, anche se tutti i documenti XML validi sono ben formati, non tutti i documenti XML ben formati sono validi.

È possibile convalidare i dati in base a una DTD, a uno schema XSD inline o a uno schema XSD archiviato in un oggetto (una cache). Questi scenari sono descritti nella pagina XmlSchemaSet Create di riferimento. XmlReader non supporta la convalida XML-Data dello schema XDR (Reduced).

Usare le impostazioni seguenti nella classe per specificare il tipo XmlReaderSettings di convalida, se presente, supportato XmlReader dall'istanza di .

Usare questo XmlReaderSettings membro Per specificare
ProprietàDtdProcessing Indica se consentire l'elaborazione DTD. Per impostazione predefinita l'elaborazione della DTD non è consentita.
ProprietàValidationType Indica se il lettore deve convalidare i dati e il tipo di convalida da eseguire (DTD o schema). Per impostazione predefinita non è prevista alcuna convalida dei dati.
EventoValidationEventHandler Gestore eventi per la ricezione di informazioni sugli eventi di convalida. Se non si fornisce un gestore eventi, viene generata un'eccezione XmlException per il primo errore di convalida.
ProprietàValidationFlags Opzioni di convalida aggiuntive tramite i membri XmlSchemaValidationFlags dell'enumerazione:

- AllowXmlAttributes-- Consente attributi XML ( ) nei documenti di istanza anche quando xml:* non sono definiti nello schema. Gli attributi vengono convalidati in base al relativo tipo di dati. Vedere la XmlSchemaValidationFlags pagina di riferimento per l'impostazione da usare in scenari specifici. (Disabilitato per impostazione predefinita.
- ProcessIdentityConstraints --Elabora vincoli di identità ( xs:ID , , , , ) rilevati durante la xs:IDREF xs:key xs:keyref xs:unique convalida. (Abilitato per impostazione predefinita.
- ProcessSchemaLocation --Elabora gli schemi specificati xsi:schemaLocation dall'attributo o xsi:noNamespaceSchemaLocation . (Abilitato per impostazione predefinita.
- ProcessInlineSchema-- Elaborare xml schema inline durante la convalida. (Disabilitato per impostazione predefinita.
- ReportValidationWarnings--Segnala eventi se si verifica un avviso di convalida. Un avviso, in genere, viene emesso quando non si dispone di una DTD o di un XML Schema in base al quale convalidare un determinato elemento o attributo. L'evento ValidationEventHandler viene utilizzato per la notifica. (Disabilitato per impostazione predefinita.
Schemas Oggetto XmlSchemaSet da usare per la convalida.
ProprietàXmlResolver oggetto XmlResolver per la risoluzione e l'accesso a risorse esterne. Può includere entità esterne, ad esempio DTD e schemi, e qualsiasi xs:include elemento o contenuto in XML xs:import Schema. Se non si specifica , XmlResolver usa un valore predefinito senza credenziali XmlReader XmlUrlResolver utente.

Conformità dei dati

I lettori XML creati dal metodo Create soddisfano i requisiti di conformità seguenti per impostazione predefinita:

  • Le nuove righe e il valore dell'attributo vengono normalizzati in base alla raccomandazione W3C XML 1.0.

  • Tutte le entità vengono espanse automaticamente.

  • Gli attributi predefiniti dichiarati nella definizione del tipo di documento vengono sempre aggiunti anche quando il lettore non esegue la convalida.

  • È consentita la dichiarazione del prefisso XML mappato all'URI dello spazio dei nomi XML corretto.

  • I nomi di notazione in una singola dichiarazione NotationType di attributo e in una singola dichiarazione di attributo sono NmTokens Enumeration distinti.

Usare queste XmlReaderSettings proprietà per specificare il tipo di controlli di conformità da abilitare:

Usare questa XmlReaderSettings proprietà A Impostazione predefinita
ProprietàCheckCharacters Abilitare o disabilitare i controlli per gli elementi seguenti:

- I caratteri sono all'interno dell'intervallo di caratteri XML validi, come definito dalla sezione 2.2 Caratteri della raccomandazione W3C XML 1.0.
- Tutti i nomi XML sono validi, come definito nella sezione 2.3 Common Syntactic Constructs della raccomandazione W3C XML 1.0.

Quando questa proprietà è impostata su (impostazione predefinita), viene generata un'eccezione se il file XML contiene caratteri non validi o nomi XML non validi (ad esempio, un nome di elemento inizia true XmlException con un numero).
Il controllo dei caratteri e dei nomi è abilitato.

Se si imposta la proprietà CheckCharacters su false, il controllo dei caratteri per i riferimenti a entità carattere viene disattivato. Se il lettore elabora dati di testo, verifica sempre che i nomi XML siano validi, indipendentemente da questa impostazione. Nota: La raccomandazione XML 1.0 richiede la conformità a livello di documento quando è presente una DTD. Pertanto, se il lettore è configurato per supportare , ma i dati XML contengono una ConformanceLevel.Fragment definizione DTD (Document Type Definition), viene XmlException generata un'eccezione .
ProprietàConformanceLevel Scegliere il livello di conformità da applicare:

- Document. È conforme alle regole per un documento XML 1.0 ben formato.
- Fragment. È conforme alle regole per un frammento di documento ben formato che può essere utilizzato come entità analizzata esterna.
- Auto. È conforme al livello deciso dal lettore.

Se i dati non sono conformi, viene XmlException generata un'eccezione.
Document

Il nodo corrente è il nodo XML in cui è attualmente posizionato il lettore XML. Tutti i metodi eseguono operazioni in relazione a questo nodo e tutte le XmlReader proprietà riflettono il valore del nodo XmlReader corrente.

I metodi seguenti semplificano l'esplorazione dei nodi e l'analisi dei dati.

Usare questo XmlReaderSettings metodo A
Read Leggere il primo nodo e passare attraverso il flusso un nodo alla volta. Tali chiamate vengono in genere eseguite all'interno di un while ciclo.

Usare la NodeType proprietà per ottenere il tipo (ad esempio, attributo, commento, elemento e così via) del nodo corrente.
Skip Ignorare gli elementi figlio del nodo corrente e passare al nodo successivo.
MoveToContent e MoveToContentAsync Ignorare i nodi non di contenuto e passare al nodo di contenuto successivo o alla fine del file.

I nodi non di contenuto ProcessingInstruction includono , , , e DocumentType Comment Whitespace SignificantWhitespace .

I nodi di contenuto includono testo non vuoto, CDATA EntityReference , e EndEntity .
ReadSubtree Legge un elemento e tutti i relativi elementi figlio e restituisce una nuova XmlReader istanza impostata su ReadState.Initial .

Questo metodo è utile per la creazione di limiti intorno agli elementi XML. Ad esempio, se si vogliono passare dati a un altro componente per l'elaborazione e si vuole limitare la quantità di dati a cui il componente può accedere.

Vedere la pagina di riferimento per un esempio di esplorazione di un flusso di testo un nodo alla volta e la visualizzazione XmlReader.Read del tipo di ogni nodo.

Le sezioni seguenti descrivono come è possibile leggere tipi specifici di dati, ad esempio elementi, attributi e dati tipiati.

Lettura di elementi XML

Nella tabella seguente sono elencati i metodi e le proprietà forniti XmlReader dalla classe per l'elaborazione degli elementi. Dopo che il tipo XmlReader è stato posizionato in corrispondenza di un elemento, le proprietà del nodo, quale Name, riflettono i valori dell'elemento. Oltre ai membri descritti di seguito, è possibile utilizzare qualsiasi metodo e proprietà generale della classe XmlReader per elaborare gli elementi. Il metodo ReadInnerXml può essere utilizzato, ad esempio, per leggere il contenuto di un elemento.

Nota

Vedere la sezione 3.1 della raccomandazione W3C XML 1.0 per le definizioni di tag di inizio, tag di fine e tag di elemento vuoti.

Usare questo XmlReader membro A
Metodo IsStartElement Controllare se il nodo corrente è un tag di inizio o un tag di elemento vuoto.
Metodo ReadStartElement Verificare che il nodo corrente sia un elemento e far avanzare il lettore al nodo successivo (chiamate IsStartElement seguite da Read ).
Metodo ReadEndElement Verificare che il nodo corrente sia un tag di fine e far avanzare il lettore al nodo successivo.
Metodo ReadElementString Leggere un elemento di solo testo.
Metodo ReadToDescendant Far avanzare il lettore XML all'elemento discendente successivo (figlio) con il nome specificato.
Metodo ReadToNextSibling Far avanzare il lettore XML all'elemento di pari livello successivo con il nome specificato.
ProprietàIsEmptyElement Controllare se l'elemento corrente ha un tag dell'elemento finale. Esempio:

- <item num="123"/> ( IsEmptyElement è true . )
- <item num="123"> </item> ( IsEmptyElement è , anche se il contenuto false dell'elemento è vuoto.

Per un esempio di lettura del contenuto di testo degli elementi, vedere il ReadString metodo . L'esempio seguente elabora gli elementi usando un while ciclo .

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

Lettura degli attributi XML

Gli attributi XML si trovano più comunemente sugli elementi, ma sono consentiti anche nei nodi di dichiarazione e di tipo documento XML.

Quando è posizionato su un nodo elemento, il metodo consente di MoveToAttribute scorrere l'elenco di attributi dell'elemento. Si noti che dopo la chiamata, le proprietà del nodo, ad esempio , e riflettono le proprietà di tale attributo, non le proprietà dell'elemento a cui appartiene MoveToAttribute Name NamespaceURI Prefix l'attributo.

La XmlReader classe fornisce questi metodi e proprietà per leggere ed elaborare gli attributi sugli elementi.

Usare questo XmlReader membro A
ProprietàHasAttributes Controllare se il nodo corrente dispone di attributi.
ProprietàAttributeCount Ottiene il numero di attributi nell'elemento corrente.
Metodo MoveToFirstAttribute Passare al primo attributo di un elemento.
Metodo MoveToNextAttribute Passare all'attributo successivo in un elemento.
Metodo MoveToAttribute Passare a un attributo specificato.
GetAttribute metodo o Item[] proprietà Ottiene il valore di un attributo specificato.
ProprietàIsDefault Controllare se il nodo corrente è un attributo generato dal valore predefinito definito nella DTD o nello schema.
Metodo MoveToElement Passare all'elemento proprietario dell'attributo corrente. Usare questo metodo per tornare a un elemento dopo lo spostamento tra i relativi attributi.
Metodo ReadAttributeValue Analizzare il valore dell'attributo in uno o più Text EntityReference nodi , o EndEntity .

Per elaborare gli attributi è possibile utilizzare anche qualsiasi metodo e proprietà generale del tipo XmlReader. Dopo che il tipo XmlReader è stato posizionato in corrispondenza di un attributo, ad esempio, le proprietà Name e Value riflettono i valori dell'attributo. È inoltre possibile utilizzare qualsiasi metodo Read del contenuto per ottenere il valore dell'attributo.

In questo esempio viene AttributeCount utilizzata la proprietà per spostarsi tra tutti gli attributi di un elemento .

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

In questo esempio viene MoveToNextAttribute utilizzato il metodo in un ciclo per spostarsi tra gli while attributi.

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

Lettura degli attributi nei nodi di dichiarazione XML

Quando il lettore XML è posizionato su un nodo di dichiarazione XML, la proprietà restituisce le informazioni sulla versione, sulla versione autonoma e sulla codifica Value come singola stringa. XmlReader Gli oggetti creati dal metodo , la classe e la classe espongono la versione, la versione autonoma e gli elementi Create XmlTextReader di codifica come XmlValidatingReader attributi.

Lettura degli attributi nei nodi del tipo di documento

Quando il lettore XML è posizionato su un nodo di tipo documento, il metodo e la proprietà possono essere usati per restituire i valori per i valori letterali GetAttribute Item[] SYSTEM e PUBLIC. Ad esempio, la chiamata al metodo reader.GetAttribute("PUBLIC") restituisce il valore PUBLIC.

Lettura degli attributi nei nodi di istruzione di elaborazione

Quando il tipo XmlReader è posizionato in corrispondenza di un nodo di istruzioni di elaborazione, la proprietà Value restituisce l'intero contenuto di testo. Gli elementi nel nodo dell'istruzione di elaborazione non vengono considerati attributi. Non possono essere lette con il GetAttribute metodo o MoveToAttribute .

Lettura di contenuto XML

La classe XMLReader include i membri seguenti che leggono il contenuto da un file XML e restituiscono il contenuto come valori stringa. Per restituire tipi CLR, vedere la sezione successiva.

Usare questo XmlReader membro A
ProprietàValue Ottiene il contenuto di testo del nodo corrente. Il valore restituito dipende dal tipo di nodo. Per informazioni Value dettagliate, vedere la pagina di riferimento.
Metodo ReadString Ottenere il contenuto di un elemento o di un nodo di testo come stringa. Questo metodo si arresta durante l'elaborazione di istruzioni e commenti.

Per informazioni dettagliate su come questo metodo gestisce tipi di nodo specifici, vedere la ReadString pagina di riferimento.
Metodi ReadInnerXml e ReadInnerXmlAsync Ottiene tutto il contenuto del nodo corrente, incluso il markup, ma escludendo i tag di inizio e di fine. Ad esempio, per:

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

ReadInnerXml Restituisce:

this<child id="123"/>
Metodi ReadOuterXml e ReadOuterXmlAsync Ottiene tutto il contenuto del nodo corrente e dei relativi elementi figlio, inclusi markup e tag di inizio/fine. Ad esempio, per:

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

ReadOuterXml Restituisce:

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

Conversione in tipi CLR

È possibile usare i membri della classe (elencati nella tabella seguente) per leggere dati XML e restituire valori come tipi XmlReader CLR (Common Language Runtime) anziché stringhe. Questi membri consentono di ottenere valori nella rappresentazione più appropriata per l'attività di codifica senza dover analizzare o convertire manualmente i valori stringa.

  • I metodi ReadElementContentAs possono essere chiamati solo sui tipi di nodo elemento. e non possono essere utilizzati su elementi contenenti elementi figlio o contenuto misto. Quando viene chiamato, l'oggetto XmlReader legge il tag di inizio e il contenuto dell'elemento, quindi si sposta dopo il tag di fine dell'elemento. Le istruzioni di elaborazione e i commenti vengono ignorati e le entità vengono espanse.

  • I metodi ReadContentAs leggono il contenuto di testo nella posizione corrente del lettore e, se ai dati XML non sono associate informazioni sullo schema o sul tipo di dati, convertire il contenuto di testo nel tipo restituito richiesto. Il testo, gli spazi vuoti, gli spazi vuoti significativi e le sezioni CDATA sono concatenati. I commenti e le istruzioni di elaborazione vengono ignorati e i riferimenti alle entità vengono risolti automaticamente.

La XmlReader classe usa le regole definite dalla raccomandazione W3C XML Schema Part 2: Datatypes.

Usare questo XmlReader metodo Per restituire questo tipo CLR
ReadContentAsBoolean e ReadElementContentAsBoolean Boolean
ReadContentAsDateTime e ReadElementContentAsDateTime DateTime
ReadContentAsDouble e ReadElementContentAsDouble Double
ReadContentAsLong e ReadElementContentAsLong Int64
ReadContentAsInt e ReadElementContentAsInt Int32
ReadContentAsString e ReadElementContentAsString String
ReadContentAs e ReadElementContentAs Tipo specificato con il returnType parametro
ReadContentAsObject e ReadElementContentAsObject Tipo più appropriato, come specificato dalla XmlReader.ValueType proprietà . Per informazioni sul mapping, vedere Supporto dei tipi System.Xml classi.

Se un elemento non può essere convertito facilmente in un tipo CLR a causa del formato, è possibile usare un mapping dello schema per garantire una conversione corretta. Nell'esempio seguente viene utilizzato un file xsd per convertire l'elemento nel tipo e quindi viene utilizzato il metodo per hire-date restituire l'elemento come oggetto xs:date ReadElementContentAsDateTime DateTime .

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):

<?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>

Codice:

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

Output:

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

Programmazione asincrona

La maggior parte XmlReader dei metodi ha controparti asincrone con "Async" alla fine dei relativi nomi di metodo. Ad esempio, l'equivalente asincrono ReadContentAsObject di è ReadContentAsObjectAsync .

Con le chiamate al metodo asincrone è possibile usare i metodi seguenti:

Le sezioni seguenti descrivono l'utilizzo asincrono per i metodi che non hanno controparti asincrone.

ReadStartElement, metodo

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

Metodo ReadEndElement

public static async Task ReadEndElementAsync(this XmlReader reader)
{
    if (await reader.MoveToContentAsync() != XmlNodeType.EndElement)
    {
        throw new InvalidOperationException();
    }
    await reader.ReadAsync();
}
<Extension()>
Public Async Function ReadEndElementAsync(reader As XmlReader) As task
    If (Await reader.MoveToContentAsync() <> XmlNodeType.EndElement) Then
        Throw New InvalidOperationException()
    End If
    Await reader.ReadAsync()
End Function

Metodo ReadToNextSibling

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

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

    // find the next sibling
    XmlNodeType nt;
    do
    {
        await reader.SkipAsync();
        if (reader.ReadState != ReadState.Interactive)
            break;
        nt = reader.NodeType;
        if (nt == XmlNodeType.Element &&
             ((object)localName == (object)reader.LocalName) &&
             ((object)namespaceURI ==(object)reader.NamespaceURI))
        {
            return true;
        }
    } while (nt != XmlNodeType.EndElement && !reader.EOF);
    
    return false;
}
<Extension()>
Public Async Function ReadToNextSiblingAsync(reader As XmlReader, localName As String, namespaceURI As String) As Task(Of Boolean)
    If (localName = Nothing Or localName.Length = 0) Then
        Throw New ArgumentException("localName is empty or null")
    End If

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

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

    ' find the next sibling
    Dim nt As XmlNodeType
    Do

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

    Return False

End Function

Metodo ReadToFollowing

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

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

    // find element with that name
    while (await reader.ReadAsync())
    {
        if (reader.NodeType == XmlNodeType.Element && ((object)localName == (object)reader.LocalName) && ((object)namespaceURI == (object)reader.NamespaceURI))
        {
            return true;
        }
    }
    return false;
}
<Extension()>
Public Async Function ReadToFollowingAsync(reader As XmlReader, localName As String, namespaceURI As String) As Task(Of Boolean)
    If (localName = Nothing Or localName.Length = 0) Then
        Throw New ArgumentException("localName is empty or null")
    End If

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

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

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

    Return False
End Function

Metodo ReadToDescendant

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

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

    // find the descendant
    while (await reader.ReadAsync() && reader.Depth > parentDepth)
    {
        if (reader.NodeType == XmlNodeType.Element && ((object)localName == (object)reader.LocalName) && ((object)namespaceURI == (object)reader.NamespaceURI))
        {
            return true;
        }
    }
    return false;
}
<Extension()>
Public Async Function ReadToDescendantAsync(reader As XmlReader, localName As String, namespaceURI As String) As Task(Of Boolean)
    If (localName = Nothing Or localName.Length = 0) Then
        Throw New ArgumentException("localName is empty or null")
    End If

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

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

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

    Return False
End Function

Considerazioni relative alla sicurezza

Quando si utilizza la classe , tenere presente quanto XmlReader segue:

  • Le eccezioni generate da possono divulgare informazioni sul percorso che potrebbero non essere necessarie per XmlReader l'app. L'app deve rilevare le eccezioni ed elaborarle in modo appropriato.

  • Non abilitare l'elaborazione DTD se si è interessati a problemi di denial of service o se si gestiscono origini non attendibili. L'elaborazione DTD è disabilitata per impostazione predefinita XmlReader per gli oggetti creati dal metodo Create .

    Se l'elaborazione della DTD è attivata, è possibile utilizzare il tipo XmlSecureResolver per limitare le risorse a cui il tipo XmlReader può accedere. È anche possibile progettare l'app in modo che l'elaborazione XML sia vincolata alla memoria e al tempo. Ad esempio, è possibile configurare i limiti di timeout nell'app ASP.NET locale.

  • È possibile che i dati XML includano riferimenti a risorse esterne quali, ad esempio, un file dello schema. Per impostazione predefinita, le risorse esterne vengono risolte usando XmlUrlResolver un oggetto senza credenziali utente. È possibile migliorare i livelli di sicurezza mediante una delle seguenti operazioni:

  • I ProcessInlineSchema flag di convalida e di un oggetto non sono impostati per impostazione ProcessSchemaLocation XmlReaderSettings predefinita. Ciò consente di proteggere il tipo XmlReader da attacchi basati sullo schema durante l'elaborazione dei dati XML da un'origine non attendibile. Se questi flag sono impostati, verrà utilizzata la proprietà XmlResolver dell'oggetto XmlReaderSettings per risolvere i percorsi dello schema rilevati nel documento di istanza nel tipo XmlReader. Se la XmlResolver proprietà è impostata su , i percorsi dello schema non vengono risolti anche se sono impostati i flag di null convalida e ProcessInlineSchema ProcessSchemaLocation .

    Gli schemi aggiunti durante la convalida aggiungono nuovi tipi e possono alterare l'esito della convalida del documento in esame. Di conseguenza, gli schemi esterni devono essere risolti solo da origini attendibili.

    È consigliabile disabilitare il flag durante la convalida di documenti XML di grandi dimensioni non attendibili in scenari a disponibilità elevata rispetto a uno schema con vincoli di identità su gran ProcessIdentityConstraints parte del documento. Questo flag è abilitato per impostazione predefinita.

  • I dati XML possono contenere un numero elevato di attributi, dichiarazione dello spazio dei nomi, elementi annidati e così via, la cui elaborazione richiede una notevole quantità di tempo. Per limitare le dimensioni dell'input inviato a XmlReader , è possibile:

  • Il ReadValueChunk metodo può essere usato per gestire flussi di dati di grandi dimensioni. Questo metodo consente di leggere un numero ridotto di caratteri alla volta invece di allocare una singola stringa per l'intero valore.

  • Quando si legge un documento XML con un numero elevato di nomi locali univoci, spazi dei nomi o prefissi, può verificarsi un problema. Se si usa una classe che deriva da e si chiama la proprietà , o per ogni elemento, la stringa restituita XmlReader viene aggiunta a un oggetto LocalName Prefix NamespaceURI NameTable . La raccolta mantenuta da NameTable non diminuisce mai di dimensioni, creando una perdita di memoria virtuale degli handle di stringa. Una mitigazione di questo problema è derivare dalla NameTable classe e applicare una quota di dimensioni massime. Non è possibile impedire l'uso di o NameTable per cambiare NameTable l'oggetto quando è pieno. Un'altra mitigazione è evitare di usare le proprietà indicate e usare invece il metodo con il metodo , laddove possibile. Tali metodi non restituiscono stringhe e quindi evitano il problema di riempimento della MoveToAttribute IsStartElement NameTable raccolta.

  • Gli oggetti XmlReaderSettings possono contenere informazioni sensibili quali le credenziali utente. L'oggetto XmlReaderSettings e le relative credenziali utente potrebbero essere utilizzate da un componente non attendibile per creare oggetti XmlReader che consentano di leggere i dati. Prestare attenzione quando si memorizzano nella cache gli oggetti o quando XmlReaderSettings si passa l'oggetto da un componente a un XmlReaderSettings altro.

  • Non accettare componenti di supporto, ad esempio oggetti NameTable, XmlNamespaceManager e XmlResolver da un'origine non attendibile.

Costruttori

XmlReader()

Inizializza una nuova istanza della classe XmlReader.

Proprietà

AttributeCount

Quando ne viene eseguito l'override in una classe derivata, ottiene il numero di attributi sul nodo corrente.

BaseURI

Quando sottoposto a override in una classe derivata, ottiene l'URI di base del nodo corrente.

CanReadBinaryContent

Ottiene un valore che indica se XmlReader implementa metodi di lettura del contenuto binario.

CanReadValueChunk

Ottiene un valore che indica se XmlReader implementa il metodo ReadValueChunk(Char[], Int32, Int32).

CanResolveEntity

Ottiene un valore che indica se il lettore può analizzare e risolvere le entità.

Depth

Quando sottoposto a override in una classe derivata, ottiene la profondità del nodo corrente nel documento XML.

EOF

Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il lettore è posizionato alla fine del flusso.

HasAttributes

Ottiene un valore che indica se il nodo corrente dispone di attributi.

HasValue

Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il nodo corrente può avere Value.

IsDefault

Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il nodo corrente è un attributo generato dal valore predefinito configurato nella definizione DTD o nello schema.

IsEmptyElement

Quando viene eseguito l'override in una classe derivata, ottiene un valore che indica se il nodo corrente è un elemento vuoto, ad esempio <MyElement/>.

Item[Int32]

Quando ne viene eseguito l'override in una classe derivata, ottiene il valore dell'attributo con l'indice specificato.

Item[String, String]

Quando sottoposto a override in una classe derivata, ottiene il valore dell'attributo con le proprietà LocalName e NamespaceURI specificate.

Item[String]

Quando sottoposto a override in una classe derivata, ottiene il valore dell'attributo con la proprietà Name specificata.

LocalName

Quando sottoposto a override in una classe derivata, ottiene il nome locale del nodo corrente.

Name

Quando ne viene eseguito l'override in una classe derivata, ottiene il nome completo del nodo corrente.

NamespaceURI

Quando sottoposto a override in una classe derivata, ottiene l'URI dello spazio dei nomi, definito nella specifica W3C Namespace, del nodo in corrispondenza del quale è posizionato il lettore.

NameTable

Quando sottoposto a override in una classe derivata, ottiene l'oggetto XmlNameTable associato a questa implementazione.

NodeType

Quando ne viene eseguito l'override in una classe derivata, ottiene il tipo del nodo corrente.

Prefix

Quando ne viene eseguito l'override in una classe derivata, ottiene il prefisso dello spazio dei nomi associato al nodo corrente.

QuoteChar

Quando sottoposto a override in una classe derivata, ottiene il carattere punto interrogativo (?) utilizzato per delimitare il valore di un nodo attributo.

ReadState

Quando ne viene eseguito l'override in una classe derivata, ottiene lo stato del lettore.

SchemaInfo

Ottiene le informazioni sullo schema assegnate al nodo corrente in seguito alla convalida dello schema.

Settings

Ottiene l'oggetto XmlReaderSettings usato per creare questa istanza di XmlReader.

Value

Quando ne viene eseguito l'override in una classe derivata, ottiene il valore del testo del nodo corrente.

ValueType

Ottiene il tipo CLR (Common Language Runtime) relativo al nodo corrente.

XmlLang

Quando ne viene eseguito l'override in una classe derivata, ottiene l'ambito xml:lang corrente.

XmlSpace

Quando ne viene eseguito l'override in una classe derivata, ottiene l'ambito xml:space corrente.

Metodi

Close()

Quando ne viene eseguito l'override in una classe derivata, sostituisce ReadState con Closed.

Create(Stream)

Crea una nuova istanza di XmlReader con il flusso specificato e le impostazioni predefinite.

Create(Stream, XmlReaderSettings)

Crea una nuova istanza di XmlReader con il flusso e le impostazioni specificati.

Create(Stream, XmlReaderSettings, String)

Crea una nuova istanza di XmlReader con il flusso, l'URI di base e le impostazioni specificati.

Create(Stream, XmlReaderSettings, XmlParserContext)

Crea una nuova istanza di XmlReader con il flusso, le impostazioni e le informazioni di contesto specificati per l'analisi.

Create(String)

Crea una nuova istanza di XmlReader con l'URI specificato.

Create(String, XmlReaderSettings)

Crea una nuova istanza di XmlReader con l'URI e le impostazioni specificati.

Create(String, XmlReaderSettings, XmlParserContext)

Crea una nuova istanza di XmlReader con l'URI, le impostazioni e le informazioni di contesto specificati per l'analisi.

Create(TextReader)

Crea una nuova istanza di XmlReader con il lettore di testo specificato.

Create(TextReader, XmlReaderSettings)

Crea una nuova istanza di XmlReader con il lettore di testo e le impostazioni specificati.

Create(TextReader, XmlReaderSettings, String)

Crea una nuova istanza di XmlReader con il lettore di testo, le impostazioni e l'URI di base specificati.

Create(TextReader, XmlReaderSettings, XmlParserContext)

Crea una nuova istanza di XmlReader con il lettore di testo, le impostazioni e le informazioni di contesto specificati per l'analisi.

Create(XmlReader, XmlReaderSettings)

Crea una nuova istanza di XmlReader con il lettore XML e le impostazioni specificate.

Dispose()

Rilascia tutte le risorse usate dall'istanza corrente della classe XmlReader.

Dispose(Boolean)

Rilascia le risorse non gestite usate da XmlReader e, facoltativamente, le risorse gestite.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetAttribute(Int32)

Quando ne viene eseguito l'override in una classe derivata, ottiene il valore dell'attributo con l'indice specificato.

GetAttribute(String)

Quando sottoposto a override in una classe derivata, ottiene il valore dell'attributo con la proprietà Name specificata.

GetAttribute(String, String)

Quando sottoposto a override in una classe derivata, ottiene il valore dell'attributo con le proprietà LocalName e NamespaceURI specificate.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
GetValueAsync()

Ottiene in modo asincrono il valore del nodo corrente.

IsName(String)

Restituisce un valore che indica se l'argomento della stringa è un nome XML valido.

IsNameToken(String)

Restituisce un valore che indica se l'argomento della stringa è un token di un nome XML valido o meno.

IsStartElement()

Chiama MoveToContent() e verifica se il nodo di contenuto corrente è un tag di inizio o un tag di elemento vuoto.

IsStartElement(String)

Chiama MoveToContent() e verifica se il nodo corrente è un tag di inizio o un tag di elemento vuoto e se la proprietà Name dell'elemento trovato corrisponde all'argomento specificato.

IsStartElement(String, String)

Chiama MoveToContent() e verifica se il nodo di contenuto è un tag di inizio o un tag di elemento vuoto e se le proprietà LocalName e NamespaceURI dell'elemento trovato corrispondono alle stringhe specificate.

LookupNamespace(String)

Quando sottoposto a override in una classe derivata, risolve il prefisso di uno spazio dei nomi nell'ambito dell'elemento corrente.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
MoveToAttribute(Int32)

Quando ne viene eseguito l'override in una classe derivata, passa all'attributo con l'indice specificato.

MoveToAttribute(String)

Quando ne viene eseguito l'override in una classe derivata, passa all'attributo con la proprietà Name specificata.

MoveToAttribute(String, String)

Quando ne viene eseguito l'override in una classe derivata, passa all'attributo con le proprietà LocalName e NamespaceURI specificate.

MoveToContent()

Verifica se il nodo corrente rappresenta un nodo di contenuto, ovvero un nodo testo non spazio vuoto, CDATA, Element, EndElement, EntityReference o EndEntity. Se il nodo non è un nodo di contenuto, il lettore passa al nodo di contenuto successivo oppure alla fine del file. Vengono inoltre ignorati i seguenti tipi di nodo: ProcessingInstruction, DocumentType, Comment, Whitespace o SignificantWhitespace.

MoveToContentAsync()

Verifica in modo asincrono se il nodo corrente è un nodo di contenuto. Se il nodo non è un nodo di contenuto, il lettore passa al nodo di contenuto successivo oppure alla fine del file.

MoveToElement()

Quando ne viene eseguito l'override in una classe derivata, passa all'elemento che contiene il nodo attributo corrente.

MoveToFirstAttribute()

Quando ne viene eseguito l'override in una classe derivata, passa al primo attributo.

MoveToNextAttribute()

Quando ne viene eseguito l'override in una classe derivata, passa all'attributo successivo.

Read()

Quando ne viene eseguito l'override in una classe derivata, visualizza il nodo successivo nel flusso.

ReadAsync()

Legge in modo asincrono il nodo successivo del flusso.

ReadAttributeValue()

Quando ne viene eseguito l'override in una classe derivata, analizza il valore dell'attributo incluso in uno o più nodi Text, EntityReference o EndEntity.

ReadContentAs(Type, IXmlNamespaceResolver)

Legge il contenuto come oggetto del tipo specificato.

ReadContentAsAsync(Type, IXmlNamespaceResolver)

Legge in modo asincrono il contenuto come oggetto del tipo specificato.

ReadContentAsBase64(Byte[], Int32, Int32)

Legge il contenuto e restituisce byte binari decodificati Base64.

ReadContentAsBase64Async(Byte[], Int32, Int32)

Legge in modo asincrono il contenuto e restituisce byte binari decodificati Base64.

ReadContentAsBinHex(Byte[], Int32, Int32)

Legge il contenuto e restituisce i byte binari decodificati BinHex.

ReadContentAsBinHexAsync(Byte[], Int32, Int32)

Legge in modo asincrono il contenuto e restituisce byte binari decodificati BinHex.

ReadContentAsBoolean()

Legge il contenuto di testo nella posizione corrente come Boolean.

ReadContentAsDateTime()

Legge il contenuto di testo nella posizione corrente come oggetto DateTime.

ReadContentAsDateTimeOffset()

Legge il contenuto di testo nella posizione corrente come oggetto DateTimeOffset.

ReadContentAsDecimal()

Legge il contenuto di testo nella posizione corrente come oggetto Decimal.

ReadContentAsDouble()

Legge il contenuto di testo nella posizione corrente come numero a virgola mobile e precisione doppia.

ReadContentAsFloat()

Legge il contenuto di testo nella posizione corrente come numero a virgola mobile e precisione singola.

ReadContentAsInt()

Legge il contenuto di testo nella posizione corrente come valore intero con segno a 32 bit.

ReadContentAsLong()

Legge il contenuto di testo nella posizione corrente come valore intero con segno a 64 bit.

ReadContentAsObject()

Legge il contenuto di testo nella posizione corrente come Object.

ReadContentAsObjectAsync()

Legge in modo asincrono il contenuto di testo nella posizione corrente come oggetto Object.

ReadContentAsString()

Legge il contenuto di testo nella posizione corrente come oggetto String.

ReadContentAsStringAsync()

Legge in modo asincrono il contenuto di testo nella posizione corrente come oggetto String.

ReadElementContentAs(Type, IXmlNamespaceResolver)

Legge il contenuto dell'elemento come il tipo richiesto.

ReadElementContentAs(Type, IXmlNamespaceResolver, String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge il contenuto dell'elemento come il tipo richiesto.

ReadElementContentAsAsync(Type, IXmlNamespaceResolver)

Legge in modo asincrono il contenuto dell'elemento come il tipo richiesto.

ReadElementContentAsBase64(Byte[], Int32, Int32)

Legge l'elemento e decodifica il contenuto Base64.

ReadElementContentAsBase64Async(Byte[], Int32, Int32)

Legge in modo asincrono l'elemento e decodifica il contenuto Base64.

ReadElementContentAsBinHex(Byte[], Int32, Int32)

Legge l'elemento e decodifica il contenuto BinHex.

ReadElementContentAsBinHexAsync(Byte[], Int32, Int32)

Legge in modo asincrono l'elemento e decodifica il contenuto BinHex.

ReadElementContentAsBoolean()

Legge l'elemento corrente e restituisce il contenuto come oggetto Boolean.

ReadElementContentAsBoolean(String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge l'elemento e restituisce il contenuto come oggetto Boolean.

ReadElementContentAsDateTime()

Legge l'elemento corrente e restituisce il contenuto come oggetto DateTime.

ReadElementContentAsDateTime(String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge l'elemento e restituisce il contenuto come oggetto DateTime.

ReadElementContentAsDecimal()

Legge l'elemento corrente e restituisce il contenuto come oggetto Decimal.

ReadElementContentAsDecimal(String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge l'elemento e restituisce il contenuto come oggetto Decimal.

ReadElementContentAsDouble()

Legge l'elemento corrente e restituisce il contenuto come numero a virgola mobile e precisione doppia.

ReadElementContentAsDouble(String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge l'elemento e restituisce il contenuto come numero a virgola mobile e precisione doppia.

ReadElementContentAsFloat()

Legge l'elemento corrente e restituisce il contenuto come numero a virgola mobile e precisione singola.

ReadElementContentAsFloat(String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge l'elemento e restituisce il contenuto come numero a virgola mobile e precisione singola.

ReadElementContentAsInt()

Legge l'elemento corrente e restituisce il contenuto come valore intero con segno a 32 bit.

ReadElementContentAsInt(String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge l'elemento e restituisce il contenuto come valore intero con segno a 32 bit.

ReadElementContentAsLong()

Legge l'elemento corrente e restituisce il contenuto come valore intero con segno a 64 bit.

ReadElementContentAsLong(String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge l'elemento e restituisce il contenuto come valore intero con segno a 64 bit.

ReadElementContentAsObject()

Legge l'elemento corrente e restituisce il contenuto come Object.

ReadElementContentAsObject(String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge l'elemento e restituisce il contenuto come oggetto Object.

ReadElementContentAsObjectAsync()

Legge in modo asincrono l'elemento corrente e restituisce il contenuto come Object.

ReadElementContentAsString()

Legge l'elemento corrente e restituisce il contenuto come oggetto String.

ReadElementContentAsString(String, String)

Verifica che il nome locale e l'URI dello spazio dei nomi specificati corrispondano a quelli dell'elemento corrente, quindi legge l'elemento e restituisce il contenuto come oggetto String.

ReadElementContentAsStringAsync()

Legge in modo asincrono l'elemento corrente e restituisce il contenuto come oggetto String.

ReadElementString()

Legge un elemento di solo testo. È tuttavia consigliabile usare il metodo ReadElementContentAsString(), perché fornisce un modo più diretto per gestire questa operazione.

ReadElementString(String)

Verifica che la proprietà Name dell'elemento trovato corrisponda alla stringa specificata prima di leggere un elemento di solo testo. È tuttavia consigliabile usare il metodo ReadElementContentAsString(), perché fornisce un modo più diretto per gestire questa operazione.

ReadElementString(String, String)

Verifica che le proprietà LocalName e NamespaceURI dell'elemento trovato corrispondano alle stringhe specificate prima di leggere un elemento di solo testo. È tuttavia consigliabile usare il metodo ReadElementContentAsString(String, String), perché fornisce un modo più diretto per gestire questa operazione.

ReadEndElement()

Verifica che il nodo di contenuto corrente sia un tag di fine e sposta il lettore al nodo successivo.

ReadInnerXml()

Quando sottoposto a override in una classe derivata, legge tutto il contenuto come stringa, incluso il markup.

ReadInnerXmlAsync()

In modo asincrono legge tutti i contenuti, incluso il markup, come stringa.

ReadOuterXml()

Quando ne viene eseguito l'override in una classe derivata, legge il contenuto, incluso il markup, che rappresenta questo nodo e tutti i relativi nodi figlio.

ReadOuterXmlAsync()

In modo asincrono legge i contenuti che rappresentano questo nodo, incluso il markup, e i relativi elementi figlio.

ReadStartElement()

Verifica se il nodo corrente è un elemento e sposta il lettore al nodo successivo.

ReadStartElement(String)

Verifica che il nodo di contenuto corrente sia un elemento con la proprietà Name specificata e passa il lettore al nodo successivo.

ReadStartElement(String, String)

Verifica che il nodo di contenuto corrente sia un elemento con le proprietà LocalName e NamespaceURI specificate e passa il lettore al nodo successivo.

ReadString()

Quando sottoposto a override in una classe derivata, legge il contenuto di un nodo elemento o testo come se si trattasse di una stringa. È tuttavia consigliabile usare il metodo ReadElementContentAsString, perché fornisce un modo più diretto per gestire questa operazione.

ReadSubtree()

Restituisce una nuova istanza di XmlReader che è possibile utilizzare per leggere il nodo corrente e tutti i relativi discendenti.

ReadToDescendant(String)

Sposta l'oggetto XmlReader al successivo elemento discendente con il nome completo specificato.

ReadToDescendant(String, String)

Sposta l'oggetto XmlReader al successivo elemento discendente con il nome locale e l'URI dello spazio dei nomi specificati.

ReadToFollowing(String)

Legge fino a trovare un elemento con il nome completo specificato.

ReadToFollowing(String, String)

Legge fino a trovare un elemento con il nome locale e l'URI dello spazio dei nomi specificati.

ReadToNextSibling(String)

Sposta l'oggetto XmlReader al successivo elemento di pari livello con il nome completo specificato.

ReadToNextSibling(String, String)

Sposta l'oggetto XmlReader al successivo elemento di pari livello con il nome locale e l'URI dello spazio dei nomi specificati.

ReadValueChunk(Char[], Int32, Int32)

Legge flussi di testo di grandi dimensioni incorporati in un documento XML.

ReadValueChunkAsync(Char[], Int32, Int32)

Legge in modo asincrono flussi di testo di grandi dimensioni incorporati in un documento XML.

ResolveEntity()

Quando ne viene eseguito l'override in una classe derivata, risolve il riferimento a entità per i nodi EntityReference.

Skip()

Ignora gli elementi figlio del nodo corrente.

SkipAsync()

Ignora in modo asincrono gli elementi figlio del nodo corrente.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Per una descrizione di questo membro, vedere Dispose().

Si applica a

Vedi anche