XmlReader XmlReader XmlReader XmlReader Class

Définition

Représente un lecteur fournissant un accès rapide, non mis en cache et en avant uniquement vers les données 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
Héritage
XmlReaderXmlReaderXmlReaderXmlReader
Dérivé
Implémente

Exemples

L’exemple de code suivant montre comment utiliser l’API asynchrone pour analyser du code 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

Remarques

XmlReaderfournit un accès avant uniquement en lecture seule aux données XML dans un document ou un flux.XmlReader provides forward-only, read-only access to XML data in a document or stream. Cette classe est conforme aux recommandations du W3C Extensible Markup Language (XML) 1,0 (quatrième édition) et des espaces de noms dans XML 1,0 (troisième édition) .This class conforms to the W3C Extensible Markup Language (XML) 1.0 (fourth edition) and the Namespaces in XML 1.0 (third edition) recommendations.

XmlReaderles méthodes vous permettent de parcourir les données XML et de lire le contenu d’un nœud.XmlReader methods let you move through XML data and read the contents of a node. Les propriétés de la classe reflètent la valeur du nœud actuel, où le lecteur est positionné. La ReadState valeur de la propriété indique l’état actuel du lecteur 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. Par exemple, la propriété a la valeur ReadState.Initial par la XmlReader.Read méthode et ReadState.Closed par la XmlReader.Close méthode.For example, the property is set to ReadState.Initial by the XmlReader.Read method and ReadState.Closed by the XmlReader.Close method. XmlReaderfournit également des vérifications de conformité des données et une validation par rapport à une DTD ou un schéma.XmlReader also provides data conformance checks and validation against a DTD or schema.

XmlReaderutilise un modèle d’extraction pour extraire des données.XmlReader uses a pull model to retrieve data. Ce modèle :This model:

  • Simplifie la gestion de l’état d’un raffinement des procédures naturel, descendant.Simplifies state management by a natural, top-down procedural refinement.

  • Prend en charge plusieurs flux d’entrée et la superposition.Supports multiple input streams and layering.

  • Permet au client de fournir à l’analyseur une mémoire tampon dans laquelle la chaîne est écrite directement, ce qui évite la nécessité d’une copie de chaînes supplémentaire.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.

  • Prend en charge le traitement sélectif.Supports selective processing. Le client peut ignorer des éléments et traiter ceux qui présentent un intérêt pour l’application.The client can skip items and process those that are of interest to the application. Vous pouvez également définir des propriétés à l’avance pour gérer le mode de traitement du flux XML (par exemple, la normalisation).You can also set properties in advance to manage how the XML stream is processed (for example, normalization).

Dans cette section :In this section:

Création d’un lecteur XML Creating an XML reader
Validation de données XML Validating XML data
Conformité aux données Data conformance
Navigation dans les nœuds Navigating through nodes
Lire des éléments XML Reading XML elements
Lecture des attributs XML Reading XML attributes
Lecture du contenu XML Reading XML content
Convertir en types CLR Converting to CLR types
Programmation asynchrone Asynchronous programming
Considérations relatives à la sécuritéSecurity considerations

Création d’un lecteur XMLCreating an XML reader

Utilisez la Create méthode pour créer une XmlReader instance.Use the Create method to create an XmlReader instance.

