XmlReader XmlReader XmlReader XmlReader Class

Definizione

Rappresenta un lettore che fornisce accesso veloce, non in cache e di tipo forward-only ai dati 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
Ereditarietà
XmlReaderXmlReaderXmlReaderXmlReader
Derivato
Implementazioni

Esempi

Esempio di codice seguente viene illustrato come usare l'API asincrona per analizzare il codice 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

Commenti

XmlReader fornisce l'accesso in sola lettura di tipo forward-only ai dati XML in un documento o flusso.XmlReader provides forward-only, read-only access to XML data in a document or stream. Questa classe è conforme per la W3C Extensible Markup Language (XML) 1.0 (fourth edition) e il spazi dei nomi in XML 1.0 (terza edizione) raccomandazioni.This class conforms to the W3C Extensible Markup Language (XML) 1.0 (fourth edition) and the Namespaces in XML 1.0 (third edition) recommendations.

XmlReader i metodi consentono di spostarsi tra i dati XML e leggere il contenuto di un nodo.XmlReader methods let you move through XML data and read the contents of a node. Le proprietà della classe riflettono il valore del nodo corrente, ovvero in cui il lettore è posizionato. Il ReadState valore della proprietà indica lo stato corrente del lettore 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. Ad esempio, la proprietà è impostata su ReadState.Initial per il XmlReader.Read (metodo) e ReadState.Closed dal XmlReader.Close (metodo).For example, the property is set to ReadState.Initial by the XmlReader.Read method and ReadState.Closed by the XmlReader.Close method. XmlReader offre anche i controlli di conformità dei dati e la convalida rispetto a una DTD o schema.XmlReader also provides data conformance checks and validation against a DTD or schema.

XmlReader Usa un modello pull per recuperare i dati.XmlReader uses a pull model to retrieve data. Questo modello:This model:

  • Semplifica la gestione dello stato da un perfezionamento naturale, dall'alto in basso procedura.Simplifies state management by a natural, top-down procedural refinement.

  • Supporta più flussi di input e dei livelli.Supports multiple input streams and layering.

  • Consente al client di fornire al parser un buffer in cui verrà scritti direttamente la stringa e quindi evita la necessità di una copia della stringa aggiuntiva.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.

  • Supporta l'elaborazione selettiva.Supports selective processing. Il client può ignorare gli elementi ed elaborare quelle che sono di particolare interesse per l'applicazione.The client can skip items and process those that are of interest to the application. È anche possibile impostare le proprietà in anticipo per gestire la modalità di elaborazione nel flusso XML (ad esempio, la normalizzazione).You can also set properties in advance to manage how the XML stream is processed (for example, normalization).

Contenuto della sezione:In this section:

Creazione di un lettore XML Creating an XML reader
Convalida di dati XML Validating XML data
Conformità dei dati Data conformance
Esplorazione dei nodi Navigating through nodes
Elementi XML durante la lettura Reading XML elements
Attributi XML durante la lettura Reading XML attributes
Contenuto XML durante la lettura Reading XML content
La conversione in tipi CLR Converting to CLR types
Programmazione asincrona Asynchronous programming
Considerazioni sulla sicurezzaSecurity considerations

Creazione di un lettore XMLCreating an XML reader

Usare la Create metodo per creare un XmlReader istanza.Use the Create method to create an XmlReader instance.

Anche se .NET Framework fornisce le implementazioni concrete del XmlReader classe, ad esempio il XmlTextReader, XmlNodeReadere il XmlValidatingReader classi, si consiglia di utilizzare le classi specializzate solo in questi scenari: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 si desidera leggere un sottoalbero del DOM XML da un XmlNode dell'oggetto, usare il XmlNodeReader classe.When you want to read an XML DOM subtree from an XmlNode object, use the XmlNodeReader class. (Tuttavia, questa classe non supporta la convalida DTD o nello schema).(However, this class doesn't support DTD or schema validation.)

  • Se è necessario espandere entità su richiesta, non si desidera il testo contenuto normalizzata o non si desidera attributi restituiti predefiniti, usare il XmlTextReader 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.

Per specificare il set di funzionalità che si desidera attivare il lettore XML, passare un System.Xml.XmlReaderSettings dell'oggetto per il Create (metodo).To specify the set of features you want to enable on the XML reader, pass an System.Xml.XmlReaderSettings object to the Create method. È possibile utilizzare un'unica System.Xml.XmlReaderSettings dell'oggetto per creare più lettori con la stessa funzionalità o modificare il System.Xml.XmlReaderSettings oggetto per creare un nuovo lettore con un set di funzionalità diverso.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. È possibile aggiungere facilmente funzionalità a un lettore esistente.You can also easily add features to an existing reader.

Se non si usa un System.Xml.XmlReaderSettings dell'oggetto, vengono usate le impostazioni predefinite.If you don't use a System.Xml.XmlReaderSettings object, default settings are used. Vedere il Create pagina di riferimento per i dettagli.See the Create reference page for details.

XmlReader Genera un XmlException errori di analisi in XML.XmlReader throws an XmlException on XML parse errors. Dopo che viene generata un'eccezione, lo stato del lettore non è prevedibile.After an exception is thrown, the state of the reader is not predictable. Ad esempio, il tipo di nodo restituito può essere diverso dal tipo di nodo effettivo del nodo corrente.For example, the reported node type may be different from the actual node type of the current node. Usare il ReadState proprietà per controllare se il reader è in stato di errore.Use the ReadState property to check whether the reader is in error state.

Convalida di dati XMLValidating XML data

