XmlReader Classe

Définition

Représente un lecteur fournissant un accès rapide, non mis en cache et en avant uniquement vers les données XML.

public ref class XmlReader abstract : IDisposable
public ref class XmlReader abstract
public abstract class XmlReader : IDisposable
public abstract class XmlReader
type XmlReader = class
    interface IDisposable
type XmlReader = class
Public MustInherit Class XmlReader
Implements IDisposable
Public MustInherit Class XmlReader
Héritage
XmlReader
Dérivé
Implémente

Exemples

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

XmlReader fournit un accès en lecture seule aux données XML dans un document ou un flux. Cette classe est conforme aux recommandations W3C Extensible Markup Language (XML) 1.0 (quatrième édition) et aux espaces de noms dans XML 1.0 (troisième édition).

XmlReader les méthodes vous permettent de parcourir les données XML et de lire le contenu d’un nœud. Les propriétés de la classe reflètent la valeur du nœud actuel, qui est l’emplacement du lecteur. La ReadState valeur de la propriété indique l’état actuel du lecteur XML. Par exemple, la propriété est définie ReadState.Initial par la XmlReader.Read méthode et ReadState.Closed par la XmlReader.Close méthode. XmlReader fournit également des vérifications et une validation de conformité des données sur un DTD ou un schéma.

XmlReader utilise un modèle d’extraction pour récupérer des données. Ce modèle :

  • Simplifie la gestion de l’état par un affinement procédural naturel et inférieur.

  • Prend en charge plusieurs flux d’entrée et la couche.

  • Permet au client de donner à l’analyseur une mémoire tampon dans laquelle la chaîne est directement écrite, et évite ainsi la nécessité d’une copie de chaîne supplémentaire.

  • Prend en charge le traitement sélectif. Le client peut ignorer les éléments et traiter ceux qui sont intéressés par l’application. Vous pouvez également définir des propriétés à l’avance pour gérer la façon dont le flux XML est traité (par exemple, la normalisation).

Dans cette section :

Création d’un lecteur XML Validation des données XML Conformité des données Navigation dans les nœuds Lecture d’éléments XML Lecture d’attributs XML Lecture du contenu XML Conversion en types CLR Programmation asynchrone Considérations relatives à la sécurité

Création d’un lecteur XML

Utilisez la Create méthode pour créer une XmlReader instance.

Bien que les .NET Framework fournissent des implémentations concrètes de la XmlReader classe, telles que les XmlTextReaderclasses , XmlNodeReaderet les XmlValidatingReader classes, nous vous recommandons d’utiliser les classes spécialisées uniquement dans ces scénarios :

  • Lorsque vous souhaitez lire une sous-arborescence DOM XML à partir d’un XmlNode objet, utilisez la XmlNodeReader classe. (Toutefois, cette classe ne prend pas en charge la validation de schéma ou DTD.)

  • Si vous devez développer des entités à la demande, vous ne souhaitez pas que votre contenu texte soit normalisé ou que vous ne souhaitez pas que les attributs par défaut soient retournés, utilisez la XmlTextReader classe.

Pour spécifier l’ensemble des fonctionnalités que vous souhaitez activer sur le lecteur XML, transmettez un System.Xml.XmlReaderSettings objet à la Create méthode. Vous pouvez utiliser un objet unique System.Xml.XmlReaderSettings pour créer plusieurs lecteurs avec la même fonctionnalité ou modifier l’objet System.Xml.XmlReaderSettings pour créer un nouveau lecteur avec un ensemble de fonctionnalités différent. Vous pouvez également ajouter facilement des fonctionnalités à un lecteur existant.

Si vous n’utilisez pas d’objet System.Xml.XmlReaderSettings , les paramètres par défaut sont utilisés. Pour plus d’informations, consultez la Create page de référence.

XmlReader lève une erreur d’analyse XmlException XML. Une fois qu’une exception est levée, l’état du lecteur n’est pas prévisible. Par exemple, le type de nœud signalé peut être différent du type de nœud réel du nœud actuel. Utilisez la ReadState propriété pour vérifier si le lecteur est en état d’erreur.

Validation des données XML

Pour définir la structure d’un document XML et ses relations d’éléments, types de données et contraintes de contenu, vous utilisez un schéma de définition de type de document (DTD) ou de langage XSD (XML Schema Definition Language). Un document XML est considéré comme bien formé s’il répond à toutes les exigences syntactiques définies par la recommandation W3C XML 1.0. Il est considéré comme valide s’il est bien formé et conforme également aux contraintes définies par son DTD ou son schéma. (Consultez la partie 1 du schéma XML W3C : Structures et schéma XML W3C, partie 2 : Recommandations sur les types de données .) Par conséquent, bien que tous les documents XML valides soient bien formés, tous les documents XML bien formés ne sont pas valides.