Bien que le .NET Framework fournisse des implémentations XmlReader concrètes de la classe XmlTextReader, XmlNodeReadertelles que, XmlValidatingReader , et les classes, nous vous recommandons d’utiliser les classes spécialisées uniquement dans les scénarios suivants :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:

  • Lorsque vous souhaitez lire une sous-arborescence DOM XML à partir XmlNode d’un objet, XmlNodeReader utilisez la classe.When you want to read an XML DOM subtree from an XmlNode object, use the XmlNodeReader class. (Toutefois, cette classe ne prend pas en charge la validation DTD ou de schéma.)(However, this class doesn't support DTD or schema validation.)

  • Si vous devez développer des entités à la demande, vous ne souhaitez pas que le contenu de votre texte soit normalisé, ou que vous ne XmlTextReader souhaitiez pas que les attributs par défaut soient retournés, utilisez la 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.

Pour spécifier l’ensemble de fonctionnalités que vous souhaitez activer sur le lecteur XML, transmettez System.Xml.XmlReaderSettings un objet à Create la méthode.To specify the set of features you want to enable on the XML reader, pass an System.Xml.XmlReaderSettings object to the Create method. Vous pouvez utiliser un seul System.Xml.XmlReaderSettings objet pour créer plusieurs lecteurs avec la même fonctionnalité, ou modifier l' System.Xml.XmlReaderSettings objet pour créer un nouveau lecteur avec un ensemble de fonctionnalités différent.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. Vous pouvez également ajouter facilement des fonctionnalités à un lecteur existant.You can also easily add features to an existing reader.

Si vous n’utilisez pas System.Xml.XmlReaderSettings un objet, les paramètres par défaut sont utilisés.If you don't use a System.Xml.XmlReaderSettings object, default settings are used. Pour plus Create d’informations, consultez la page de référence.See the Create reference page for details.

XmlReaderlève une XmlException exception sur les erreurs d’analyse XML.XmlReader throws an XmlException on XML parse errors. Une fois qu’une exception est levée, l’état du lecteur n’est pas prévisible.After an exception is thrown, the state of the reader is not predictable. Par exemple, le type de nœud signalé peut être différent du type de nœud réel du nœud actuel.For example, the reported node type may be different from the actual node type of the current node. Utilisez la ReadState propriété pour vérifier si le lecteur est dans un état d’erreur.Use the ReadState property to check whether the reader is in error state.

Validation de données XMLValidating XML data

Pour définir la structure d’un document XML et ses relations d’élément, types de données et contraintes de contenu, vous utilisez une définition de type de document (DTD) ou un schéma de langage XSD (XML Schema Definition).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 document XML est considéré comme correctement construit s’il répond à toutes les exigences syntaxiques définies par la recommandation du W3C sur XML 1,0.An XML document is considered to be well formed if it meets all the syntactical requirements defined by the W3C XML 1.0 Recommendation. Elle est considérée comme valide si elle est correctement formée et est conforme aux contraintes définies par sa DTD ou son schéma.It's considered valid if it's well formed and also conforms to the constraints defined by its DTD or schema. (Consultez le W3C XML Schema Part 1 : Structures et le W3C XML Schema Part 2 : Recommandations relatives aux types de données.) Par conséquent, même si tous les documents XML valides sont construits correctement, tous les documents XML construits correctement ne sont pas valides.(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.

Vous pouvez valider les données par rapport à une DTD, un schéma XSD en ligne ou un schéma XSD stocké XmlSchemaSet dans un objet (un cache). ces scénarios sont décrits Create dans la page de référence.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. XmlReaderne prend pas en charge la validation de schéma XDR (XML-Data Reduced).XmlReader doesn't support XML-Data Reduced (XDR) schema validation.

Vous utilisez les paramètres suivants sur la XmlReaderSettings classe pour spécifier le type de validation, le cas échéant, XmlReader que l’instance prend en charge.You use the following settings on the XmlReaderSettings class to specify what type of validation, if any, the XmlReader instance supports.

Utiliser ce XmlReaderSettings membreUse this XmlReaderSettings member Pour spécifierTo specify
PropriétéDtdProcessingDtdProcessing property Indique si le traitement DTD doit être autorisé.Whether to allow DTD processing. Par défaut, le traitement DTD n'est pas autorisé.The default is to disallow DTD processing.
PropriétéValidationTypeValidationType property Indique si le lecteur doit valider les données et le type de validation à effectuer (DTD ou schéma).Whether the reader should validate data, and what type of validation to perform (DTD or schema). Par défaut, les données ne sont pas validées.The default is no data validation.
ÉvénementValidationEventHandlerValidationEventHandler event Gestionnaire d’événements pour recevoir des informations sur les événements de validation.An event handler for receiving information about validation events. Si aucun gestionnaire d'événements n'est fourni, un objet XmlException est levé sur la première erreur de validation.If an event handler is not provided, an XmlException is thrown on the first validation error.
PropriétéValidationFlagsValidationFlags property Options de validation supplémentaires par XmlSchemaValidationFlags le biais des membres de l’énumération :Additional validation options through the XmlSchemaValidationFlags enumeration members:

- AllowXmlAttributes--Autorisez les attributsxml:*XML () dans les documents d’instance, même s’ils ne sont pas définis dans le schéma.- AllowXmlAttributes-- Allow XML attributes (xml:*) in instance documents even when they're not defined in the schema. Les attributs sont validés en fonction de leur type de données.The attributes are validated based on their data type. Consultez la XmlSchemaValidationFlags page de référence pour le paramètre à utiliser dans des scénarios spécifiques.See the XmlSchemaValidationFlags reference page for the setting to use in specific scenarios. (Désactivé par défaut.)(Disabled by default.)
- ProcessIdentityConstraints--Traiter les contraintes d'xs:IDidentité xs:IDREF( xs:key, xs:keyref, xs:unique,,) rencontrées pendant la validation.- ProcessIdentityConstraints --Process identity constraints (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) encountered during validation. (Activé par défaut.)(Enabled by default.)
- ProcessSchemaLocation--Traiter les schémas spécifiés par xsi:schemaLocation l' xsi:noNamespaceSchemaLocation attribut ou.- ProcessSchemaLocation --Process schemas specified by the xsi:schemaLocation or xsi:noNamespaceSchemaLocation attribute. (Activé par défaut.)(Enabled by default.)
- ProcessInlineSchema--Traitez les schémas XML inline lors de la validation.- ProcessInlineSchema-- Process inline XML Schemas during validation. (Désactivé par défaut.)(Disabled by default.)
- ReportValidationWarnings--Signaler les événements si un avertissement de validation se produit.- ReportValidationWarnings--Report events if a validation warning occurs. Un avertissement est généralement émis lorsqu'un attribut ou élément particulier ne peut être validé par rapport à aucun schéma XML ou aucune DTD.A warning is typically issued when there is no DTD or XML Schema to validate a particular element or attribute against. Le ValidationEventHandler est utilisé pour les notifications.The ValidationEventHandler is used for notification. (Désactivé par défaut.)(Disabled by default.)
Schemas XmlSchemaSet à utiliser pour la validation.The XmlSchemaSet to use for validation.
PropriétéXmlResolverXmlResolver property Pour XmlResolver la résolution et l’accès aux ressources externes.The XmlResolver for resolving and accessing external resources. Cela peut inclure des entités externes telles que des DTD et des schémas, xs:include ainsi xs:import que tout élément ou contenu dans le schéma XML.This can include external entities such as DTD and schemas, and any xs:include or xs:import elements contained in the XML Schema. Si vous ne spécifiez XmlResolverpas un XmlReader , le utilise XmlUrlResolver une valeur par défaut sans informations d’identification de l’utilisateur.If you don't specify an XmlResolver, the XmlReader uses a default XmlUrlResolver with no user credentials.

Conformité aux donnéesData conformance

Les lecteurs XML créés par la Create méthode remplissent les conditions de conformité suivantes par défaut :XML readers that are created by the Create method meet the following compliance requirements by default:

  • Les nouvelles lignes et la nouvelle valeur de l’attribut sont normalisées conformément à la recommandation du W3C sur XML 1,0.New lines and attribute value are normalized according to the W3C XML 1.0 Recommendation.

  • Toutes les entités sont développées automatiquement.All entities are automatically expanded.

  • Les attributs par défaut déclarés dans la définition de type de document sont toujours ajoutés même lorsque le lecteur n’est pas validé.Default attributes declared in the document type definition are always added even when the reader doesn't validate.

  • La déclaration du préfixe XML mappé à l’URI d’espace de noms XML correct est autorisée.Declaration of XML prefix mapped to the correct XML namespace URI is allowed.

  • Les noms de notations dans NotationType une déclaration d' NmTokens attribut unique et Enumeration dans une déclaration d’attribut unique sont distincts.The notation names in a single NotationType attribute declaration and NmTokens in a single Enumeration attribute declaration are distinct.

Utilisez ces XmlReaderSettings propriétés pour spécifier le type de vérifications de conformité que vous souhaitez activer :Use these XmlReaderSettings properties to specify the type of conformance checks you want to enable:

Utilisez cette XmlReaderSettings propriétéUse this XmlReaderSettings property ÀTo Par défautDefault
PropriétéCheckCharactersCheckCharacters property Activez ou désactivez les vérifications pour les éléments suivants :Enable or disable checks for the following:

-Les caractères se trouvent dans la plage de caractères XML légaux, tels que définis dans la section 2,2 caractères de la recommandation du W3C sur 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.
-Tous les noms XML sont valides, comme défini dans la section constructions syntaxiques communes 2,3 de la recommandation du W3C sur 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.

Quand cette propriété a la valeur true (valeur par défaut) XmlException , une exception est levée si le fichier XML contient des caractères non conformes ou des noms XML non valides (par exemple, un nom d’élément commence par un nombre).When this property is set to true (default), an XmlException exception is thrown if the XML file contains illegal characters or invalid XML names (for example, an element name starts with a number).
La vérification des caractères et des noms est activée.Character and name checking is enabled.

L'attribution à CheckCharacters de la valeur false désactive la vérification de caractères pour la recherche de références d'entité de caractère.Setting CheckCharacters to false turns off character checking for character entity references. Si le lecteur traite des données texte, il vérifie toujours que les noms XML sont valides, quel que soit ce paramètre.If the reader is processing text data, it always checks that XML names are valid, regardless of this setting. Remarque : La recommandation XML 1.0 nécessite une conformité au niveau du document lorsqu'une DTD est présente.Note: The XML 1.0 recommendation requires document-level conformance when a DTD is present. Par conséquent, si le lecteur est configuré pour ConformanceLevel.Fragmentprendre en charge, mais que les données XML contiennent une DTD (définition de XmlException type de document), une exception est levée.Therefore, if the reader is configured to support ConformanceLevel.Fragment, but the XML data contains a document type definition (DTD), an XmlException is thrown.
PropriétéConformanceLevelConformanceLevel property Choisissez le niveau de conformité à appliquer :Choose the level of conformance to enforce:

- Document.- Document. Conforme aux règles d’un document XML 1,0 correctement construit.Conforms to the rules for a well-formed XML 1.0 document.
- Fragment.- Fragment. Est conforme aux règles d’un fragment de document bien formé qui peut être consommé en tant qu' entité analysée externe.Conforms to the rules for a well-formed document fragment that can be consumed as an external parsed entity.
- Auto.- Auto. Conforme au niveau choisi par le lecteur.Conforms to the level decided by the reader.

Si les données ne sont pas conformes, une XmlException exception est levée.If the data isn't in conformance, an XmlException exception is thrown.
Document

Le nœud actuel est le nœud XML sur lequel le lecteur XML est actuellement positionné.The current node is the XML node on which the XML reader is currently positioned. Toutes XmlReader les méthodes effectuent des opérations par rapport à ce nœud XmlReader , et toutes les propriétés reflètent la valeur du nœud actuel.All XmlReader methods perform operations in relation to this node, and all XmlReader properties reflect the value of the current node.

Les méthodes suivantes facilitent la navigation dans les nœuds et l’analyse des données.The following methods make it easy to navigate through nodes and parse data.

Utilisez cette XmlReaderSettings méthodeUse this XmlReaderSettings method ÀTo
Read Lit le premier nœud et avance le flux d’un nœud à la fois.Read the first node, and advance through the stream one node at a time. De tels appels sont généralement effectués à while l’intérieur d’une boucle.Such calls are typically performed inside a while loop.

Utilisez la NodeType propriété pour obtenir le type (par exemple, attribut, commentaire, élément, etc.) du nœud actuel.Use the NodeType property to get the type (for example, attribute, comment, element, and so on) of the current node.
Skip Ignore les enfants du nœud actuel et passe au nœud suivant.Skip the children of the current node and move to the next node.
MoveToContent et MoveToContentAsyncMoveToContent and MoveToContentAsync Ignorer les nœuds de non-contenu et passer au nœud de contenu suivant ou à la fin du fichier.Skip non-content nodes and move to the next content node or to the end of the file.

Les nœuds autres que ProcessingInstructionles DocumentTypenœuds de contenu SignificantWhitespaceincluent,, Comment Whitespace, et.Non-content nodes include ProcessingInstruction, DocumentType, Comment, Whitespace, and SignificantWhitespace.

Les nœuds de contenu incluent du texte qui CDATAn' EntityReference est pas EndEntityun espace blanc,, et.Content nodes include non-white space text, CDATA, EntityReference , and EndEntity.
ReadSubtree Lit un élément et tous ses enfants et retourne une nouvelle XmlReader instance de ReadState.Initialla valeur.Read an element and all its children, and return a new XmlReader instance set to ReadState.Initial.

Cette méthode est utile pour créer des limites autour des éléments XML. par exemple, si vous souhaitez passer des données à un autre composant pour le traitement et que vous souhaitez limiter la quantité de données auxquelles le composant peut accéder.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.

Consultez la XmlReader.Read page de référence pour obtenir un exemple de navigation dans un flux de texte, un nœud à la fois et l’affichage du type de chaque nœud.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.

Les sections suivantes décrivent comment vous pouvez lire des types de données spécifiques, tels que des éléments, des attributs et des données typées.The following sections describe how you can read specific types of data, such as elements, attributes, and typed data.

Lire des éléments XMLReading XML elements

Le tableau suivant répertorie les méthodes et les propriétés XmlReader fournies par la classe pour le traitement des éléments.The following table lists the methods and properties that the XmlReader class provides for processing elements. Une fois l'objet XmlReader positionné sur un élément, les propriétés du nœud, telles que Name, reflètent les valeurs de l'élément.After the XmlReader is positioned on an element, the node properties, such as Name, reflect the element values. Outre les membres décrits ci-dessous, toutes les propriétés et méthodes générales de la classe XmlReader peuvent également être utilisées pour le traitement des éléments.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. Par exemple, vous pouvez utiliser la méthode ReadInnerXml pour lire le contenu d'un élément.For example, you can use the ReadInnerXml method to read the contents of an element.

Notes

Consultez la section 3,1 de la recommandation du W3C sur XML 1,0 pour connaître les définitions des balises de début, les balises de fin et les balises d’éléments vides.See section 3.1 of the W3C XML 1.0 Recommendation for definitions of start tags, end tags, and empty element tags.

Utiliser ce XmlReader membreUse this XmlReader member ÀTo
Méthode IsStartElementIsStartElement method Vérifiez si le nœud actuel est une balise de début ou une balise d’élément vide.Check if the current node is a start tag or an empty element tag.
Méthode ReadStartElementReadStartElement method Vérifiez que le nœud actuel est un élément et faites avancer le lecteur jusqu’au nœud suivant ( IsStartElement appels suivis par Read).Check that the current node is an element and advance the reader to the next node (calls IsStartElement followed by Read).
Méthode ReadEndElementReadEndElement method Vérifiez que le nœud actuel est une balise de fin et faites avancer le lecteur jusqu’au nœud suivant.Check that the current node is an end tag and advance the reader to the next node.
Méthode ReadElementStringReadElementString method Lire un élément de texte uniquement.Read a text-only element.
Méthode ReadToDescendantReadToDescendant method Avance le lecteur XML sur l’élément descendant (enfant) suivant portant le nom spécifié.Advance the XML reader to the next descendant (child) element that has the specified name.
Méthode ReadToNextSiblingReadToNextSibling method Avance le lecteur XML vers l’élément frère suivant portant le nom spécifié.Advance the XML reader to the next sibling element that has the specified name.
PropriétéIsEmptyElementIsEmptyElement property Vérifie si l’élément actuel a une balise d’élément de fin.Check if the current element has an end element tag. Par exemple :For example:

- <item num="123"/> (IsEmptyElement is true.)- <item num="123"/> (IsEmptyElement is true.)
- <item num="123"> </item>(IsEmptyElement estfalse, bien que le contenu de l’élément soit vide.)- <item num="123"> </item> (IsEmptyElement is false, although the element's content is empty.)

Pour obtenir un exemple de lecture du contenu de texte des éléments, ReadString consultez la méthode.For an example of reading the text content of elements, see the ReadString method. L’exemple suivant traite les éléments à l' while aide d’une boucle.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

Lecture des attributs XMLReading XML attributes

Les attributs XML se trouvent le plus souvent sur les éléments, mais ils sont également autorisés sur les nœuds de déclaration et de type de document XML.XML attributes are most commonly found on elements, but they're also allowed on XML declaration and document type nodes.

Lorsqu’elle est positionnée sur un nœud MoveToAttribute d’élément, la méthode vous permet de parcourir la liste des attributs de l’élément.When positioned on an element node, the MoveToAttribute method lets you go through the attribute list of the element. Notez qu’après MoveToAttribute l’appel de, les propriétés de nœud Nametelles NamespaceURIque, Prefix et reflètent les propriétés de cet attribut, et non les propriétés de l’élément auquel l’attribut appartient.Note that after MoveToAttribute has been called, node properties such as Name, NamespaceURI, and Prefix reflect the properties of that attribute, not the properties of the element the attribute belongs to.

La XmlReader classe fournit ces méthodes et propriétés pour lire et traiter des attributs sur des éléments.The XmlReader class provides these methods and properties to read and process attributes on elements.

Utiliser ce XmlReader membreUse this XmlReader member ÀTo
PropriétéHasAttributesHasAttributes property Vérifiez si le nœud actuel possède des attributs.Check whether the current node has any attributes.
PropriétéAttributeCountAttributeCount property Obtient le nombre d’attributs sur l’élément actuel.Get the number of attributes on the current element.
Méthode MoveToFirstAttributeMoveToFirstAttribute method Accède au premier attribut d’un élément.Move to the first attribute in an element.
Méthode MoveToNextAttributeMoveToNextAttribute method Passer à l’attribut suivant dans un élément.Move to the next attribute in an element.
Méthode MoveToAttributeMoveToAttribute method Déplacer vers un attribut spécifié.Move to a specified attribute.
GetAttributeméthode ou Item[String, String] propriétéGetAttribute method or Item[String, String] property Obtient la valeur d’un attribut spécifié.Get the value of a specified attribute.
PropriétéIsDefaultIsDefault property Vérifiez si le nœud actuel est un attribut qui a été généré à partir de la valeur par défaut définie dans le DTD ou le schéma.Check whether the current node is an attribute that was generated from the default value defined in the DTD or schema.
Méthode MoveToElementMoveToElement method Accédez à l’élément qui possède l’attribut actuel.Move to the element that owns the current attribute. Utilisez cette méthode pour revenir à un élément après avoir parcouru ses attributs.Use this method to return to an element after navigating through its attributes.
Méthode ReadAttributeValueReadAttributeValue method Analyse la valeur d’attribut dans un ou Textplusieurs EntityReferencenœuds EndEntity , ou.Parse the attribute value into one or more Text, EntityReference, or EndEntity nodes.

Toutes les méthodes et propriétés XmlReader générales peuvent aussi être utilisées pour traiter des attributs.Any of the general XmlReader methods and properties can also be used to process attributes. Par exemple, une fois que l'objet XmlReader a été positionné sur un attribut, les propriétés Name et Value reflètent les valeurs de cet attribut.For example, after the XmlReader is positioned on an attribute, the Name and Value properties reflect the values of the attribute. Vous pouvez aussi utiliser les méthodes Read de contenu pour obtenir la valeur de l'attribut.You can also use any of the content Read methods to get the value of the attribute.

Cet exemple utilise la AttributeCount propriété pour naviguer dans tous les attributs d’un élément.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

Cet exemple utilise la MoveToNextAttribute méthode dans une while boucle pour parcourir les attributs.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

Lecture d’attributs sur des nœuds de déclaration XMLReading attributes on XML declaration nodes

Lorsque le lecteur XML est positionné sur un nœud de déclaration XML, Value la propriété retourne les informations de version, autonome et d’encodage sous la forme d’une chaîne unique.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. XmlReaderles objets créés par Create la méthode, XmlTextReader la classe et la XmlValidatingReader classe exposent les éléments de version, autonome et d’encodage en tant qu’attributs.XmlReader objects created by the Create method, the XmlTextReader class, and the XmlValidatingReader class expose the version, standalone, and encoding items as attributes.

Lecture d’attributs sur des nœuds de type de documentReading attributes on document type nodes

Lorsque le lecteur XML est positionné sur un nœud de type de document GetAttribute , la Item[String, String] méthode et la propriété peuvent être utilisées pour retourner les valeurs des littéraux système et publics.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. Par exemple, un appel reader.GetAttribute("PUBLIC") retourne la valeur PUBLIC.For example, calling reader.GetAttribute("PUBLIC") returns the PUBLIC value.

Lecture des attributs sur les nœuds d’instruction de traitementReading attributes on processing instruction nodes

Lorsque l'objet XmlReader est positionné sur un n_œud d'instruction de traitement, la propriété Value retourne tout le contenu textuel.When the XmlReader is positioned on a processing instruction node, the Value property returns the entire text content. Les éléments du nœud d’instruction de traitement ne sont pas traités comme des attributs.Items in the processing instruction node aren't treated as attributes. Ils ne peuvent pas être lus GetAttribute à MoveToAttribute l’aide de la méthode ou.They can't be read with the GetAttribute or MoveToAttribute method.

Lecture du contenu XMLReading XML content

La classe XMLReader comprend les membres suivants qui lisent du contenu à partir d’un fichier XML et retournent le contenu sous forme de valeurs de chaîne.The XMLReader class includes the following members that read content from an XML file and return the content as string values. (Pour retourner des types CLR, consultez la section suivante.)(To return CLR types, see the next section.)

Utiliser ce XmlReader membreUse this XmlReader member ÀTo
PropriétéValueValue property Obtient le contenu de texte du nœud actuel.Get the text content of the current node. La valeur retournée dépend du type de nœud ; Pour plus Value d’informations, consultez la page de référence.The value returned depends on the node type; see the Value reference page for details.
Méthode ReadStringReadString method Obtient le contenu d’un nœud d’élément ou de texte sous la forme d’une chaîne.Get the content of an element or text node as a string. Cette méthode s’arrête sur les instructions de traitement et les commentaires.This method stops on processing instructions and comments.

Pour plus d’informations sur la façon dont cette méthode gère les types ReadString de nœuds spécifiques, consultez la page de référence.For details on how this method handles specific node types, see the ReadString reference page.
Méthodes ReadInnerXml et ReadInnerXmlAsyncReadInnerXml and ReadInnerXmlAsync methods Obtient tout le contenu du nœud actuel, y compris le balisage, mais à l’exclusion des balises de début et de fin.Get all the content of the current node, including the markup, but excluding start and end tags. Par exemple, pour :For example, for:

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

ReadInnerXmlCetteReadInnerXml returns:

this<child id="123"/>
Méthodes ReadOuterXml et ReadOuterXmlAsyncReadOuterXml and ReadOuterXmlAsync methods Obtenez tout le contenu du nœud actuel et de ses enfants, y compris le balisage et les balises de début et de fin.Get all the content of the current node and its children, including markup and start/end tags. Par exemple, pour :For example, for:

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

ReadOuterXmlCetteReadOuterXml returns:

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

Convertir en types CLRConverting to CLR types

Vous pouvez utiliser les membres de la XmlReader classe (énumérés dans le tableau suivant) pour lire les données XML et retourner des valeurs en tant que types Common Language Runtime (CLR) à la place de chaînes.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. Ces membres vous permettent d’obtenir des valeurs dans la représentation la plus appropriée pour votre tâche de codage sans avoir à analyser ou convertir manuellement les valeurs de chaîne.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.

  • Les méthodes ReadElementContentAs peuvent uniquement être appelées sur des types de nœuds d’élément.The ReadElementContentAs methods can only be called on element node types. Elles peuvent être utilisées pour des éléments qui comportent des éléments enfants ou du contenu mixte.These methods cannot be used on elements that contain child elements or mixed content. S'il est appelé, l'objet XmlReader lit la balise de début et le contenu de l'élément, puis avance jusqu'après la balise d'élément de fin.When called, the XmlReader object reads the start tag, reads the element content, and then moves past the end element tag. Les instructions de traitement et les commentaires sont ignorés et les entités sont développées.Processing instructions and comments are ignored and entities are expanded.

  • Les méthodes ReadContentAs lisent le contenu de texte à la position actuelle du lecteur et, si les données XML n’ont pas d’informations de schéma ou de type de données qui lui sont associées, convertissent le contenu de texte dans le type de retour demandé.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. Le texte, les espaces blancs, les espaces blancs significatifs et les sections CDATA sont concaténés.Text, white space, significant white space and CDATA sections are concatenated. Les commentaires et les instructions de traitement sont ignorés, et les références d’entité sont résolues automatiquement.Comments and processing instructions are skipped, and entity references are automatically resolved.

La XmlReader classe utilise les règles définies par le W3C XML Schema Part 2 : Recommandation de type de données.The XmlReader class uses the rules defined by the W3C XML Schema Part 2: Datatypes recommendation.

Utilisez cette XmlReader méthodeUse this XmlReader method Pour retourner ce type CLRTo return this CLR type
ReadContentAsBoolean et ReadElementContentAsBooleanReadContentAsBoolean and ReadElementContentAsBoolean Boolean
ReadContentAsDateTime et ReadElementContentAsDateTimeReadContentAsDateTime and ReadElementContentAsDateTime DateTime
ReadContentAsDouble et ReadElementContentAsDoubleReadContentAsDouble and ReadElementContentAsDouble Double
ReadContentAsLong et ReadElementContentAsLongReadContentAsLong and ReadElementContentAsLong Int64
ReadContentAsInt et ReadElementContentAsIntReadContentAsInt and ReadElementContentAsInt Int32
ReadContentAsString et ReadElementContentAsStringReadContentAsString and ReadElementContentAsString String
ReadContentAs et ReadElementContentAsReadContentAs and ReadElementContentAs Le type que vous spécifiez returnType avec le paramètreThe type you specify with the returnType parameter
ReadContentAsObject et ReadElementContentAsObjectReadContentAsObject and ReadElementContentAsObject Type le plus approprié, tel que spécifié par XmlReader.ValueType la propriété.The most appropriate type, as specified by the XmlReader.ValueType property. Pour plus d’informations sur le mappage, consultez prise en charge des types dans les classes System. xml .See Type Support in the System.Xml Classes for mapping information.

Si un élément ne peut pas être facilement converti en type CLR en raison de son format, vous pouvez utiliser un mappage de schéma pour garantir la réussite de la conversion.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’exemple suivant utilise un fichier. xsd pour convertir l' hire-date élément xs:date en type, puis utilise la ReadElementContentAsDateTime méthode pour retourner l’élément sous la forme d' DateTime un objet.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.

Entrée (HireDate. Xml) :Input (hireDate.xml):

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

Schéma (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>

CodeCode:

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

Sortie :Output:

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

Programmation asynchroneAsynchronous programming

La plupart des XmlReader méthodes ont des équivalents asynchrones qui ont « Async » à la fin de leurs noms de méthode.Most of the XmlReader methods have asynchronous counterparts that have "Async" at the end of their method names. Par exemple, l’équivalent asynchrone de ReadContentAsObject est ReadContentAsObjectAsync.For example, the asynchronous equivalent of ReadContentAsObject is ReadContentAsObjectAsync.

Les méthodes suivantes peuvent être utilisées avec des appels de méthode asynchrones :The following methods can be used with asynchronous method calls:

Les sections suivantes décrivent l’utilisation asynchrone des méthodes qui n’ont pas d’équivalents asynchrones.The following sections describe asynchronous usage for methods that don't have asynchronous counterparts.

Méthode ReadStartElementReadStartElement method

public static async Task ReadStartElementAsync(this XmlReader reader, string localname, string ns)
{
    if (await reader.MoveToContentAsync() != XmlNodeType.Element)
    {
        throw new InvalidOperationException(reader.NodeType.ToString() + " is an invalid XmlNodeType");
    }
    if ((reader.LocalName == localname) && (reader.NamespaceURI == ns))
    {
        await reader.ReadAsync();
    }
    else
    {
        throw new InvalidOperationException("localName or namespace doesn’t match");
    }
}
<Extension()>
Public Async Function ReadStartElementAsync(reader As XmlReader, localname As String, ns As String) As Task
    If (Await reader.MoveToContentAsync() <> XmlNodeType.Element) Then
        Throw New InvalidOperationException(reader.NodeType.ToString() + " is an invalid XmlNodeType")
    End If

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

Méthode ReadEndElementReadEndElement method

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

Méthode ReadToNextSiblingReadToNextSibling method

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

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

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

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

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

    ' find the next sibling
    Dim nt As XmlNodeType
    Do

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

    Return False

End Function

Méthode ReadToFollowingReadToFollowing method

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

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

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

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

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

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

    Return False
End Function

Méthode 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

Considérations relatives à la sécuritéSecurity considerations

Tenez compte des éléments suivants lorsque vous XmlReader utilisez la classe :Consider the following when working with the XmlReader class:

  • Les XmlReader exceptions levées à partir de peuvent divulguer des informations de chemin d’accès que vous ne voulez peut-être pas être propagées à votre application.Exceptions thrown from the XmlReader can disclose path information that you might not want bubbled up to your app. Votre application doit intercepter les exceptions et les traiter de manière appropriée.Your app must catch exceptions and process them appropriately.

  • N’activez pas le traitement DTD si vous vous inquiétez des problèmes de déni de service ou si vous êtes confronté à des sources non approuvées.Do not enable DTD processing if you're concerned about denial of service issues or if you're dealing with untrusted sources. Le traitement DTD est désactivé par défaut XmlReader pour les objets créés Create par la méthode.DTD processing is disabled by default for XmlReader objects created by the Create method.

    Si le traitement DTD est activé, vous pouvez utiliser l'objet XmlSecureResolver pour limiter les ressources auxquelles l'objet XmlReader peut avoir accès.If you have DTD processing enabled, you can use the XmlSecureResolver to restrict the resources that the XmlReader can access. Vous pouvez également concevoir votre application de manière à ce que le traitement XML soit soumis à une limitation de la mémoire et du temps.You can also design your app so that the XML processing is memory and time constrained. Par exemple, vous pouvez configurer des limites de délai d’attente dans votre application ASP.NET.For example, you can configure time-out limits in your ASP.NET app.

  • Les données XML peuvent inclure des références à des ressources externes telles qu'un fichier de schéma.XML data can include references to external resources such as a schema file. Par défaut, les ressources externes sont résolues à XmlUrlResolver l’aide d’un objet sans informations d’identification de l’utilisateur.By default, external resources are resolved by using an XmlUrlResolver object with no user credentials. Vous pouvez renforcer la sécurité en procédant comme suit :You can secure this further by doing one of the following:

  • Les ProcessInlineSchema indicateurs ProcessSchemaLocation de validation et d' XmlReaderSettings un objet ne sont pas définis par défaut.The ProcessInlineSchema and ProcessSchemaLocation validation flags of an XmlReaderSettings object aren't set by default. Cela contribue à protéger l'objet XmlReader contre les attaques basées sur des schémas lorsqu'il traite des données XML provenant d'une source non fiable.This helps to protect the XmlReader against schema-based attacks when it is processing XML data from an untrusted source. Lorsque ces indicateurs sont activés, la propriété XmlResolver de l'objet XmlReaderSettings est utilisée pour résoudre les emplacements de schéma rencontrés dans le document d'instance dans l'objet XmlReader.When these flags are set, the XmlResolver of the XmlReaderSettings object is used to resolve schema locations encountered in the instance document in the XmlReader. Si la XmlResolver propriété a la nullvaleur, les emplacements de schéma ne sont pas ProcessInlineSchema résolus même si les indicateurs de validation et ProcessSchemaLocation sont définis.If the XmlResolver property is set to null, schema locations aren't resolved even if the ProcessInlineSchema and ProcessSchemaLocation validation flags are set.

    Les schémas ajoutés lors de la validation ajoutent de nouveaux types et peuvent changer le résultat de la validation du document en cours de validation.Schemas added during validation add new types and can change the validation outcome of the document being validated. Par conséquent, les schémas externes ne devraient être résolus que s'ils proviennent de sources fiables.As a result, external schemas should only be resolved from trusted sources.

    Nous vous recommandons de désactiver ProcessIdentityConstraints l’indicateur lors de la validation de documents XML volumineux non fiables dans des scénarios de haute disponibilité par rapport à un schéma qui a des contraintes d’identité sur une grande partie du document.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. Cet indicateur est activé par défaut.This flag is enabled by default.

  • Les données XML peuvent contenir un grand nombre d'attributs, de déclarations d'espaces de noms, d'éléments imbriqués, etc. exigeant un temps de traitement long.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. Pour limiter la taille de l’entrée envoyée au XmlReader, vous pouvez :To limit the size of the input that is sent to the XmlReader, you can:

  • La ReadValueChunk méthode peut être utilisée pour gérer de grands flux de données.The ReadValueChunk method can be used to handle large streams of data. Cette méthode lit un petit nombre de caractères à la fois au lieu d'allouer une seule chaîne à toute la valeur.This method reads a small number of characters at a time instead of allocating a single string for the whole value.

  • Un problème peut se produire lors de la lecture d’un document XML avec un grand nombre de noms locaux, d’espaces de noms ou de préfixes uniques.When reading an XML document with a large number of unique local names, namespaces, or prefixes, a problem can occur. Si vous utilisez une classe XmlReaderqui dérive de et que vous appelez la LocalNamepropriété, Prefixou NamespaceURI pour chaque élément, la chaîne retournée est ajoutée à 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 collection détenue par NameTable la taille ne diminue jamais, créant une fuite de mémoire virtuelle des handles de chaîne.The collection held by the NameTable never decreases in size, creating a virtual memory leak of the string handles. L’une des solutions de contournement consiste à dériver NameTable de la classe et à appliquer un quota de taille maximale.One mitigation for this is to derive from the NameTable class and enforce a maximum size quota. (Il n’existe aucun moyen d’empêcher l’utilisation d' NameTableun ou de NameTable basculer lorsqu’il est plein).(There is no way to prevent the use of a NameTable, or to switch the NameTable when it is full). Une autre solution d’atténuation consiste à éviter d’utiliser les propriétés mentionnées et MoveToAttribute à utiliser la IsStartElement méthode avec la méthode dans la mesure du possible ; ces méthodes ne retournent pas de chaînes NameTable et, par conséquent, évitent le problème de surremplissage de la collection.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.

  • Les objets XmlReaderSettings peuvent contenir des informations confidentielles telles que des informations d'identification de l'utilisateur.XmlReaderSettings objects can contain sensitive information such as user credentials. Un composant non fiable pourrait utiliser l'objet XmlReaderSettings et ses informations d'identification pour créer des objets XmlReader afin de lire des données.An untrusted component could use the XmlReaderSettings object and its user credentials to create XmlReader objects to read data. Soyez prudent lors de XmlReaderSettings la mise en cache des objets XmlReaderSettings ou lors du passage de l’objet d’un composant à un autre.Be careful when caching XmlReaderSettings objects, or when passing the XmlReaderSettings object from one component to another.

  • N'acceptez pas les composants de prise en charge, tels que les objets NameTable, XmlNamespaceManager et XmlResolver provenant d'une source non fiable.Do not accept supporting components, such as NameTable, XmlNamespaceManager, and XmlResolver objects, from an untrusted source.

Constructeurs

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

Initialise une nouvelle instance de la classe XmlReader.Initializes a new instance of the XmlReader class.

Propriétés

AttributeCount AttributeCount AttributeCount AttributeCount

En cas de substitution dans une classe dérivée, obtient le nombre d'attributs du nœud actuel.When overridden in a derived class, gets the number of attributes on the current node.

BaseURI BaseURI BaseURI BaseURI

En cas de substitution dans une classe dérivée, obtient l'URI de base du nœud actuel.When overridden in a derived class, gets the base URI of the current node.

CanReadBinaryContent CanReadBinaryContent CanReadBinaryContent CanReadBinaryContent

Obtient une valeur indiquant si XmlReader implémente les méthodes de lecture de contenu binaire.Gets a value indicating whether the XmlReader implements the binary content read methods.

CanReadValueChunk CanReadValueChunk CanReadValueChunk CanReadValueChunk

Obtient une valeur indiquant si XmlReader implémente la méthode ReadValueChunk(Char[], Int32, Int32).Gets a value indicating whether the XmlReader implements the ReadValueChunk(Char[], Int32, Int32) method.

CanResolveEntity CanResolveEntity CanResolveEntity CanResolveEntity

Obtient une valeur indiquant si ce lecteur peut analyser et résoudre les entités.Gets a value indicating whether this reader can parse and resolve entities.

Depth Depth Depth Depth

En cas de substitution dans une classe dérivée, obtient la profondeur du nœud actuel dans le document XML.When overridden in a derived class, gets the depth of the current node in the XML document.

EOF EOF EOF EOF

En cas de substitution dans une classe dérivée, obtient une valeur indiquant si le lecteur est placé à la fin du flux.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

Obtient une valeur indiquant si le nœud actuel a des attributs.Gets a value indicating whether the current node has any attributes.

HasValue HasValue HasValue HasValue

En cas de substitution dans une classe dérivée, obtient une valeur indiquant si le nœud actuel peut posséder Value.When overridden in a derived class, gets a value indicating whether the current node can have a Value.

IsDefault IsDefault IsDefault IsDefault

En cas de substitution dans une classe dérivée, obtient une valeur indiquant si le nœud actuel est un attribut généré à partir de la valeur par défaut définie dans le DTD ou le schéma.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

En cas de substitution dans une classe dérivée, obtient une valeur indiquant si le nœud actuel est un élément vide (par exemple, <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]

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec l'index spécifié.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]

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec le LocalName et le NamespaceURI spécifiés.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]

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec le Name spécifié.When overridden in a derived class, gets the value of the attribute with the specified Name.

LocalName LocalName LocalName LocalName

En cas de substitution dans une classe dérivée, obtient le nom local du nœud actuel.When overridden in a derived class, gets the local name of the current node.

Name Name Name Name

En cas de substitution dans une classe dérivée, obtient le nom qualifié du nœud actuel.When overridden in a derived class, gets the qualified name of the current node.

NamespaceURI NamespaceURI NamespaceURI NamespaceURI

En cas de substitution dans une classe dérivée, obtient l'URI de l'espace de noms (tel qu'il est défini dans la spécification relative aux espaces de noms du W3C) du nœud sur lequel le lecteur est placé.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

En cas de substitution dans une classe dérivée, obtient le XmlNameTable associé à cette implémentation.When overridden in a derived class, gets the XmlNameTable associated with this implementation.

NodeType NodeType NodeType NodeType

En cas de substitution dans une classe dérivée, obtient le type du nœud actuel.When overridden in a derived class, gets the type of the current node.

Prefix Prefix Prefix Prefix

En cas de substitution dans une classe dérivée, obtient le préfixe de l'espace de noms associé au nœud actuel.When overridden in a derived class, gets the namespace prefix associated with the current node.

QuoteChar QuoteChar QuoteChar QuoteChar

En cas de substitution dans une classe dérivée, obtient le caractère guillemet permettant de délimiter la valeur d'un nœud d'attribut.When overridden in a derived class, gets the quotation mark character used to enclose the value of an attribute node.

ReadState ReadState ReadState ReadState

En cas de substitution dans une classe dérivée, obtient l'état du lecteur.When overridden in a derived class, gets the state of the reader.

SchemaInfo SchemaInfo SchemaInfo SchemaInfo

Obtient les informations de schéma qui ont été assignées au nœud actuel à la suite de la validation du schéma.Gets the schema information that has been assigned to the current node as a result of schema validation.

Settings Settings Settings Settings

Obtient l'objet XmlReaderSettings permettant de créer cette instance de XmlReader.Gets the XmlReaderSettings object used to create this XmlReader instance.

Value Value Value Value

En cas de substitution dans une classe dérivée, obtient la valeur texte du nœud actuel.When overridden in a derived class, gets the text value of the current node.

ValueType ValueType ValueType ValueType

Obtient le type de CLR du nœud actuel.Gets The Common Language Runtime (CLR) type for the current node.

XmlLang XmlLang XmlLang XmlLang

En cas de substitution dans une classe dérivée, obtient la portée xml:lang en cours.When overridden in a derived class, gets the current xml:lang scope.

XmlSpace XmlSpace XmlSpace XmlSpace

En cas de substitution dans une classe dérivée, obtient la portée xml:space en cours.When overridden in a derived class, gets the current xml:space scope.

Méthodes

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

En cas de substitution dans une classe dérivée, modifie ReadState en Closed.When overridden in a derived class, changes the ReadState to Closed.

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

Crée une instance de XmlReader à l’aide du flux spécifié avec les paramètres par défaut.Creates a new XmlReader instance using the specified stream with default settings.

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

Crée une instance de XmlReader avec le flux et les paramètres spécifiés.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)

Crée une instance de XmlReader en utilisant le flux, l’URI de base et les paramètres spécifiés.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)

Crée une instance de XmlReader à l’aide du flux, des paramètres et des informations de contexte d’analyse spécifiés.Creates a new XmlReader instance using the specified stream, settings, and context information for parsing.

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

Crée une instance de XmlReader avec l’URI spécifié.Creates a new XmlReader instance with specified URI.

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

Crée une instance de XmlReader en utilisant l’URI et les paramètres spécifiés.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)

Crée une instance de XmlReader en utilisant l’URI, les paramètres et les informations de contexte spécifiés pour l’analyse.Creates a new XmlReader instance by using the specified URI, settings, and context information for parsing.

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

Crée une instance de XmlReader à l’aide du lecteur de texte spécifié.Creates a new XmlReader instance by using the specified text reader.

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

Crée une instance de XmlReader à l’aide du lecteur de texte et des paramètres spécifiés.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)

Crée une instance de XmlReader à l’aide du lecteur de texte, des paramètres et de l’URI de base spécifiés.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)