Per definire la struttura di un documento XML e relativi elementi-relazioni, i tipi di dati e i vincoli di contenuto, usare un document type definition (DTD) o schema di XML Schema definition language (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. Un documento XML venga considerato corretto se soddisfa i requisiti sintattici definiti dal W3C XML 1.0 Recommendation.An XML document is considered to be well formed if it meets all the syntactical requirements defined by the W3C XML 1.0 Recommendation. Viene considerato valido se è ben formata e inoltre conforme ai vincoli definiti dalla relativa DTD o nello schema.It's considered valid if it's well formed and also conforms to the constraints defined by its DTD or schema. (Vedere il W3C XML Schema Part 1: Le strutture e il W3C XML Schema Part 2: Tipi di dati raccomandazioni.) Pertanto, anche se tutti i documenti XML validi sono corretti, non tutti i documenti XML corretti sono validi.(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.

È possibile convalidare i dati rispetto a una DTD, un Schema XSD inline o uno Schema XSD archiviati in un' XmlSchemaSet oggetto (una cache); questi scenari sono descritti nel Create pagina di riferimento.You can validate the data against a DTD, an inline XSD Schema, or an XSD Schema stored in an XmlSchemaSet object (a cache); these scenarios are described on the Create reference page. XmlReader non supporta la convalida dello schema XML-Data Reduced (XDR).XmlReader doesn't support XML-Data Reduced (XDR) schema validation.

Si usano le impostazioni seguenti nel XmlReaderSettings classe per specificare il tipo di convalida, se presente, il XmlReader istanza supporta.You use the following settings on the XmlReaderSettings class to specify what type of validation, if any, the XmlReader instance supports.

Utilizzare questa opzione XmlReaderSettings membroUse this XmlReaderSettings member Per specificareTo specify
ProprietàDtdProcessingDtdProcessing property Se si desidera consentire l'elaborazione della DTD.Whether to allow DTD processing. Per impostazione predefinita l'elaborazione della DTD non è consentita.The default is to disallow DTD processing.
ProprietàValidationTypeValidationType property Indica se il lettore deve convalidare i dati e il tipo di convalida da eseguire (DTD o schema).Whether the reader should validate data, and what type of validation to perform (DTD or schema). Per impostazione predefinita non è prevista alcuna convalida dei dati.The default is no data validation.
EventoValidationEventHandlerValidationEventHandler event Un gestore eventi per la ricezione di informazioni sugli eventi di convalida.An event handler for receiving information about validation events. Se non si fornisce un gestore eventi, viene generata un'eccezione XmlException per il primo errore di convalida.If an event handler is not provided, an XmlException is thrown on the first validation error.
ProprietàValidationFlagsValidationFlags property Opzioni di convalida aggiuntiva tramite la XmlSchemaValidationFlags membri dell'enumerazione:Additional validation options through the XmlSchemaValidationFlags enumeration members:

- AllowXmlAttributes-Consente gli attributi XML (xml:*) nei documenti di istanza anche quando non sono definiti nello schema.- AllowXmlAttributes-- Allow XML attributes (xml:*) in instance documents even when they're not defined in the schema. Gli attributi vengono convalidati in base al relativo tipo di dati.The attributes are validated based on their data type. Vedere il XmlSchemaValidationFlags pagina di riferimento per l'impostazione da usare in scenari specifici.See the XmlSchemaValidationFlags reference page for the setting to use in specific scenarios. (Disabilitato per impostazione predefinita).(Disabled by default.)
- ProcessIdentityConstraints -Elabora i vincoli identity (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) incontrati durante la convalida.- ProcessIdentityConstraints --Process identity constraints (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) encountered during validation. (Abilitata per impostazione predefinita).(Enabled by default.)
- ProcessSchemaLocation -Consente di elaborare gli schemi specificati dal xsi:schemaLocation o xsi:noNamespaceSchemaLocation attributo.- ProcessSchemaLocation --Process schemas specified by the xsi:schemaLocation or xsi:noNamespaceSchemaLocation attribute. (Abilitata per impostazione predefinita).(Enabled by default.)
- ProcessInlineSchema: Schemi XML inline processo durante la convalida.- ProcessInlineSchema-- Process inline XML Schemas during validation. (Disabilitato per impostazione predefinita).(Disabled by default.)
- ReportValidationWarnings-Consente di segnalare gli eventi se si verifica un avviso di convalida.- ReportValidationWarnings--Report events if a validation warning occurs. 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.A warning is typically issued when there is no DTD or XML Schema to validate a particular element or attribute against. L'evento ValidationEventHandler viene utilizzato per la notifica.The ValidationEventHandler is used for notification. (Disabilitato per impostazione predefinita).(Disabled by default.)
Schemas Oggetto XmlSchemaSet da usare per la convalida.The XmlSchemaSet to use for validation.
ProprietàXmlResolverXmlResolver property Il XmlResolver per la risoluzione e l'accesso alle risorse esterne.The XmlResolver for resolving and accessing external resources. Ciò può includere le entità esterne, ad esempio DTD e schemi e qualsiasi xs:include o xs:import elementi contenuti nel XML Schema.This can include external entities such as DTD and schemas, and any xs:include or xs:import elements contained in the XML Schema. Se non si specifica un XmlResolver, il XmlReader Usa un valore predefinito XmlUrlResolver senza credenziali utente.If you don't specify an XmlResolver, the XmlReader uses a default XmlUrlResolver with no user credentials.

Conformità dei datiData conformance

Lettori XML che vengono creati il Create per impostazione predefinita, metodo soddisfa i requisiti di conformità seguenti:XML readers that are created by the Create method meet the following compliance requirements by default:

  • Le nuove righe e il valore di attributo vengono normalizzati in base al W3C XML 1.0 Recommendation.New lines and attribute value are normalized according to the W3C XML 1.0 Recommendation.

  • Tutte le entità vengono espansi automaticamente.All entities are automatically expanded.

  • Gli attributi predefiniti dichiarati nella definizione del tipo di documento vengono aggiunti sempre anche quando il lettore non convalida.Default attributes declared in the document type definition are always added even when the reader doesn't validate.

  • Dichiarazione di prefisso XML mappato all'URI dello spazio dei nomi XML corretto è consentita.Declaration of XML prefix mapped to the correct XML namespace URI is allowed.

  • I nomi di notazione in un'unica NotationType dichiarazione dell'attributo e NmTokens in una singola Enumeration dichiarazione di attributo sono distinti.The notation names in a single NotationType attribute declaration and NmTokens in a single Enumeration attribute declaration are distinct.

Usare questi XmlReaderSettings da abilitare le proprietà per specificare il tipo di conformità viene controllato è:Use these XmlReaderSettings properties to specify the type of conformance checks you want to enable:

Utilizzare questa opzione XmlReaderSettings proprietàUse this XmlReaderSettings property ATo Impostazione predefinitaDefault
ProprietàCheckCharactersCheckCharacters property Abilitare o disabilitare i controlli per le operazioni seguenti:Enable or disable checks for the following:

-Caratteri siano compresi nell'intervallo dei caratteri XML validi, come definito per il 2.2 Characters sezione della raccomandazione 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.
-Tutti i nomi XML vengono, come definito per il 2.3 i costrutti sintattici comuni sezione della raccomandazione 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 questa proprietà è impostata su true (impostazione predefinita), un XmlException eccezione viene generata se il file XML contiene caratteri non validi oppure nomi XML non validi (ad esempio, un nome di elemento inizia con un numero).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).
Carattere e il controllo dei nomi è abilitata.Character and name checking is enabled.

Se si imposta la proprietà CheckCharacters su false, il controllo dei caratteri per i riferimenti a entità carattere viene disattivato.Setting CheckCharacters to false turns off character checking for character entity references. Se il lettore elabora dati di tipo text, verificare sempre che i nomi XML vengono, indipendentemente da questa impostazione.If the reader is processing text data, it always checks that XML names are valid, regardless of this setting. Nota: La raccomandazione XML 1.0 richiede la conformità a livello di documento in presenza di una DTD.Note: The XML 1.0 recommendation requires document-level conformance when a DTD is present. Pertanto, se il lettore è configurato per supportare ConformanceLevel.Fragment, ma i dati XML contengono una definizione di tipo di documento (DTD), un XmlException viene generata un'eccezione.Therefore, if the reader is configured to support ConformanceLevel.Fragment, but the XML data contains a document type definition (DTD), an XmlException is thrown.
ProprietàConformanceLevelConformanceLevel property Scegliere il livello di conformità per applicare:Choose the level of conformance to enforce:

- Document.- Document. È conforme alle regole per un documento XML 1.0 corretto.Conforms to the rules for a well-formed XML 1.0 document.
- Fragment.- Fragment. È conforme alle regole per un frammento di documento in formato corretto che può essere utilizzato come un entità analizzata esterna.Conforms to the rules for a well-formed document fragment that can be consumed as an external parsed entity.
- Auto.- Auto. È conforme al livello scelto dal lettore.Conforms to the level decided by the reader.

Se i dati non sono conformi, un XmlException viene generata un'eccezione.If the data isn't in conformance, an XmlException exception is thrown.
Document

Il nodo corrente è il nodo XML in cui è attualmente posizionato il lettore XML.The current node is the XML node on which the XML reader is currently positioned. Tutti i XmlReader metodi eseguono operazioni in relazione a questo nodo e tutti XmlReader proprietà riflettono il valore del nodo corrente.All XmlReader methods perform operations in relation to this node, and all XmlReader properties reflect the value of the current node.

I metodi seguenti rendono più semplice per spostarsi tra i nodi e analizzare i dati.The following methods make it easy to navigate through nodes and parse data.

Utilizzare questa opzione XmlReaderSettings (metodo)Use this XmlReaderSettings method ATo
Read Leggere il primo nodo e passare attraverso il nodo di un flusso in un momento.Read the first node, and advance through the stream one node at a time. Tali chiamate vengono in genere eseguite all'interno di un while ciclo.Such calls are typically performed inside a while loop.

Usare il NodeType proprietà da ottenere il tipo (ad esempio, attributo, commento, elemento e così via) del nodo corrente.Use the NodeType property to get the type (for example, attribute, comment, element, and so on) of the current node.
Skip Ignora gli elementi figlio del nodo corrente e sposta al nodo successivo.Skip the children of the current node and move to the next node.
MoveToContent e MoveToContentAsyncMoveToContent and MoveToContentAsync Ignorare i nodi non di contenuto e passare al nodo di contenuto successivo oppure alla fine del file.Skip non-content nodes and move to the next content node or to the end of the file.

I nodi non di contenuto comprendono ProcessingInstruction, DocumentType, Comment, Whitespace, e SignificantWhitespace.Non-content nodes include ProcessingInstruction, DocumentType, Comment, Whitespace, and SignificantWhitespace.

Nodi di contenuto includono testo, diverso da spazi vuoti CDATA, EntityReference , e EndEntity.Content nodes include non-white space text, CDATA, EntityReference , and EndEntity.
ReadSubtree Leggere un elemento e tutti i relativi figli e restituire un nuovo XmlReader istanza impostata su ReadState.Initial.Read an element and all its children, and return a new XmlReader instance set to ReadState.Initial.

Questo metodo è utile per la creazione di limiti attorno agli elementi XML; ad esempio, se si desidera passare dati a un altro componente per l'elaborazione e si desidera limitare la quantità di dati può accedere il componente.This method is useful for creating boundaries around XML elements; for example, if you want to pass data to another component for processing and you want to limit how much of your data the component can access.

Vedere il XmlReader.Read pagina di riferimento per un esempio di spostamento all'interno di un nodo di un flusso di testo alla volta e la visualizzazione del tipo di ogni nodo.See the XmlReader.Read reference page for an example of navigating through a text stream one node at a time and displaying the type of each node.

Le sezioni seguenti descrivono come è possibile leggere tipi specifici di dati, ad esempio elementi, attributi e dati tipizzati.The following sections describe how you can read specific types of data, such as elements, attributes, and typed data.

Elementi XML durante la letturaReading XML elements

Nella tabella seguente sono elencati i metodi e proprietà che il XmlReader classe fornisce per l'elaborazione degli elementi.The following table lists the methods and properties that the XmlReader class provides for processing elements. Dopo che il tipo XmlReader è stato posizionato in corrispondenza di un elemento, le proprietà del nodo, quale Name, riflettono i valori dell'elemento.After the XmlReader is positioned on an element, the node properties, such as Name, reflect the element values. Oltre ai membri descritti di seguito, è possibile usare qualsiasi metodo e proprietà generale della classe XmlReader per elaborare gli elementi.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. Il metodo ReadInnerXml può essere utilizzato, ad esempio, per leggere il contenuto di un elemento.For example, you can use the ReadInnerXml method to read the contents of an element.

Nota

Vedere la sezione 3.1 del W3C XML 1.0 Recommendation per le definizioni di tag di inizio, fine, tag e i tag di elemento vuoto.See section 3.1 of the W3C XML 1.0 Recommendation for definitions of start tags, end tags, and empty element tags.

Utilizzare questa opzione XmlReader membroUse this XmlReader member ATo
Metodo IsStartElementIsStartElement method Verificare se il nodo corrente è un tag di inizio o un tag di elemento vuoto.Check if the current node is a start tag or an empty element tag.
Metodo ReadStartElementReadStartElement method Verificare che il nodo corrente è un elemento e far avanzare il lettore al nodo successivo (chiamate IsStartElement seguita da Read).Check that the current node is an element and advance the reader to the next node (calls IsStartElement followed by Read).
Metodo ReadEndElementReadEndElement method Verificare che il nodo corrente è un tag di fine e far avanzare il lettore al nodo successivo.Check that the current node is an end tag and advance the reader to the next node.
Metodo ReadElementStringReadElementString method Leggere un elemento di solo testo.Read a text-only element.
Metodo ReadToDescendantReadToDescendant method Passare il lettore XML al successivo elemento discendente (figlio) che ha il nome specificato.Advance the XML reader to the next descendant (child) element that has the specified name.
Metodo ReadToNextSiblingReadToNextSibling method Far avanzare il lettore XML sull'elemento di pari livello successivo con il nome specificato.Advance the XML reader to the next sibling element that has the specified name.
ProprietàIsEmptyElementIsEmptyElement property Controllare se l'elemento corrente dispone di un tag di fine dell'elemento.Check if the current element has an end element tag. Ad esempio:For example:

- <item num="123"/> (IsEmptyElement è true.)- <item num="123"/> (IsEmptyElement is true.)
- <item num="123"> </item> (IsEmptyElement è false, anche se il contenuto dell'elemento è vuoto.)- <item num="123"> </item> (IsEmptyElement is false, although the element's content is empty.)

Per un esempio di leggere il contenuto di testo degli elementi, vedere il ReadString (metodo).For an example of reading the text content of elements, see the ReadString method. Nell'esempio seguente consente di elaborare elementi usando un while ciclo.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

Attributi XML durante la letturaReading XML attributes

Gli attributi XML si trovano in genere sugli elementi, ma sono anche autorizzati in dichiarazioni XML e nodi di tipo document.XML attributes are most commonly found on elements, but they're also allowed on XML declaration and document type nodes.

Quando è posizionata su un nodo elemento, il MoveToAttribute metodo consente di scorrere l'elenco di attributi dell'elemento.When positioned on an element node, the MoveToAttribute method lets you go through the attribute list of the element. Si noti che dopo aver MoveToAttribute è stato chiamato, le proprietà dei nodi, ad esempio Name, NamespaceURI, e Prefix rispecchiano le proprietà di tale attributo, non le proprietà dell'elemento l'attributo a cui appartiene.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.

Il XmlReader classe fornisce questi metodi e proprietà per leggere ed elaborare gli attributi per gli elementi.The XmlReader class provides these methods and properties to read and process attributes on elements.

Utilizzare questa opzione XmlReader membroUse this XmlReader member ATo
ProprietàHasAttributesHasAttributes property Controllare se il nodo corrente dispone di attributi.Check whether the current node has any attributes.
ProprietàAttributeCountAttributeCount property Ottiene il numero di attributi nell'elemento corrente.Get the number of attributes on the current element.
Metodo MoveToFirstAttributeMoveToFirstAttribute method Spostare il primo attributo in un elemento.Move to the first attribute in an element.
Metodo MoveToNextAttributeMoveToNextAttribute method Spostare l'attributo successivo in un elemento.Move to the next attribute in an element.
Metodo MoveToAttributeMoveToAttribute method Passare a un attributo specificato.Move to a specified attribute.
GetAttribute metodo o Item[String, String] proprietàGetAttribute method or Item[String, String] property Ottenere il valore di un attributo specificato.Get the value of a specified attribute.
ProprietàIsDefaultIsDefault property Controllare se il nodo corrente è un attributo generato dal valore predefinito definito nella DTD o schema.Check whether the current node is an attribute that was generated from the default value defined in the DTD or schema.
Metodo MoveToElementMoveToElement method Spostare l'elemento che possiede l'attributo corrente.Move to the element that owns the current attribute. Utilizzare questo metodo per restituire a un elemento dopo aver esplorato gli attributi.Use this method to return to an element after navigating through its attributes.
Metodo ReadAttributeValueReadAttributeValue method Analizzare il valore dell'attributo in uno o più Text, EntityReference, o EndEntity nodi.Parse the attribute value into one or more Text, EntityReference, or EndEntity nodes.

Per elaborare gli attributi è possibile utilizzare anche qualsiasi metodo e proprietà generale del tipo XmlReader.Any of the general XmlReader methods and properties can also be used to process attributes. Dopo che il tipo XmlReader è stato posizionato in corrispondenza di un attributo, ad esempio, le proprietà Name e Value riflettono i valori dell'attributo.For example, after the XmlReader is positioned on an attribute, the Name and Value properties reflect the values of the attribute. È inoltre possibile utilizzare qualsiasi metodo Read del contenuto per ottenere il valore dell'attributo.You can also use any of the content Read methods to get the value of the attribute.

Questo esempio viene usato il AttributeCount proprietà per spostarsi tra tutti gli attributi su un elemento.This example uses the AttributeCount property to navigate through all the attributes on an element.

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

Questo esempio Usa la MoveToNextAttribute metodo in un while ciclo per spostarsi tra gli attributi.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

Lettura di attributi su nodi della dichiarazione XMLReading attributes on XML declaration nodes

Quando si posiziona il lettore XML su un nodo della dichiarazione XML, il Value proprietà restituisce la versione autonoma e le informazioni di codifica come un'unica stringa.When the XML reader is positioned on an XML declaration node, the Value property returns the version, standalone, and encoding information as a single string. XmlReader gli oggetti creati dal Create metodo, il XmlTextReader (classe) e il XmlValidatingReader espongono la versione autonoma e gli elementi di codifica come attributi.XmlReader objects created by the Create method, the XmlTextReader class, and the XmlValidatingReader class expose the version, standalone, and encoding items as attributes.

La lettura degli attributi in nodi di tipo di documentoReading attributes on document type nodes

Quando si posiziona il lettore XML su un nodo di tipo documento, il GetAttribute metodo e Item[String, String] proprietà può essere utilizzata per restituire i valori per i valori letterali SYSTEM e PUBLIC.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. Ad esempio, la chiamata al metodo reader.GetAttribute("PUBLIC") restituisce il valore PUBLIC.For example, calling reader.GetAttribute("PUBLIC") returns the PUBLIC value.

La lettura degli attributi in nodi di istruzioni di elaborazioneReading attributes on processing instruction nodes

Quando il tipo XmlReader è posizionato in corrispondenza di un nodo di istruzioni di elaborazione, la proprietà Value restituisce l'intero contenuto di testo.When the XmlReader is positioned on a processing instruction node, the Value property returns the entire text content. Gli elementi nel nodo istruzione di elaborazione non sono considerati come attributi.Items in the processing instruction node aren't treated as attributes. Non possono essere letti con il GetAttribute o MoveToAttribute (metodo).They can't be read with the GetAttribute or MoveToAttribute method.

Contenuto XML durante la letturaReading XML content

La classe XMLReader include i membri seguenti che leggere il contenuto da un file XML e restituisce il contenuto come valori di stringa.The XMLReader class includes the following members that read content from an XML file and return the content as string values. (Per restituire i tipi CLR, vedere la nella sezione successiva.)(To return CLR types, see the next section.)

Utilizzare questa opzione XmlReader membroUse this XmlReader member ATo
ProprietàValueValue property Ottenere il contenuto di testo del nodo corrente.Get the text content of the current node. Il valore restituito dipende dal tipo di nodo; vedere il Value pagina di riferimento per i dettagli.The value returned depends on the node type; see the Value reference page for details.
Metodo ReadStringReadString method Ottenere il contenuto di un nodo elemento o testo come stringa.Get the content of an element or text node as a string. Questo metodo arresta in istruzioni di elaborazione e commenti.This method stops on processing instructions and comments.

Per informazioni dettagliate sul modo in cui questo metodo gestisce i tipi di nodo specifico, vedere il ReadString pagina di riferimento.For details on how this method handles specific node types, see the ReadString reference page.
Metodi ReadInnerXml e ReadInnerXmlAsyncReadInnerXml and ReadInnerXmlAsync methods Ottieni tutto il contenuto del nodo corrente, inclusi i markup, escluso il tag di inizio e fine.Get all the content of the current node, including the markup, but excluding start and end tags. Ad esempio, per:For example, for:

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

ReadInnerXml Restituisce:ReadInnerXml returns:

this<child id="123"/>
Metodi ReadOuterXml e ReadOuterXmlAsyncReadOuterXml and ReadOuterXmlAsync methods Ottieni tutto il contenuto del nodo corrente e dei relativi elementi figlio, inclusi i tag di markup e di inizio/fine.Get all the content of the current node and its children, including markup and start/end tags. Ad esempio, per:For example, for:

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

ReadOuterXml Restituisce:ReadOuterXml returns:

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

La conversione in tipi CLRConverting to CLR types

È possibile usare i membri del XmlReader classe (elencati nella tabella seguente) per leggere i dati XML e i valori come common language runtime (CLR) tipi restituiti anziché stringhe.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. Questi membri consentono di ottenere i valori nella rappresentazione più appropriata per l'attività di codifica senza dover eseguire manualmente analizzare o convertire i valori di stringa.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.

  • Il ReadElementContentAs metodi possono essere chiamati solo su tipi di nodo elemento.The ReadElementContentAs methods can only be called on element node types. e non possono essere utilizzati su elementi contenenti elementi figlio o contenuto misto.These methods cannot be used on elements that contain child elements or mixed content. 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.When called, the XmlReader object reads the start tag, reads the element content, and then moves past the end element tag. Le istruzioni di elaborazione e i commenti vengono ignorati e le entità vengono espanse.Processing instructions and comments are ignored and entities are expanded.

  • Il ReadContentAs metodi leggere il contenuto di testo nella posizione corrente del lettore e se i dati XML non include lo schema o dati digitare le informazioni associate, convertire il contenuto di testo per il tipo restituito richiesto.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. Il testo, gli spazi vuoti, gli spazi vuoti significativi e le sezioni CDATA sono concatenati.Text, white space, significant white space and CDATA sections are concatenated. I commenti e istruzioni di elaborazione vengono ignorate e i riferimenti alle entità vengono risolti automaticamente.Comments and processing instructions are skipped, and entity references are automatically resolved.

Il XmlReader classe utilizza le regole definite dal W3C XML Schema Part 2: Tipi di dati raccomandazione.The XmlReader class uses the rules defined by the W3C XML Schema Part 2: Datatypes recommendation.

Utilizzare questa opzione XmlReader (metodo)Use this XmlReader method Per restituire il 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 Il tipo specificato con il returnType parametroThe type you specify with the returnType parameter
ReadContentAsObject e ReadElementContentAsObjectReadContentAsObject and ReadElementContentAsObject Il tipo più appropriato, come specificato da di XmlReader.ValueType proprietà.The most appropriate type, as specified by the XmlReader.ValueType property. Visualizzare supporto dei tipi di dati nelle classi System. XML per informazioni di mapping.See Type Support in the System.Xml Classes for mapping information.

Se un elemento non può essere facilmente convertito in un tipo CLR a causa di un formato, è possibile usare un mapping dello schema per garantire una corretta conversione.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. L'esempio seguente usa un file XSD per convertire il hire-date elemento per il xs:date tipo e quindi Usa il ReadElementContentAsDateTime per restituire l'elemento come un DateTime oggetto.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.

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

Codice:Code:

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

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

Programmazione asincronaAsynchronous programming

La maggior parte del XmlReader metodi hanno controparti asincrone con "Async" alla fine dei relativi nomi di metodo.Most of the XmlReader methods have asynchronous counterparts that have "Async" at the end of their method names. Ad esempio, l'equivalente di asincrone ReadContentAsObject è ReadContentAsObjectAsync.For example, the asynchronous equivalent of ReadContentAsObject is ReadContentAsObjectAsync.

I metodi seguenti sono utilizzabili con le chiamate asincrone:The following methods can be used with asynchronous method calls:

Le sezioni seguenti descrivono l'utilizzo asincrono per i metodi che non hanno controparti asincrone.The following sections describe asynchronous usage for methods that don't have asynchronous counterparts.

ReadStartElement, metodoReadStartElement 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

Metodo 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

Metodo 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

Metodo 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

Metodo 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

Considerazioni sulla sicurezzaSecurity considerations

Tenere presente quanto segue quando si lavora con i XmlReader classe:Consider the following when working with the XmlReader class:

  • Le eccezioni generate dal XmlReader possono rivelare informazioni sui percorsi che si preferisca non venga propagato fino all'app.Exceptions thrown from the XmlReader can disclose path information that you might not want bubbled up to your app. L'app deve intercettare le eccezioni ed elaborarli in modo appropriato.Your app must catch exceptions and process them appropriately.

  • Non abilitare l'elaborazione DTD se si teme di tipo denial of problemi del servizio o se usano origini non attendibili.Do not enable DTD processing if you're concerned about denial of service issues or if you're dealing with untrusted sources. L'elaborazione della DTD è disabilitata per impostazione predefinita per XmlReader degli oggetti creati dal Create (metodo).DTD processing is disabled by default for XmlReader objects created by the Create method.

    Se l'elaborazione della DTD è attivata, è possibile utilizzare il tipo XmlSecureResolver per limitare le risorse a cui il tipo XmlReader può accedere.If you have DTD processing enabled, you can use the XmlSecureResolver to restrict the resources that the XmlReader can access. È anche possibile progettare l'app in modo che l'elaborazione di XML è memoria e tempo limitato.You can also design your app so that the XML processing is memory and time constrained. Ad esempio, è possibile configurare limiti di timeout nell'app ASP.NET.For example, you can configure time-out limits in your ASP.NET app.

  • È possibile che i dati XML includano riferimenti a risorse esterne quali, ad esempio, un file dello schema.XML data can include references to external resources such as a schema file. Per impostazione predefinita, le risorse esterne vengono risolte utilizzando un XmlUrlResolver oggetto senza credenziali utente.By default, external resources are resolved by using an XmlUrlResolver object with no user credentials. È possibile migliorare i livelli di sicurezza mediante una delle seguenti operazioni:You can secure this further by doing one of the following:

  • Il ProcessInlineSchema e ProcessSchemaLocation i flag di convalida di un XmlReaderSettings oggetto non impostato per impostazione predefinita.The ProcessInlineSchema and ProcessSchemaLocation validation flags of an XmlReaderSettings object aren't set by default. Ciò consente di proteggere il tipo XmlReader da attacchi basati sullo schema durante l'elaborazione dei dati XML da un'origine non attendibile.This helps to protect the XmlReader against schema-based attacks when it is processing XML data from an untrusted source. 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.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 il XmlResolver è impostata su null, le posizioni degli schemi non vengono risolte anche se il ProcessInlineSchema e ProcessSchemaLocation vengono impostati i flag di convalida.If the XmlResolver property is set to null, schema locations aren't resolved even if the ProcessInlineSchema and ProcessSchemaLocation validation flags are set.

    Gli schemi aggiunti durante la convalida aggiungono nuovi tipi e possono alterare l'esito della convalida del documento in esame.Schemas added during validation add new types and can change the validation outcome of the document being validated. Di conseguenza, gli schemi esterni devono essere risolti solo da origini attendibili.As a result, external schemas should only be resolved from trusted sources.

    Si consiglia di disabilitare il ProcessIdentityConstraints flag durante la convalida di documenti XML non attendibili di grandi dimensioni in scenari a disponibilità elevata rispetto a uno schema con vincoli di identità su una vasta parte del documento.We recommend disabling the ProcessIdentityConstraints flag when validating untrusted, large XML documents in high availability scenarios against a schema that has identity constraints over a large part of the document. Questo flag è abilitato per impostazione predefinita.This flag is enabled by default.

  • 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.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. Per limitare le dimensioni dell'input inviato al XmlReader, è possibile:To limit the size of the input that is sent to the XmlReader, you can:

  • Il ReadValueChunk metodo può essere utilizzato per gestire grandi flussi di dati.The ReadValueChunk method can be used to handle large streams of data. Questo metodo consente di leggere un numero ridotto di caratteri alla volta invece di allocare una singola stringa per l'intero valore.This method reads a small number of characters at a time instead of allocating a single string for the whole value.

  • Durante la lettura di un documento XML con un numero elevato di nomi univoci locali, gli spazi dei nomi o prefissi, può verificarsi un problema.When reading an XML document with a large number of unique local names, namespaces, or prefixes, a problem can occur. Se si usa una classe che deriva da XmlReader, e si chiama il LocalName, Prefix, o NamespaceURI proprietà per ogni elemento, la stringa restituita viene aggiunta a un NameTable.If you are using a class that derives from XmlReader, and you call the LocalName, Prefix, or NamespaceURI property for each item, the returned string is added to a NameTable. La raccolta contenuta la NameTable mai riduzioni delle dimensioni, la creazione di una perdita di memoria virtuale degli handle di stringa.The collection held by the NameTable never decreases in size, creating a virtual memory leak of the string handles. Una mitigazione per questo consiste nel derivarlo dal NameTable classe e applicare una quota di dimensioni massime.One mitigation for this is to derive from the NameTable class and enforce a maximum size quota. (Non è possibile per evitare l'uso di un NameTable, o per passare il NameTable quando è pieno).(There is no way to prevent the use of a NameTable, or to switch the NameTable when it is full). Un'altra soluzione consiste nell'evitare di usare le proprietà citate e impiegare invece il MoveToAttribute metodo con il IsStartElement metodo laddove possibile; questi metodi non restituiscono stringhe e pertanto evitare il problema di superamento del NameTable raccolta.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.

  • Gli oggetti XmlReaderSettings possono contenere informazioni sensibili quali le credenziali utente.XmlReaderSettings objects can contain sensitive information such as user credentials. 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.An untrusted component could use the XmlReaderSettings object and its user credentials to create XmlReader objects to read data. Prestare attenzione durante la memorizzazione nella cache XmlReaderSettings oggetti, o quando si passa il XmlReaderSettings oggetto da un componente a un altro.Be careful when caching XmlReaderSettings objects, or when passing the XmlReaderSettings object from one component to another.

  • Non accettare componenti di supporto, ad esempio oggetti NameTable, XmlNamespaceManager e XmlResolver da un'origine non attendibile.Do not accept supporting components, such as NameTable, XmlNamespaceManager, and XmlResolver objects, from an untrusted source.

Costruttori

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

Inizializza una nuova istanza della classe XmlReader.Initializes a new instance of the XmlReader class.

Proprietà

AttributeCount AttributeCount AttributeCount AttributeCount

Quando sottoposto a override in una classe derivata, ottiene il numero di attributi sul nodo corrente.When overridden in a derived class, gets the number of attributes on the current node.

BaseURI BaseURI BaseURI BaseURI

Quando sottoposto a override in una classe derivata, ottiene l'URI di base del nodo corrente.When overridden in a derived class, gets the base URI of the current node.

CanReadBinaryContent CanReadBinaryContent CanReadBinaryContent CanReadBinaryContent

Ottiene un valore che indica se XmlReader implementa metodi di lettura del contenuto binario.Gets a value indicating whether the XmlReader implements the binary content read methods.

CanReadValueChunk CanReadValueChunk CanReadValueChunk CanReadValueChunk

Ottiene un valore che indica se XmlReader implementa il metodo ReadValueChunk(Char[], Int32, Int32).Gets a value indicating whether the XmlReader implements the ReadValueChunk(Char[], Int32, Int32) method.

CanResolveEntity CanResolveEntity CanResolveEntity CanResolveEntity

Ottiene un valore che indica se il lettore può analizzare e risolvere le entità.Gets a value indicating whether this reader can parse and resolve entities.

Depth Depth Depth Depth

Quando sottoposto a override in una classe derivata, ottiene la profondità del nodo corrente nel documento XML.When overridden in a derived class, gets the depth of the current node in the XML document.

EOF EOF EOF EOF

Quando sottoposto a override in una classe derivata, ottiene un valore che indica se il lettore è posizionato al termine del flusso.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

Ottiene un valore che indica se il nodo corrente dispone di attributi.Gets a value indicating whether the current node has any attributes.

HasValue HasValue HasValue HasValue

Quando sottoposto a override in una classe derivata, ottiene un valore che indica se il nodo corrente può presentare una proprietà Value.When overridden in a derived class, gets a value indicating whether the current node can have a Value.

IsDefault IsDefault IsDefault IsDefault

Quando sottoposto a 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.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 viene eseguito l'override in una classe derivata, ottiene un valore che indica se il nodo corrente è un elemento vuoto, ad esempio <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 sottoposto a override in una classe derivata, ottiene il valore dell'attributo con l'indice specificato.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 sottoposto a override in una classe derivata, ottiene il valore dell'attributo con le proprietà LocalName e NamespaceURI specificate.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 sottoposto a override in una classe derivata, ottiene il valore dell'attributo con la proprietà Name specificata.When overridden in a derived class, gets the value of the attribute with the specified Name.

LocalName LocalName LocalName LocalName

Quando sottoposto a override in una classe derivata, ottiene il nome locale del nodo corrente.When overridden in a derived class, gets the local name of the current node.

Name Name Name Name

Quando sottoposto a override in una classe derivata, ottiene il nome completo del nodo corrente.When overridden in a derived class, gets the qualified name of the current node.

NamespaceURI NamespaceURI NamespaceURI 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.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 sottoposto a override in una classe derivata, ottiene l'oggetto XmlNameTable associato a questa implementazione.When overridden in a derived class, gets the XmlNameTable associated with this implementation.

NodeType NodeType NodeType NodeType

Quando sottoposto a override in una classe derivata, ottiene il tipo del nodo corrente.When overridden in a derived class, gets the type of the current node.

Prefix Prefix Prefix Prefix

Quando sottoposto a override in una classe derivata, ottiene il prefisso dello spazio dei nomi associato al nodo corrente.When overridden in a derived class, gets the namespace prefix associated with the current node.

QuoteChar QuoteChar QuoteChar QuoteChar

Quando sottoposto a override in una classe derivata, ottiene il carattere punto interrogativo (?) utilizzato per delimitare il valore di un nodo attributo.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 sottoposto a override in una classe derivata, ottiene lo stato del lettore.When overridden in a derived class, gets the state of the reader.

SchemaInfo SchemaInfo SchemaInfo SchemaInfo

Ottiene le informazioni sullo schema assegnate al nodo corrente in seguito alla convalida dello schema.Gets the schema information that has been assigned to the current node as a result of schema validation.

Settings Settings Settings Settings

Ottiene l'oggetto XmlReaderSettings usato per creare questa istanza di XmlReader.Gets the XmlReaderSettings object used to create this XmlReader instance.

Value Value Value Value

Quando sottoposto a override in una classe derivata, ottiene il valore del testo del nodo corrente.When overridden in a derived class, gets the text value of the current node.

ValueType ValueType ValueType ValueType

Ottiene il tipo CLR (Common Language Runtime) relativo al nodo corrente.Gets The Common Language Runtime (CLR) type for the current node.

XmlLang XmlLang XmlLang XmlLang

Quando ne viene eseguito l'override in una classe derivata, ottiene l'ambito xml:lang corrente.When overridden in a derived class, gets the current xml:lang scope.

XmlSpace XmlSpace XmlSpace XmlSpace

Quando ne viene eseguito l'override in una classe derivata, ottiene l'ambito xml:space corrente.When overridden in a derived class, gets the current xml:space scope.

Metodi

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

Quando sottoposto a override in una classe derivata, modifica la proprietà ReadState in Closed.When overridden in a derived class, changes the ReadState to Closed.

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

Crea una nuova istanza di XmlReader con il flusso specificato e le impostazioni predefinite.Creates a new XmlReader instance using the specified stream with default settings.

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

Crea una nuova istanza di XmlReader con il flusso e le impostazioni specificati.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)

Crea una nuova istanza di XmlReader con il flusso, l'URI di base e le impostazioni specificati.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)

Crea una nuova istanza di XmlReader con il flusso, le impostazioni e le informazioni di contesto specificati per l'analisi.Creates a new XmlReader instance using the specified stream, settings, and context information for parsing.

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

Crea una nuova istanza di XmlReader con l'URI specificato.Creates a new XmlReader instance with specified URI.

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

Crea una nuova istanza di XmlReader con l'URI e le impostazioni specificati.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)

Crea una nuova istanza di XmlReader con l'URI, le impostazioni e le informazioni di contesto specificati per l'analisi.Creates a new XmlReader instance by using the specified URI, settings, and context information for parsing.

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

Crea una nuova istanza di XmlReader con il lettore di testo specificato.Creates a new XmlReader instance by using the specified text reader.

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

Crea una nuova istanza di XmlReader con il lettore di testo e le impostazioni specificati.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)