Vous pouvez valider les données sur un DTD, un schéma XSD inline ou un schéma XSD stocké dans un objet (un XmlSchemaSet cache) ; ces scénarios sont décrits sur la Create page de référence. XmlReader ne prend pas en charge XML-Data validation de schéma réduite (XDR).

Vous utilisez les paramètres suivants sur la XmlReaderSettings classe pour spécifier le type de validation, le cas échéant, l’instance XmlReader prend en charge.

Utiliser ce XmlReaderSettings membre Pour spécifier
PropriétéDtdProcessing Indique s’il faut autoriser le traitement DTD. Par défaut, le traitement DTD n'est pas autorisé.
PropriétéValidationType Indique si le lecteur doit valider les données et quel type de validation effectuer (DTD ou schéma). Par défaut, les données ne sont pas validées.
ÉvénementValidationEventHandler Gestionnaire d’événements pour recevoir des informations sur les événements de validation. Si aucun gestionnaire d'événements n'est fourni, un objet XmlException est levé sur la première erreur de validation.
PropriétéValidationFlags Options de validation supplémentaires via les membres de l’énumération XmlSchemaValidationFlags :

- AllowXmlAttributes-- Autoriser les attributs XML (xml:*) dans les documents d’instance même s’ils ne sont pas définis dans le schéma. Les attributs sont validés en fonction de leur type de données. Consultez la XmlSchemaValidationFlags page de référence du paramètre à utiliser dans des scénarios spécifiques. (Désactivé par défaut.)
- ProcessIdentityConstraints --Traiter les contraintes d’identité (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) rencontrées lors de la validation. (Activé par défaut.)
- ProcessSchemaLocation--Process schémas spécifiés par l’attribut ou xsi:noNamespaceSchemaLocation l’attributxsi:schemaLocation. (Activé par défaut.)
- ProcessInlineSchema-- Traiter les schémas XML inline lors de la validation. (Désactivé par défaut.)
- ReportValidationWarnings--Signaler des événements si un avertissement de validation se produit. 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. Le ValidationEventHandler est utilisé pour les notifications. (Désactivé par défaut.)
Schemas XmlSchemaSet à utiliser pour la validation.
PropriétéXmlResolver Pour XmlResolver résoudre et accéder aux ressources externes. Cela peut inclure des entités externes telles que DTD et des schémas, ainsi que tous xs:include les éléments xs:import contenus dans le schéma XML. Si vous ne spécifiez pas d’informations d’identification utilisateur XmlResolver, le XmlReader code utilise une valeur par défaut XmlUrlResolver sans informations d’identification de l’utilisateur.

Conformité des données

Les lecteurs XML créés par la Create méthode répondent aux exigences de conformité suivantes par défaut :

  • Les nouvelles lignes et la valeur d’attribut sont normalisées selon la recommandation W3C XML 1.0.

  • Toutes les entités sont automatiquement développées.

  • 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 ne valide pas.

  • La déclaration de préfixe XML mappée à l’URI d’espace de noms XML correct est autorisée.

  • Les noms de notation dans une déclaration d’attribut unique NotationType et NmTokens dans une déclaration d’attribut unique Enumeration sont distincts.

Utilisez ces XmlReaderSettings propriétés pour spécifier le type de vérification de conformité que vous souhaitez activer :

Utiliser cette XmlReaderSettings propriété À Par défaut
PropriétéCheckCharacters Activez ou désactivez les vérifications suivantes :

- Les caractères se trouvent dans la plage de caractères XML juridiques, comme défini par la section 2.2 Caractères de la recommandation W3C XML 1.0.
- Tous les noms XML sont valides, comme défini par la section Constructions syntactiques courantes de la recommandation W3C XML 1.0.

Lorsque cette propriété est définie true sur (par défaut), une XmlException exception est levée si le fichier XML contient des caractères non valides ou des noms XML non valides (par exemple, un nom d’élément commence par un nombre).
La vérification des caractères et des noms est activée.

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. Si le lecteur traite les données de texte, il vérifie toujours que les noms XML sont valides, quel que soit ce paramètre. Note: La recommandation XML 1.0 nécessite une conformité au niveau du document lorsqu’une DTD est présente. Par conséquent, si le lecteur est configuré pour prendre en charge ConformanceLevel.Fragment, mais que les données XML contiennent une définition de type de document (DTD), une levée XmlException est levée.
PropriétéConformanceLevel Choisissez le niveau de conformité à appliquer :

