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 du code 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 avant uniquement en lecture seule aux données XML dans un document ou un flux. 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) .

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, où le lecteur est positionné. La ReadState valeur de la propriété indique l’état actuel du lecteur XML. 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. XmlReader fournit également des vérifications de conformité des données et une validation par rapport à une DTD ou un schéma.

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

  • Simplifie la gestion de l’état d’un raffinement des procédures naturel, descendant.

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

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

  • Prend en charge le traitement sélectif. Le client peut ignorer des éléments et traiter ceux qui présentent un intérêt pour l’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).

Dans cette section :

Création d’un lecteur XML
Validation de données XML
Conformité aux données
Navigation dans les nœuds
Lire des éléments XML
Lecture des attributs XML
Lecture du contenu XML
Convertir 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 le .NET Framework fournisse des implémentations concrètes de la XmlReader classe, telles que XmlTextReader , XmlNodeReader , et les XmlValidatingReader classes, nous vous recommandons d’utiliser les classes spécialisées uniquement dans les scénarios suivants :

  • 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 DTD ou de schéma.)

  • 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 souhaitiez pas que les attributs par défaut soient retournés, utilisez la XmlTextReader classe.

Pour spécifier l’ensemble de fonctionnalités que vous souhaitez activer sur le lecteur XML, transmettez un System.Xml.XmlReaderSettings objet à la Create méthode. 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. Vous pouvez également ajouter facilement des fonctionnalités à un lecteur existant.

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

XmlReader lève une exception XmlException sur les erreurs d’analyse 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 dans un état d’erreur.

Validation de données XML

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). 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. 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. (Consultez le W3C XML Schema Part 1 : structures and the W3C XML Schema Part 2 : Datatypes recommendations.) Par conséquent, bien que tous les documents XML valides soient correctement formés, tous les documents XML bien formés ne sont pas valides.

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

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

Utiliser ce XmlReaderSettings membre Pour spécifier
PropriétéDtdProcessing Indique si le traitement DTD doit être autorisé. Par défaut, le traitement DTD n'est pas autorisé.
PropriétéValidationType Indique si le lecteur doit valider les données et le 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 par le biais des membres de l' XmlSchemaValidationFlags énumération :

- AllowXmlAttributes--Autorisez 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 pour le 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 pendant la validation. (Activé par défaut.)
- ProcessSchemaLocation --Traiter les schémas spécifiés par xsi:schemaLocation l' xsi:noNamespaceSchemaLocation attribut ou. (Activé par défaut.)
- ProcessInlineSchema--Traitez les schémas XML inline lors de la validation. (Désactivé par défaut.)
- ReportValidationWarnings--Signaler les é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 XmlResolverPour la résolution et l’accès aux ressources externes. Cela peut inclure des entités externes telles que des DTD et des schémas, ainsi que tout xs:include xs:import élément ou contenu dans le schéma XML. Si vous ne spécifiez pas un XmlResolver , le XmlReader utilise une valeur par défaut sans XmlUrlResolver informations d’identification de l’utilisateur.

Conformité aux données

Les lecteurs XML créés par la Create méthode remplissent les conditions de conformité suivantes par défaut :

  • Les nouvelles lignes et la nouvelle valeur de l’attribut sont normalisées conformément à la recommandation du W3C sur XML 1,0.

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

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

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

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

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

Utilisez cette XmlReaderSettings propriété À Par défaut
PropriétéCheckCharacters Activez ou désactivez les vérifications pour les éléments suivants :

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

Quand cette propriété a la valeur true (valeur par défaut), une XmlException 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).
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 des données texte, il vérifie toujours que les noms XML sont valides, quel que soit ce paramètre. Remarque : La recommandation XML 1,0 requiert la 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 DTD (définition de type de document), une XmlException exception est levée.
PropriétéConformanceLevel Choisissez le niveau de conformité à appliquer :

- Document. Conforme aux règles d’un document XML 1,0 correctement construit.
- Fragment. Est 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 choisi 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 l’analyse des données.

Utilisez cette XmlReaderSettings méthode À
Read Lit le premier nœud et avance le flux d’un nœud à la fois. De tels 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, etc.) du nœud actuel.
Skip Ignore les enfants du nœud actuel et passe au nœud suivant.
MoveToContent et MoveToContentAsync Ignorer les nœuds de non-contenu et passer au nœud de contenu suivant ou à la fin du fichier.

Les nœuds autres que les nœuds de contenu incluent ProcessingInstruction , DocumentType ,, Comment Whitespace et SignificantWhitespace .