Crea una nuova istanza di XmlReader con il lettore di testo, le impostazioni e l'URI di base specificati.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)

Crea una nuova istanza di XmlReader con il lettore di testo, le impostazioni e le informazioni di contesto specificati per l'analisi.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)

Crea una nuova istanza di XmlReader con il lettore XML e le impostazioni specificate.Creates a new XmlReader instance by using the specified XML reader and settings.

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

Rilascia tutte le risorse usate dall'istanza corrente della classe XmlReader.Releases all resources used by the current instance of the XmlReader class.

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

Rilascia le risorse non gestite usate da XmlReader e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the XmlReader and optionally releases the managed resources.

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

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

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

Quando sottoposto a override in una classe derivata, ottiene il valore dell'attributo con l'indice specificato.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 sottoposto a override in una classe derivata, ottiene il valore dell'attributo con la proprietà Name specificata.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 sottoposto a override in una classe derivata, ottiene il valore dell'attributo con le proprietà LocalName e NamespaceURI specificate.When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

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

Funge da funzione hash predefinita.Serves as the default hash function.

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

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

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

Ottiene in modo asincrono il valore del nodo corrente.Asynchronously gets the value of the current node.

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

Restituisce un valore che indica se l'argomento della stringa è un nome XML valido.Returns a value indicating whether the string argument is a valid XML name.

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