- Document. Conforme aux règles d’un document XML 1.0 bien formé.
- Fragment. Conforme aux règles d’un fragment de document bien formé qui peut être consommé en tant qu’entité analysée externe.
- Auto. Conforme au niveau décidé par le lecteur.

Si les données ne sont pas conformes, une XmlException exception est levée.
Document

Le nœud actuel est le nœud XML sur lequel le lecteur XML est actuellement positionné. Toutes les XmlReader méthodes effectuent des opérations par rapport à ce nœud, et toutes les XmlReader propriétés reflètent la valeur du nœud actuel.

Les méthodes suivantes facilitent la navigation dans les nœuds et analysent les données.

Utiliser cette XmlReaderSettings méthode À
Read Lisez le premier nœud et parcourez le flux d’un nœud à la fois. Ces appels sont généralement effectués à l’intérieur d’une while boucle.

Utilisez la NodeType propriété pour obtenir le type (par exemple, attribut, commentaire, élément, et ainsi de suite) du nœud actuel.
Skip Ignorez les enfants du nœud actuel et passez au nœud suivant.
MoveToContent et MoveToContentAsync Ignorez les nœuds non de contenu et passez au nœud de contenu suivant ou à la fin du fichier.

Les nœuds non-contenu incluent ProcessingInstruction, , DocumentType, Commentet SignificantWhitespaceWhitespace.

Les nœuds de contenu incluent du texte sans espace blanc, CDATAet EndEntityEntityReference .
ReadSubtree Lit un élément et tous ses enfants, puis retournez un nouvel XmlReader ensemble ReadState.Initiald’instances sur .

Cette méthode est utile pour créer des limites autour des éléments XML ; par exemple, si vous souhaitez transmettre des données à un autre composant à des fins de traitement et que vous souhaitez limiter la quantité de vos données auquel le composant peut accéder.

Consultez la XmlReader.Read page de référence pour obtenir un exemple de navigation dans un flux de texte d’un nœud à la fois et d’afficher le type de chaque nœud.

Les sections suivantes décrivent comment lire des types de données spécifiques, tels que des éléments, des attributs et des données typées.

Lecture d’éléments XML

Le tableau suivant répertorie les méthodes et les propriétés que la XmlReader classe fournit pour le traitement des éléments. 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. 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. Par exemple, vous pouvez utiliser la méthode ReadInnerXml pour lire le contenu d'un élément.

Notes

Consultez la section 3.1 de la recommandation W3C XML 1.0 pour les définitions des balises de début, des balises de fin et des balises d’élément vides.

Utiliser ce XmlReader membre À
Méthode IsStartElement Vérifiez si le nœud actuel est une balise de début ou une balise d’élément vide.
Méthode ReadStartElement Vérifiez que le nœud actuel est un élément et avancez le lecteur vers le nœud suivant (appels IsStartElement suivis par Read).
Méthode ReadEndElement Vérifiez que le nœud actuel est une balise de fin et faites passer le lecteur au nœud suivant.
Méthode ReadElementString Lit un élément texte uniquement.
Méthode ReadToDescendant Faites passer le lecteur XML à l’élément descendant (enfant) suivant qui a le nom spécifié.
Méthode ReadToNextSibling Faites passer le lecteur XML à l’élément frère suivant qui a le nom spécifié.
PropriétéIsEmptyElement Vérifiez si l’élément actuel a une balise d’élément de fin. Exemple :

- <item num="123"/> (IsEmptyElement est true.)
- <item num="123"> </item> (IsEmptyElement est false, bien que le contenu de l’élément soit vide.)

Pour obtenir un exemple de lecture du contenu texte d’éléments, consultez la ReadString méthode. L’exemple suivant traite les éléments à l’aide d’une while boucle.

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 d’attributs XML

Les attributs XML sont généralement trouvés sur les éléments, mais ils sont également autorisés sur les nœuds de déclaration XML et de type de document.

Lorsqu’elle est positionnée sur un nœud d’élément, la MoveToAttribute méthode vous permet de parcourir la liste d’attributs de l’élément. Notez qu’après MoveToAttribute avoir été appelée, les propriétés de nœud telles que Name, NamespaceURIet Prefix reflètent les propriétés de cet attribut, et non les propriétés de l’élément auquel appartient l’attribut.

La XmlReader classe fournit ces méthodes et propriétés pour lire et traiter des attributs sur des éléments.