Crée une instance de XmlReader à l’aide du lecteur de texte, des paramètres et des informations de contexte d’analyse spécifiés.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)

Crée une instance de XmlReader à l’aide des paramètres et du lecteur XML spécifiés.Creates a new XmlReader instance by using the specified XML reader and settings.

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

Libère toutes les ressources utilisées par l'instance actuelle de la classe XmlReader.Releases all resources used by the current instance of the XmlReader class.

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

Libère les ressources non managées utilisées par XmlReader et libère éventuellement les ressources managées.Releases the unmanaged resources used by the XmlReader and optionally releases the managed resources.

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

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

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

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec l'index spécifié.When overridden in a derived class, gets the value of the attribute with the specified index.

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

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec le Name spécifié.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)

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec le LocalName et le NamespaceURI spécifiés.When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

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

Fait office de fonction de hachage par défaut.Serves as the default hash function.

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

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

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

Obtient de façon asynchrone la valeur du nœud actuel.Asynchronously gets the value of the current node.

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

Retourne une valeur indiquant si l'argument de chaîne est un nom XML valide.Returns a value indicating whether the string argument is a valid XML name.

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

Retourne une valeur indiquant si l'argument de chaîne est un jeton de nom XML valide.Returns a value indicating whether or not the string argument is a valid XML name token.

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