Restituisce un valore che indica se l'argomento della stringa è un token di un nome XML valido o meno.Returns a value indicating whether or not the string argument is a valid XML name token.

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

Chiama il metodo MoveToContent() e verifica se il nodo di contenuto corrente è un tag di inizio oppure un tag di elemento vuoto.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)

Chiama il metodo MoveToContent() e verifica se il nodo di contenuto corrente è un tag di inizio oppure un tag di elemento vuoto e se la proprietà Name dell'elemento individuato corrisponde all'argomento specificato.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)

Chiama il metodo MoveToContent() e verifica se il nodo di contenuto corrente è un tag di inizio oppure un tag di elemento vuoto e se le proprietà LocalName e NamespaceURI dell'elemento trovato corrispondono alle stringhe specificate.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 sottoposto a override in una classe derivata, risolve il prefisso di uno spazio dei nomi nell'ambito dell'elemento corrente.When overridden in a derived class, resolves a namespace prefix in the current element's scope.

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

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

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

Quando sottoposto a override in una classe derivata, si sposta in corrispondenza dell'attributo con l'indice specificato.When overridden in a derived class, moves to the attribute with the specified index.

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

Quando sottoposto a override in una classe derivata, si sposta in corrispondenza dell'attributo con la proprietà Name specificata.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 sottoposto a override in una classe derivata, si sposta in corrispondenza dell'attributo con le proprietà LocalName e NamespaceURI specificate.When overridden in a derived class, moves to the attribute with the specified LocalName and NamespaceURI.

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