Utiliser ce XmlReader membre À
PropriétéHasAttributes Vérifiez si le nœud actuel a des attributs.
PropriétéAttributeCount Obtient le nombre d’attributs sur l’élément actuel.
Méthode MoveToFirstAttribute Accédez au premier attribut d’un élément.
Méthode MoveToNextAttribute Passez à l’attribut suivant dans un élément.
Méthode MoveToAttribute Accéder à un attribut spécifié.
GetAttribute méthode ou Item[] propriété Obtient la valeur d’un attribut spécifié.
PropriétéIsDefault 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.
Méthode MoveToElement Accédez à l’élément qui possède l’attribut actuel. Utilisez cette méthode pour revenir à un élément après avoir parcouru ses attributs.
Méthode ReadAttributeValue Analysez la valeur d’attribut en un ou plusieurs Text``EntityReferencenœuds ou EndEntity nœuds.

Toutes les méthodes et propriétés XmlReader générales peuvent aussi être utilisées pour traiter des attributs. 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. Vous pouvez aussi utiliser les méthodes Read de contenu pour obtenir la valeur de l'attribut.

Cet exemple utilise la AttributeCount propriété pour parcourir tous les attributs d’un élément.

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

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 XML

Lorsque le lecteur XML est positionné sur un nœud de déclaration XML, la Value propriété retourne les informations de version, autonomes et d’encodage sous la forme d’une chaîne unique. XmlReader objets créés par la Create méthode, la XmlTextReader classe et la XmlValidatingReader classe exposent les éléments de version, autonomes et d’encodage en tant qu’attributs.

Lecture d’attributs sur les nœuds de type de document

Lorsque le lecteur XML est positionné sur un nœud de type de document, la méthode et Item[] la GetAttribute propriété peuvent être utilisées pour retourner les valeurs des littéraux SYSTEM et PUBLIC. Par exemple, un appel reader.GetAttribute("PUBLIC") retourne la valeur PUBLIC.

Lecture d’attributs sur les nœuds d’instruction de traitement

Lorsque l'objet XmlReader est positionné sur un n_œud d'instruction de traitement, la propriété Value retourne tout le contenu textuel. Les éléments du nœud d’instruction de traitement ne sont pas traités comme des attributs. Ils ne peuvent pas être lus avec la méthode ou MoveToAttribute la GetAttribute méthode.

Lecture du contenu XML

La classe XmlReader inclut les membres suivants qui lisent le contenu à partir d’un fichier XML et retournent le contenu sous forme de valeurs de chaîne. (Pour retourner des types CLR, consultez la section suivante.)

Utiliser ce XmlReader membre À
PropriétéValue Obtenez le contenu texte du nœud actuel. La valeur retournée dépend du type de nœud ; consultez la page de référence pour plus d’informations Value .
Méthode ReadString Obtient le contenu d’un nœud d’élément ou de texte sous forme de chaîne. Cette méthode s’arrête lors du traitement des instructions et des commentaires.

Pour plus d’informations sur la façon dont cette méthode gère des types de nœuds spécifiques, consultez la ReadString page de référence.
Méthodes ReadInnerXml et ReadInnerXmlAsync Obtenez tout le contenu du nœud actuel, y compris le balisage, mais à l’exclusion des balises de début et de fin. Par exemple, pour :

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

ReadInnerXml retourne :

this<child id="123"/>
Méthodes ReadOuterXml et ReadOuterXmlAsync Obtenez tout le contenu du nœud actuel et de ses enfants, y compris les balises de balisage et de début/fin. Par exemple, pour :

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

ReadOuterXml retourne :

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

Conversion en types CLR

Vous pouvez utiliser les membres de la XmlReader classe (répertoriés dans le tableau suivant) pour lire des données XML et retourner des valeurs en tant que types CLR (Common Language Runtime) au lieu de chaînes. 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 des valeurs de chaîne.

  • Les méthodes ReadElementContentAs peuvent uniquement être appelées sur les types de nœuds d’élément. Elles peuvent être utilisées pour des éléments qui comportent des éléments enfants ou du contenu mixte. S’il est appelé, l’objet XmlReader lit l’étiquette de début et le contenu de l’élément, puis avance jusqu’après l’étiquette d’élément de fin. Les instructions de traitement et les commentaires sont ignorés et les entités sont développées.

  • Les méthodes ReadContentAs lisent le contenu 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 associées, convertissez le contenu du texte en type de retour demandé. Le texte, les espaces blancs, les espaces blancs significatifs et les sections CDATA sont concaténés. Les commentaires et les instructions de traitement sont ignorés et les références d’entité sont automatiquement résolues.