Appelle MoveToContent() et vérifie si le nœud de contenu actuel est une balise de début ou une balise d'élément vide.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)

Appelle MoveToContent(), vérifie si le nœud de contenu actuel est une balise de début ou une balise d'élément vide, puis vérifie également si la propriété Name de l'élément trouvé correspond à l'argument spécifié.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)

Appelle MoveToContent(), vérifie si le nœud de contenu actuel est une balise de début ou une balise d'élément vide, puis vérifie également si les propriétés LocalName et NamespaceURI de l'élément trouvé correspondent aux chaînes spécifiées.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)

En cas de substitution dans une classe dérivée, résout un préfixe de l'espace de noms dans la portée de l'élément en cours.When overridden in a derived class, resolves a namespace prefix in the current element's scope.

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

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

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

En cas de substitution dans une classe dérivée, se déplace vers l'attribut avec l'index spécifié.When overridden in a derived class, moves to the attribute with the specified index.

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

En cas de substitution dans une classe dérivée, se déplace vers l'attribut avec le Name spécifié.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)

En cas de substitution dans une classe dérivée, se déplace vers l'attribut avec le LocalName et le NamespaceURI spécifiés.When overridden in a derived class, moves to the attribute with the specified LocalName and NamespaceURI.

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

Vérifie si le nœud actuel est un nœud de contenu (texte non constitué d'espaces blancs, CDATA, Element, EndElement, EntityReference ou EndEntity).Checks whether the current node is a content (non-white space text, CDATA, Element, EndElement, EntityReference, or EndEntity) node. Si le nœud n'est pas un nœud de contenu, le lecteur avance jusqu'au nœud de contenu suivant ou jusqu'à la fin du fichier.If the node is not a content node, the reader skips ahead to the next content node or end of file. Il ignore les nœuds possédant les types suivants : ProcessingInstruction, DocumentType, Comment, Whitespace ou SignificantWhitespace.It skips over nodes of the following type: ProcessingInstruction, DocumentType, Comment, Whitespace, or SignificantWhitespace.

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

Vérifie de façon asynchrone si le nœud actuel est un nœud de contenu.Asynchronously checks whether the current node is a content node. Si le nœud n'est pas un nœud de contenu, le lecteur avance jusqu'au nœud de contenu suivant ou jusqu'à la fin du fichier.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()

En cas de substitution dans une classe dérivée, se déplace vers l'élément contenant le nœud d'attribut actuel.When overridden in a derived class, moves to the element that contains the current attribute node.

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

En cas de substitution dans une classe dérivée, se déplace vers le premier attribut.When overridden in a derived class, moves to the first attribute.

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

En cas de substitution dans une classe dérivée, se déplace vers l'attribut suivant.When overridden in a derived class, moves to the next attribute.

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

En cas de substitution dans une classe dérivée, lit le nœud suivant à partir du flux.When overridden in a derived class, reads the next node from the stream.

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

Lit de façon asynchrone le nœud suivant à partir du flux de données.Asynchronously reads the next node from the stream.

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

En cas de substitution dans une classe dérivée, analyse la valeur d'attribut dans un ou plusieurs nœuds Text, EntityReference ou EndEntity.When overridden in a derived class, parses the attribute value into one or more Text, EntityReference, or EndEntity nodes.

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

Lit le contenu en tant qu'objet du type spécifié.Reads the content as an object of the type specified.

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

Lit de façon asynchrone le contenu en tant qu'objet du type spécifié.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)

Lit le contenu et retourne les octets binaires décodés au format 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)