Verifica se il nodo corrente rappresenta un nodo di contenuto, ovvero un nodo testo non spazio vuoto, CDATA, Element, EndElement, EntityReference o EndEntity.Checks whether the current node is a content (non-white space text, CDATA, Element, EndElement, EntityReference, or EndEntity) node. Se il nodo non è un nodo di contenuto, il lettore passa al nodo di contenuto successivo oppure alla fine del file.If the node is not a content node, the reader skips ahead to the next content node or end of file. Vengono inoltre ignorati i seguenti tipi di nodo: ProcessingInstruction, DocumentType, Comment, Whitespace o SignificantWhitespace.It skips over nodes of the following type: ProcessingInstruction, DocumentType, Comment, Whitespace, or SignificantWhitespace.

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

Verifica in modo asincrono se il nodo corrente è un nodo di contenuto.Asynchronously checks whether the current node is a content node. Se il nodo non è un nodo di contenuto, il lettore passa al nodo di contenuto successivo oppure alla fine del file.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 sottoposto a override in una classe derivata, si sposta in corrispondenza dell'elemento contenente il nodo attributo corrente.When overridden in a derived class, moves to the element that contains the current attribute node.

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

Quando sottoposto a override in una classe derivata, si sposta in corrispondenza del primo attributo.When overridden in a derived class, moves to the first attribute.

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