La XmlReader classe utilise les règles définies par le schéma XML W3C, partie 2 : recommandation des types de données .

Utiliser cette XmlReader méthode Pour retourner ce type CLR
ReadContentAsBoolean et ReadElementContentAsBoolean Boolean
ReadContentAsDateTime et ReadElementContentAsDateTime DateTime
ReadContentAsDouble et ReadElementContentAsDouble Double
ReadContentAsLong et ReadElementContentAsLong Int64
ReadContentAsInt et ReadElementContentAsInt Int32
ReadContentAsString et ReadElementContentAsString String
ReadContentAs et ReadElementContentAs Type que vous spécifiez avec le returnType paramètre
ReadContentAsObject et ReadElementContentAsObject Type le plus approprié, tel que spécifié par la XmlReader.ValueType propriété. Consultez la prise en charge des types dans les classes System.Xml pour obtenir des informations de mappage.

Si un élément ne peut pas facilement être converti en type CLR en raison de son format, vous pouvez utiliser un mappage de schéma pour garantir une conversion réussie. L’exemple suivant utilise un fichier .xsd pour convertir l’élément hire-date en type xs:date , puis utilise la méthode pour retourner l’élément ReadElementContentAsDateTime en tant qu’objet DateTime .

Entrée (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) :

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

Code:

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

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

  // Return the hire-date as a DateTime object.
  DateTime hireDate = reader.ReadElementContentAsDateTime();
  Console.WriteLine("Six Month Review Date: {0}", hireDate.AddMonths(6));
}
' Create a validating XmlReader object. The schema 
' provides the necessary type information.
Dim settings As XmlReaderSettings = New XmlReaderSettings()
settings.ValidationType = ValidationType.Schema
settings.Schemas.Add("urn:empl-hire", "hireDate.xsd")
Using reader As XmlReader = XmlReader.Create("hireDate.xml", settings) 
  ' Move to the hire-date element.
  reader.MoveToContent()
  reader.ReadToDescendant("hire-date")

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

Output:

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

Programmation asynchrone

La plupart des XmlReader méthodes ont des équivalents asynchrones qui ont « Async » à la fin de leurs noms de méthode. Par exemple, l’équivalent asynchrone est ReadContentAsObject ReadContentAsObjectAsync.

Les méthodes suivantes peuvent être utilisées avec des appels de méthode asynchrones :

Les sections suivantes décrivent l’utilisation asynchrone pour les méthodes qui n’ont pas d’équivalents asynchrones.

ReadStartElement, méthode

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

ReadEndElement, méthode

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 ReadToNextSibling

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

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

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

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

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

    ' find the next sibling
    Dim nt As XmlNodeType
    Do

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

    Return False

End Function

ReadToFollowing, méthode

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

ReadToDescendant, méthode

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é