Lit de façon asynchrone le contenu et retourne les octets binaires décodés au format 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)

Lit le contenu et retourne les octets binaires décodés au format 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)

Lit de façon asynchrone le contenu et retourne les octets binaires décodés au format BinHex.Asynchronously reads the content and returns the BinHex decoded binary bytes.

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

Lit le contenu de texte à la position actuelle comme un Boolean.Reads the text content at the current position as a Boolean.

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

Lit le contenu de texte à la position actuelle comme un objet DateTime.Reads the text content at the current position as a DateTime object.

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

Lit le contenu de texte à la position actuelle comme un objet DateTimeOffset.Reads the text content at the current position as a DateTimeOffset object.

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

Lit le contenu de texte à la position actuelle comme un objet Decimal.Reads the text content at the current position as a Decimal object.

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

Lit le contenu de texte à la position actuelle en tant que nombre à virgule flottante double précision.Reads the text content at the current position as a double-precision floating-point number.

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

Lit le contenu de texte à la position actuelle en tant que nombre à virgule flottante simple précision.Reads the text content at the current position as a single-precision floating point number.

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

Lit le contenu de texte à la position actuelle comme un entier signé de 32 bits.Reads the text content at the current position as a 32-bit signed integer.

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

Lit le contenu de texte à la position actuelle comme un entier signé de 64 bits.Reads the text content at the current position as a 64-bit signed integer.

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