Quando sottoposto a override in una classe derivata, si sposta in corrispondenza del successivo attributo.When overridden in a derived class, moves to the next attribute.

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

Quando ne viene eseguito l'override in una classe derivata, visualizza il nodo successivo nel flusso.When overridden in a derived class, reads the next node from the stream.

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

In modo asincrono legge il nodo successivo del flusso.Asynchronously reads the next node from the stream.

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

Quando sottoposto a override in una classe derivata, analizza il valore dell'attributo presente in uno o più nodi Text, EntityReference o EndEntity.When overridden in a derived class, parses the attribute value into one or more Text, EntityReference, or EndEntity nodes.

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

Legge il contenuto come oggetto del tipo specificato.Reads the content as an object of the type specified.

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

Legge in modo asincrono il contenuto come oggetto del tipo specificato.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)

Legge il contenuto e restituisce byte binari decodificati 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)

Legge in modo asincrono il contenuto e restituisce byte binari decodificati 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)

Legge il contenuto e restituisce i byte binari decodificati 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)

Legge in modo asincrono il contenuto e restituisce byte binari decodificati BinHex.Asynchronously reads the content and returns the BinHex decoded binary bytes.

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

Legge il contenuto di testo nella posizione corrente come Boolean.Reads the text content at the current position as a Boolean.

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