Tenez compte des éléments suivants lors de l’utilisation de la XmlReader classe :

  • Les exceptions levées à partir du XmlReader chemin d’accès peuvent révéler des informations que vous ne souhaiterez peut-être pas mettre en bulles à votre application. Votre application doit intercepter les exceptions et les traiter de manière appropriée.

  • N’activez pas le traitement DTD si vous êtes préoccupé par les problèmes de déni de service ou si vous traitez avec des sources non approuvées. Le traitement DTD est désactivé par défaut pour XmlReader les objets créés par la Create méthode.

    Si le traitement DTD est activé, vous pouvez utiliser l'objet XmlSecureResolver pour limiter les ressources auxquelles l'objet XmlReader peut avoir accès. Vous pouvez également concevoir votre application afin que le traitement XML soit limité à la mémoire et au temps. Par exemple, vous pouvez configurer des limites de délai d’attente dans votre application ASP.NET.

  • Les données XML peuvent inclure des références à des ressources externes telles qu'un fichier de schéma. Par défaut, les ressources externes sont résolues à l’aide d’un XmlUrlResolver objet sans informations d’identification utilisateur. Vous pouvez renforcer la sécurité en procédant comme suit :

  • Les ProcessInlineSchema indicateurs de validation d’un XmlReaderSettings ProcessSchemaLocation objet ne sont pas définis par défaut. 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. 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. Si la XmlResolver propriété est définie nullsur , les emplacements de schéma ne sont pas résolus même si les indicateurs de validation et ProcessSchemaLocation les ProcessInlineSchema indicateurs de validation sont définis.

    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. Par conséquent, les schémas externes ne devraient être résolus que s'ils proviennent de sources fiables.

    Nous vous recommandons de désactiver l’indicateur ProcessIdentityConstraints lors de la validation de documents XML non approuvés dans des scénarios de haute disponibilité par rapport à un schéma qui a des contraintes d’identité sur une grande partie du document. Cet indicateur est activé par défaut.

  • 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. Pour limiter la taille de l’entrée envoyée au XmlReader, vous pouvez :

    • Limitez la taille du document en définissant la MaxCharactersInDocument propriété.

    • Limitez le nombre de caractères résultant du développement d’entités en définissant la MaxCharactersFromEntities propriété.

    • Créez une implémentation personnalisée IStream pour le XmlReader.

  • La ReadValueChunk méthode peut être utilisée pour gérer de grands flux de données. Cette méthode lit un petit nombre de caractères à la fois au lieu d'allouer une seule chaîne à toute la valeur.

  • Lors de la lecture d’un document XML avec un grand nombre de noms locaux uniques, d’espaces de noms ou de préfixes, un problème peut se produire. Si vous utilisez une classe qui dérive de XmlReader, et que vous appelez le LocalName, Prefixou NamespaceURI la propriété pour chaque élément, la chaîne retournée est ajoutée à un NameTable. La collection détenue par la NameTable taille ne diminue jamais, créant une fuite de mémoire virtuelle des handles de chaîne. Une atténuation pour cela consiste à dériver de la NameTable classe et à appliquer un quota de taille maximale. (Il n’existe aucun moyen d’empêcher l’utilisation d’un NameTable, ou de changer le NameTable moment où il est plein). Une autre atténuation consiste à éviter d’utiliser les propriétés mentionnées et à utiliser plutôt la méthode avec la MoveToAttribute IsStartElement méthode si possible ; ces méthodes ne retournent pas de chaînes et évitent donc le problème de surremplir la NameTable collection.

  • Les objets XmlReaderSettings peuvent contenir des informations confidentielles telles que des informations d'identification de l'utilisateur. 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. Soyez prudent lors de la mise en cache d’objets XmlReaderSettings ou lors du passage de l’objet XmlReaderSettings d’un composant à un autre.

  • N'acceptez pas les composants de prise en charge, tels que les objets NameTable, XmlNamespaceManager et XmlResolver provenant d'une source non fiable.

Constructeurs

XmlReader()

Initialise une nouvelle instance de la classe XmlReader.

Propriétés

AttributeCount

En cas de substitution dans une classe dérivée, obtient le nombre d'attributs du nœud actuel.

BaseURI

En cas de substitution dans une classe dérivée, obtient l'URI de base du nœud actuel.

CanReadBinaryContent

Obtient une valeur indiquant si XmlReader implémente les méthodes de lecture de contenu binaire.

CanReadValueChunk

Obtient une valeur indiquant si XmlReader implémente la méthode ReadValueChunk(Char[], Int32, Int32).

CanResolveEntity

Obtient une valeur indiquant si ce lecteur peut analyser et résoudre les entités.

Depth

En cas de substitution dans une classe dérivée, obtient la profondeur du nœud actuel dans le document XML.

EOF

En cas de substitution dans une classe dérivée, obtient une valeur indiquant si le lecteur est placé à la fin du flux.

HasAttributes

Obtient une valeur indiquant si le nœud actuel a des attributs.

HasValue

En cas de substitution dans une classe dérivée, obtient une valeur indiquant si le nœud actuel peut posséder Value.

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.

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

Item[Int32]

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec l'index spécifié.

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.

Item[String]

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec le Name spécifié.

LocalName

En cas de substitution dans une classe dérivée, obtient le nom local du nœud actuel.

Name

En cas de substitution dans une classe dérivée, obtient le nom qualifié du nœud actuel.

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

NameTable

En cas de substitution dans une classe dérivée, obtient le XmlNameTable associé à cette implémentation.

NodeType

En cas de substitution dans une classe dérivée, obtient le type du nœud actuel.

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.

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.

ReadState

En cas de substitution dans une classe dérivée, obtient l'état du lecteur.

SchemaInfo

Obtient les informations de schéma qui ont été assignées au nœud actuel à la suite de la validation du schéma.

Settings

Obtient l'objet XmlReaderSettings permettant de créer cette instance de XmlReader.

Value

En cas de substitution dans une classe dérivée, obtient la valeur texte du nœud actuel.

ValueType

Obtient le type de CLR du nœud actuel.

XmlLang