Lit le contenu de texte à la position actuelle comme un Object.Reads the text content at the current position as an Object.

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

Lit de façon asynchrone le contenu de texte à la position actuelle comme un objet Object.Asynchronously reads the text content at the current position as an Object.

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

Lit le contenu de texte à la position actuelle comme un objet String.Reads the text content at the current position as a String object.

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

Lit de façon asynchrone le contenu de texte à la position actuelle comme un objet 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)

Lit le contenu de l'élément en tant que type demandé.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)

Vérifie que le nom local spécifié et l'URI de l'espace de noms correspondent à ceux de l'élément actuel, puis lit le contenu d'élément en tant que type demandé.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)

Lit de façon asynchrone le contenu de l'élément en tant que type demandé.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)

Lit l'élément et décode le contenu au format 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)

Lit de façon asynchrone l'élément et décode le contenu au format 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)

Lit l'élément et décode le contenu au format 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)

Lit de façon asynchrone l'élément et décode le contenu au format BinHex.Asynchronously reads the element and decodes the BinHex content.

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

Lit l'élément actuel et retourne le contenu en tant qu'objet 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)

Vérifie que le nom local spécifié et l'URI de l'espace de noms correspondent à ceux de l'élément actuel, puis lit l'élément actuel et retourne le contenu en tant qu'objet 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()