Legge il contenuto di testo nella posizione corrente come oggetto DateTime.Reads the text content at the current position as a DateTime object.

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

Legge il contenuto di testo nella posizione corrente come oggetto DateTimeOffset.Reads the text content at the current position as a DateTimeOffset object.

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

Legge il contenuto di testo nella posizione corrente come oggetto Decimal.Reads the text content at the current position as a Decimal object.

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

Legge il contenuto di testo nella posizione corrente come numero a virgola mobile e precisione doppia.Reads the text content at the current position as a double-precision floating-point number.

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

Legge il contenuto di testo nella posizione corrente come numero a virgola mobile e precisione singola.Reads the text content at the current position as a single-precision floating point number.

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

Legge il contenuto di testo nella posizione corrente come valore intero con segno a 32 bit.Reads the text content at the current position as a 32-bit signed integer.

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

Legge il contenuto di testo nella posizione corrente come valore intero con segno a 64 bit.Reads the text content at the current position as a 64-bit signed integer.

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

Legge il contenuto di testo nella posizione corrente come Object.Reads the text content at the current position as an Object.

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

Legge in modo asincrono il contenuto di testo nella posizione corrente come oggetto Object.Asynchronously reads the text content at the current position as an Object.

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

Legge il contenuto di testo nella posizione corrente come oggetto String.Reads the text content at the current position as a String object.

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