En cas de substitution dans une classe dérivée, obtient la portée xml:lang en cours.

XmlSpace

En cas de substitution dans une classe dérivée, obtient la portée xml:space en cours.

Méthodes

Close()

En cas de substitution dans une classe dérivée, modifie ReadState en Closed.

Create(Stream)

Crée une instance de XmlReader à l’aide du flux spécifié avec les paramètres par défaut.

Create(Stream, XmlReaderSettings)

Crée une instance de XmlReader avec le flux et les paramètres spécifiés.

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.

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.

Create(String)

Crée une instance de XmlReader avec l’URI spécifié.

Create(String, XmlReaderSettings)

Crée une instance de XmlReader en utilisant l’URI et les paramètres spécifiés.

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.

Create(TextReader)

Crée une instance de XmlReader à l’aide du lecteur de texte spécifié.

Create(TextReader, XmlReaderSettings)

Crée une instance de XmlReader à l’aide du lecteur de texte et des paramètres spécifiés.

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.

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.

Create(XmlReader, XmlReaderSettings)

Crée une instance de XmlReader à l’aide des paramètres et du lecteur XML spécifiés.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe XmlReader.

Dispose(Boolean)

Libère les ressources non managées utilisées par XmlReader et libère éventuellement les ressources managées.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetAttribute(Int32)

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec l'index spécifié.

GetAttribute(String)

En cas de substitution dans une classe dérivée, obtient la valeur de l'attribut avec le Name spécifié.

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.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
GetValueAsync()

Obtient de façon asynchrone la valeur du nœud actuel.

IsName(String)

Retourne une valeur indiquant si l’argument de chaîne est un nom XML valide.

IsNameToken(String)

Retourne une valeur indiquant si l’argument de chaîne est un jeton de nom XML valide.

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.

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

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.

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.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
MoveToAttribute(Int32)

En cas de substitution dans une classe dérivée, se déplace vers l'attribut avec l'index spécifié.

MoveToAttribute(String)

En cas de substitution dans une classe dérivée, se déplace vers l'attribut avec le Name spécifié.

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.

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). 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. Il ignore les nœuds possédant les types suivants : ProcessingInstruction, DocumentType, Comment, Whitespace ou SignificantWhitespace.

MoveToContentAsync()

Vérifie de façon asynchrone si le nœud actuel est un nœud de contenu. 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.

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.

MoveToFirstAttribute()

En cas de substitution dans une classe dérivée, se déplace vers le premier attribut.

MoveToNextAttribute()

En cas de substitution dans une classe dérivée, se déplace vers l'attribut suivant.

Read()

En cas de substitution dans une classe dérivée, lit le nœud suivant à partir du flux.

ReadAsync()

Lit de façon asynchrone le nœud suivant à partir du flux de données.

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.

ReadContentAs(Type, IXmlNamespaceResolver)

Lit le contenu en tant qu'objet du type spécifié.

ReadContentAsAsync(Type, IXmlNamespaceResolver)

Lit de façon asynchrone le contenu en tant qu'objet du type spécifié.

ReadContentAsBase64(Byte[], Int32, Int32)

Lit le contenu et retourne les octets binaires décodés au format Base64.

ReadContentAsBase64Async(Byte[], Int32, Int32)

Lit de façon asynchrone le contenu et retourne les octets binaires décodés au format Base64.

ReadContentAsBinHex(Byte[], Int32, Int32)

Lit le contenu et retourne les octets binaires décodés au format BinHex.

ReadContentAsBinHexAsync(Byte[], Int32, Int32)

Lit de façon asynchrone le contenu et retourne les octets binaires décodés au format BinHex.

ReadContentAsBoolean()

Lit le contenu de texte à la position actuelle comme un Boolean.

ReadContentAsDateTime()

Lit le contenu de texte à la position actuelle comme un objet DateTime.

ReadContentAsDateTimeOffset()

Lit le contenu de texte à la position actuelle comme un objet DateTimeOffset.

ReadContentAsDecimal()

Lit le contenu de texte à la position actuelle comme un objet Decimal.

ReadContentAsDouble()

Lit le contenu de texte à la position actuelle en tant que nombre à virgule flottante double précision.

ReadContentAsFloat()

Lit le contenu de texte à la position actuelle en tant que nombre à virgule flottante simple précision.

ReadContentAsInt()

Lit le contenu de texte à la position actuelle comme un entier signé de 32 bits.

ReadContentAsLong()

Lit le contenu de texte à la position actuelle comme un entier signé de 64 bits.

ReadContentAsObject()