Lit l'élément actuel et retourne le contenu en tant qu'objet 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)

Vérifie que le nom local spécifié et l'URI de l'espace de noms correspondent à ceux de l'élément actuel, puis lit l'élément actuel et retourne le contenu en tant qu'objet 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()

Lit l'élément actuel et retourne le contenu en tant qu'objet 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)

Vérifie que le nom local spécifié et l'URI de l'espace de noms correspondent à ceux de l'élément actuel, puis lit l'élément actuel et retourne le contenu en tant qu'objet 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()

Lit l'élément actuel et retourne le contenu en tant que nombre à virgule flottante double précision.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)

Vérifie que le nom local et l'URI de l'espace de noms spécifiés correspondent à ceux de l'élément actuel, puis lit l'élément actuel et retourne le contenu sous la forme d'un nombre à virgule flottante double précision.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()

Lit l'élément actuel et retourne le contenu en tant que nombre à virgule flottante simple précision.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)

Vérifie que le nom local et l'URI de l'espace de noms spécifiés correspondent à ceux de l'élément actuel, puis lit l'élément actuel et retourne le contenu sous la forme d'un nombre à virgule flottante simple précision.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()

Lit l'élément actuel et retourne le contenu comme un entier signé de 32 bits.Reads the current element and returns the contents as a 32-bit signed integer.