Les nœuds de contenu incluent du texte qui n’est pas un espace blanc,, CDATA EntityReference et EndEntity .
ReadSubtree Lit un élément et tous ses enfants et retourne une nouvelle XmlReader instance de la valeur 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.

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.

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.

Lire des éléments XML

Le tableau suivant répertorie les méthodes et les propriétés XmlReader fournies par la classe 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 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.

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 faites avancer le lecteur jusqu’au 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 avancer le lecteur jusqu’au nœud suivant.
Méthode ReadElementString Lire un élément de texte uniquement.
Méthode ReadToDescendant Avance le lecteur XML sur l’élément descendant (enfant) suivant portant le nom spécifié.
Méthode ReadToNextSibling Avance le lecteur XML vers l’élément frère suivant portant le nom spécifié.
PropriétéIsEmptyElement Vérifie 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 de texte des é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 des attributs XML

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.

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

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 possède des attributs.
PropriétéAttributeCount Obtient le nombre d’attributs sur l’élément actuel.
Méthode MoveToFirstAttribute Accède au premier attribut d’un élément.
Méthode MoveToNextAttribute Passer à l’attribut suivant dans un élément.
Méthode MoveToAttribute Déplacer vers 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 Analyse la valeur d’attribut dans un ou Text plusieurs EntityReference EndEntity nœuds, ou.

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 naviguer dans 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, autonome et d’encodage sous la forme d’une chaîne unique. XmlReader les objets créés par la Create méthode, la XmlTextReader classe et la XmlValidatingReader classe exposent les éléments de version, autonome et d’encodage en tant qu’attributs.

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

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

Lecture des 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 à l’aide de la GetAttribute MoveToAttribute méthode ou.

Lecture du contenu XML

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. (Pour retourner des types CLR, consultez la section suivante.)

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

Pour plus d’informations sur la façon dont cette méthode gère les types de nœuds spécifiques, consultez la ReadString page de référence.
Méthodes ReadInnerXml et ReadInnerXmlAsync Obtient 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 le balisage et les balises de début et de fin. Par exemple, pour :

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

ReadOuterXml retourne :

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

Convertir en types CLR

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

  • Les méthodes ReadElementContentAs peuvent uniquement être appelées sur des 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 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é. 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 résolues automatiquement.

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

Utilisez 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 Le 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é. Pour plus d’informations sur le mappage, consultez prise en charge des types dans les Classes System.Xml .

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. L’exemple suivant utilise un fichier. xsd pour convertir l' hire-date élément en xs:date type, puis utilise la ReadElementContentAsDateTime méthode pour retourner l’élément sous la forme d’un DateTime objet.

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 de ReadContentAsObject est ReadContentAsObjectAsync .

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

Les sections suivantes décrivent l’utilisation asynchrone des 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

Méthode ReadEndElement

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

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

Méthode ReadToFollowing

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

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

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

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

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

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

    Return False
End Function

Méthode ReadToDescendant

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

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

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

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

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

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

    Return False
End Function

Considérations relatives à la sécurité

Tenez compte des éléments suivants lorsque vous utilisez la XmlReader classe :

  • Les exceptions levées à partir de XmlReader peuvent divulguer des informations de chemin d’accès que vous ne voulez peut-être pas être propagées à votre application. Votre application doit intercepter les exceptions et les traiter de manière appropriée.

  • 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. 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 de manière à ce que le traitement XML soit soumis à une limitation de la mémoire et du 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 de l’utilisateur. Vous pouvez renforcer la sécurité en procédant comme suit :

  • Les ProcessInlineSchema ProcessSchemaLocation indicateurs de validation et d’un XmlReaderSettings 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é a la valeur null , les emplacements de schéma ne sont pas résolus même si les ProcessInlineSchema ProcessSchemaLocation indicateurs de validation et 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' ProcessIdentityConstraints 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. 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 des entités en définissant la MaxCharactersFromEntities propriété.

    • Créer une IStream implémentation personnalisée 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.

  • 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. Si vous utilisez une classe qui dérive de XmlReader et que vous appelez la LocalName propriété, Prefix ou NamespaceURI 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. L’une des solutions de contournement 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 basculer NameTable lorsqu’il est plein). Une autre solution d’atténuation consiste à éviter d’utiliser les propriétés mentionnées et à utiliser la MoveToAttribute méthode avec la méthode dans la mesure du IsStartElement possible ; ces méthodes ne retournent pas de chaînes et, par conséquent, évitent le problème de surremplissage de 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 des XmlReaderSettings objets ou lors du passage XmlReaderSettings de l’objet 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