Legge in modo asincrono il contenuto di testo nella posizione corrente come oggetto 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)

Legge il contenuto dell'elemento come il tipo richiesto.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 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.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)

Legge in modo asincrono il contenuto dell'elemento come il tipo richiesto.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)

Legge l'elemento e decodifica il contenuto 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)

Legge in modo asincrono l'elemento e decodifica il contenuto 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)

Legge l'elemento e decodifica il contenuto 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)

Legge in modo asincrono l'elemento e decodifica il contenuto BinHex.Asynchronously reads the element and decodes the BinHex content.

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

Legge l'elemento corrente e restituisce il contenuto come oggetto 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 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.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()

Legge l'elemento corrente e restituisce il contenuto come oggetto 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 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.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()

Legge l'elemento corrente e restituisce il contenuto come oggetto 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 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.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()

Legge l'elemento corrente e restituisce il contenuto come numero a virgola mobile e precisione doppia.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 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.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()

Legge l'elemento corrente e restituisce il contenuto come numero a virgola mobile e precisione singola.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 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.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()

Legge l'elemento corrente e restituisce il contenuto come valore intero con segno a 32 bit.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 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.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()

Legge l'elemento corrente e restituisce il contenuto come valore intero con segno a 64 bit.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 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.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()

Legge l'elemento corrente e restituisce il contenuto come 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 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.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()

Legge in modo asincrono l'elemento corrente e restituisce il contenuto come Object.Asynchronously reads the current element and returns the contents as an Object.

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

Legge l'elemento corrente e restituisce il contenuto come oggetto 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 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.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()

Legge in modo asincrono l'elemento corrente e restituisce il contenuto come oggetto String.Asynchronously reads the current element and returns the contents as a String object.

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

Legge un elemento di solo testo.Reads a text-only element. È tuttavia consigliabile usare il metodo ReadElementContentAsString(), perché fornisce un modo più diretto per gestire questa operazione.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 che la proprietà Name dell'elemento trovato corrisponda alla stringa specificata prima di leggere un elemento di solo testo.Checks that the Name property of the element found matches the given string before reading a text-only element. È tuttavia consigliabile usare il metodo ReadElementContentAsString(), perché fornisce un modo più diretto per gestire questa operazione.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 che le proprietà LocalName e NamespaceURI dell'elemento trovato corrispondano alle stringhe specificate prima di leggere un elemento di solo testo.Checks that the LocalName and NamespaceURI properties of the element found matches the given strings before reading a text-only element. È tuttavia consigliabile usare il metodo ReadElementContentAsString(String, String), perché fornisce un modo più diretto per gestire questa operazione.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 che il nodo di contenuto corrente sia un tag di fine e fa avanzare il lettore al nodo successivo.Checks that the current content node is an end tag and advances the reader to the next node.

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

Quando sottoposto a override in una classe derivata, legge tutto il contenuto come stringa, incluso il markup.When overridden in a derived class, reads all the content, including markup, as a string.

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

In modo asincrono legge tutti i contenuti, incluso il markup, come stringa.Asynchronously reads all the content, including markup, as a string.

ReadOuterXml() ReadOuterXml() ReadOuterXml() ReadOuterXml()

Quando sottoposto a override in una classe derivata, legge il contenuto che rappresenta questo nodo ed i relativi elementi figlio, incluso il markup.When overridden in a derived class, reads the content, including markup, representing this node and all its children.

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

In modo asincrono legge i contenuti che rappresentano questo nodo, incluso il markup, e i relativi elementi figlio.Asynchronously reads the content, including markup, representing this node and all its children.

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

Verifica che il nodo corrente sia un elemento e fa avanzare il lettore al nodo successivo.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 il nodo corrente è un elemento con la proprietà Name specificata e fa avanzare il lettore al nodo successivo.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 il nodo corrente è un elemento con le proprietà LocalName e NamespaceURI specificate e fa avanzare il lettore al nodo successivo.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 sottoposto a override in una classe derivata, legge il contenuto di un nodo elemento o testo come se si trattasse di una stringa.When overridden in a derived class, reads the contents of an element or text node as a string. È tuttavia consigliabile usare il metodo ReadElementContentAsString, perché fornisce un modo più diretto per gestire questa operazione.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()

Restituisce una nuova istanza di XmlReader che è possibile utilizzare per leggere il nodo corrente e tutti i relativi discendenti.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)

Sposta l'oggetto XmlReader al successivo elemento discendente con il nome completo specificato.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)

Sposta l'oggetto XmlReader al successivo elemento discendente con il nome locale e l'URI dello spazio dei nomi specificati.Advances the XmlReader to the next descendant element with the specified local name and namespace URI.

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

Prosegue la lettura fino a quando non viene individuato un elemento con il nome completo specificato.Reads until an element with the specified qualified name is found.

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

Prosegue la lettura fino a quando non viene individuato un elemento con il nome locale e l'URI dello spazio dei nomi specificati.Reads until an element with the specified local name and namespace URI is found.

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

Sposta l'oggetto XmlReader al successivo elemento di pari livello con il nome completo specificato.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)

Sposta l'oggetto XmlReader al successivo elemento di pari livello con il nome locale e l'URI dello spazio dei nomi specificati.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)

Legge flussi di testo di grandi dimensioni incorporati in un 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)

Legge in modo asincrono flussi di testo di grandi dimensioni incorporati in un documento XML.Asynchronously reads large streams of text embedded in an XML document.

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

Quando sottoposto a override in una classe derivata, risolve il riferimento all'entità per i nodi EntityReference.When overridden in a derived class, resolves the entity reference for EntityReference nodes.

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

Ignora gli elementi figlio del nodo corrente.Skips the children of the current node.

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

Ignora in modo asincrono gli elementi figlio del nodo corrente.Asynchronously skips the children of the current node.

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

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Implementazioni dell'interfaccia esplicita

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

Per una descrizione di questo membro, vedere Dispose().For a description of this member, see Dispose().

Si applica a

Vedi anche