ReadElementContentAsInt(String, String) ReadElementContentAsInt(String, String) ReadElementContentAsInt(String, String) ReadElementContentAsInt(String, String)

Vérifie que le nom local spécifié et l'URI de l'espace de noms correspondent à ceux de l'élément actuel, puis lit l'élément actuel et retourne le contenu en tant qu'entier signé de 32 bits.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a 32-bit signed integer.

ReadElementContentAsLong() ReadElementContentAsLong() ReadElementContentAsLong() ReadElementContentAsLong()

Lit l’élément actuel et retourne le contenu comme un entier signé de 64 bits.Reads the current element and returns the contents as a 64-bit signed integer.

ReadElementContentAsLong(String, String) ReadElementContentAsLong(String, String) ReadElementContentAsLong(String, String) ReadElementContentAsLong(String, String)

Vérifie que le nom local spécifié et l’URI de l’espace de noms correspondent à ceux de l’élément actuel, puis lit l’élément actuel et retourne le contenu en tant qu’entier signé de 64 bits.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a 64-bit signed integer.

ReadElementContentAsObject() ReadElementContentAsObject() ReadElementContentAsObject() ReadElementContentAsObject()

Lit l'élément actuel et retourne le contenu en tant que Object.Reads the current element and returns the contents as an Object.

ReadElementContentAsObject(String, String) ReadElementContentAsObject(String, String) ReadElementContentAsObject(String, String) ReadElementContentAsObject(String, String)

Vérifie que le nom local et l'URI de l'espace de noms spécifiés correspondent à ceux de l'élément actuel, puis lit l'élément actuel et retourne le contenu en tant qu'objet 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()

Lit de façon asynchrone l'élément actuel et retourne le contenu en tant que Object.Asynchronously reads the current element and returns the contents as an Object.

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

Lit l'élément actuel et retourne le contenu en tant qu'objet 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)

Vérifie que le nom local spécifié et l'URI de l'espace de noms correspondent à ceux de l'élément actuel, puis lit l'élément actuel et retourne le contenu en tant qu'objet 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()

Lit de façon asynchrone l'élément actuel et retourne le contenu en tant qu'objet String.Asynchronously reads the current element and returns the contents as a String object.

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

Lit un élément de texte brut.Reads a text-only element. Toutefois, nous vous recommandons d’utiliser plutôt la méthode ReadElementContentAsString(), car elle permet de gérer cette opération de façon plus directe.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)

Vérifie que la propriété Name de l'élément trouvé correspond à la chaîne spécifiée avant de lire un élément de texte brut.Checks that the Name property of the element found matches the given string before reading a text-only element. Toutefois, nous vous recommandons d’utiliser plutôt la méthode ReadElementContentAsString(), car elle permet de gérer cette opération de façon plus directe.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)

Vérifie que les propriétés LocalName et NamespaceURI de l'élément trouvé correspondent aux chaînes spécifiées avant de lire un élément de texte brut.Checks that the LocalName and NamespaceURI properties of the element found matches the given strings before reading a text-only element. Toutefois, nous vous recommandons d’utiliser plutôt la méthode ReadElementContentAsString(String, String), car elle permet de gérer cette opération de façon plus directe.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()

Vérifie que le nœud de contenu actuel est une balise de fin et avance le lecteur jusqu'au nœud suivant.Checks that the current content node is an end tag and advances the reader to the next node.

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

En cas de substitution dans une classe dérivée, lit tout le contenu, y compris le balisage, sous forme de chaîne.When overridden in a derived class, reads all the content, including markup, as a string.

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

Lit de façon asynchrone tout le contenu, notamment le balisage, en tant que chaîne.Asynchronously reads all the content, including markup, as a string.

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

En cas de substitution dans une classe dérivée, lit le contenu, y compris le balisage, représentant ce nœud et tous ses enfants.When overridden in a derived class, reads the content, including markup, representing this node and all its children.

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

Lit de façon asynchrone le contenu, notamment le balisage, qui représente ce nœud et tous ses enfants.Asynchronously reads the content, including markup, representing this node and all its children.

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

Vérifie que le nœud actuel est un élément et avance le lecteur jusqu'au nœud suivant.Checks that the current node is an element and advances the reader to the next node.

ReadStartElement(String) ReadStartElement(String) ReadStartElement(String) ReadStartElement(String)

Vérifie que le nœud de contenu actuel est un élément avec le Name spécifié, puis avance le lecteur jusqu'au nœud suivant.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)

Vérifie que le nœud de contenu actuel est un élément avec le LocalName et le NamespaceURI spécifiés, puis avance le lecteur jusqu'au nœud suivant.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()

En cas de substitution dans une classe dérivée, lit le contenu d'un nœud d'élément ou de texte sous forme de chaîne.When overridden in a derived class, reads the contents of an element or text node as a string. Toutefois, nous vous recommandons d’utiliser plutôt la méthode ReadElementContentAsString, car elle permet de gérer cette opération de façon plus directe.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()

Retourne une nouvelle instance de XmlReader qui permet de lire le nœud actuel, ainsi que tous ses descendants.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)

Avance le XmlReader vers l'élément descendant suivant portant le nom qualifié spécifié.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)

Avance XmlReader vers le nœud descendant suivant doté du nom local et de l'URI de l'espace de noms spécifiés.Advances the XmlReader to the next descendant element with the specified local name and namespace URI.

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

Lit jusqu'à trouver un élément avec le nom qualifié spécifié.Reads until an element with the specified qualified name is found.

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

Lit jusqu'à trouver un élément avec le nom local et l'URI de l'espace de noms spécifiés.Reads until an element with the specified local name and namespace URI is found.

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

Avance le XmlReader vers l'élément frère suivant portant le nom qualifié spécifié.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)

Avance XmlReader vers l’élément frère suivant doté du nom local et de l’URI de l’espace de noms spécifiés.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)

Lit des flux de texte volumineux incorporés dans un document 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)

Lit de façon asynchrone des flux de texte volumineux incorporés dans un document XML.Asynchronously reads large streams of text embedded in an XML document.

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

En cas de substitution dans une classe dérivée, résout la référence d'entité des nœuds EntityReference.When overridden in a derived class, resolves the entity reference for EntityReference nodes.

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

Ignore les enfants du nœud actuel.Skips the children of the current node.

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

Ignore de façon asynchrone les enfants du nœud actuel.Asynchronously skips the children of the current node.

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

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

Implémentations d’interfaces explicites

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

Pour obtenir une description de ce membre, consultez Dispose().For a description of this member, see Dispose().

S’applique à

Voir aussi