Lit le contenu de texte à la position actuelle comme un Object.

ReadContentAsObjectAsync()

Lit de façon asynchrone le contenu de texte à la position actuelle comme un objet Object.

ReadContentAsString()

Lit le contenu de texte à la position actuelle comme un objet String.

ReadContentAsStringAsync()

Lit de façon asynchrone le contenu de texte à la position actuelle comme un objet String.

ReadElementContentAs(Type, IXmlNamespaceResolver)

Lit le contenu de l'élément en tant que type demandé.

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

ReadElementContentAsAsync(Type, IXmlNamespaceResolver)

Lit de façon asynchrone le contenu de l'élément en tant que type demandé.

ReadElementContentAsBase64(Byte[], Int32, Int32)

Lit l'élément et décode le contenu au format Base64.

ReadElementContentAsBase64Async(Byte[], Int32, Int32)

Lit de façon asynchrone l'élément et décode le contenu au format Base64.

ReadElementContentAsBinHex(Byte[], Int32, Int32)

Lit l'élément et décode le contenu au format BinHex.

ReadElementContentAsBinHexAsync(Byte[], Int32, Int32)

Lit de façon asynchrone l'élément et décode le contenu au format BinHex.

ReadElementContentAsBoolean()

Lit l'élément actuel et retourne le contenu en tant qu'objet Boolean.

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.

ReadElementContentAsDateTime()

Lit l'élément actuel et retourne le contenu en tant qu'objet DateTime.

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.

ReadElementContentAsDecimal()

Lit l'élément actuel et retourne le contenu en tant qu'objet Decimal.

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.

ReadElementContentAsDouble()

Lit l'élément actuel et retourne le contenu en tant que nombre à virgule flottante double précision.

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.

ReadElementContentAsFloat()

Lit l'élément actuel et retourne le contenu en tant que nombre à virgule flottante simple précision.

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.

ReadElementContentAsInt()

Lit l'élément actuel et retourne le contenu comme un entier signé de 32 bits.

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.

ReadElementContentAsLong()

Lit l’élément actuel et retourne le contenu comme un entier signé de 64 bits.

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.

ReadElementContentAsObject()

Lit l'élément actuel et retourne le contenu en tant que Object.

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.

ReadElementContentAsObjectAsync()

Lit de façon asynchrone l'élément actuel et retourne le contenu en tant que Object.

ReadElementContentAsString()

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

ReadElementContentAsStringAsync()

Lit de façon asynchrone l'élément actuel et retourne le contenu en tant qu'objet String.

ReadElementString()

Lit un élément texte uniquement. 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.

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

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

ReadEndElement()

Vérifie que le nœud de contenu actuel est une étiquette de fin et avance le lecteur jusqu’au nœud suivant.

ReadInnerXml()

En cas de substitution dans une classe dérivée, lit tout le contenu, y compris le balisage, sous forme de chaîne.

ReadInnerXmlAsync()

Lit de façon asynchrone tout le contenu, notamment le balisage, en tant que chaîne.

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.

ReadOuterXmlAsync()

Lit de façon asynchrone le contenu, notamment le balisage, qui représente ce nœud et tous ses enfants.

ReadStartElement()

Vérifie que le nœud actuel est un élément et avance le lecteur jusqu'au nœud suivant.

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.

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.

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

ReadSubtree()

Retourne une nouvelle instance de XmlReader qui permet de lire le nœud actuel, ainsi que tous ses descendants.

ReadToDescendant(String)

Avance le XmlReader vers l'élément descendant suivant portant le nom qualifié spécifié.

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.

ReadToFollowing(String)

Lit jusqu'à trouver un élément avec le nom qualifié spécifié.

ReadToFollowing(String, String)

Lit jusqu'à trouver un élément avec le nom local et l'URI de l'espace de noms spécifiés.

ReadToNextSibling(String)

Avance le XmlReader vers l'élément frère suivant portant le nom qualifié spécifié.

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.

ReadValueChunk(Char[], Int32, Int32)

Lit des flux de texte volumineux incorporés dans un document XML.

ReadValueChunkAsync(Char[], Int32, Int32)

Lit de façon asynchrone des flux de texte volumineux incorporés dans un document XML.

ResolveEntity()

En cas de substitution dans une classe dérivée, résout la référence d'entité des nœuds EntityReference.

Skip()

Ignore les enfants du nœud actuel.

SkipAsync()

Ignore de façon asynchrone les enfants du nœud actuel.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Pour obtenir une description de ce membre, consultez Dispose().

S’applique à

Voir aussi