XNode.ReadFrom(XmlReader) Méthode

public:
 static System::Xml::Linq::XNode ^ ReadFrom(System::Xml::XmlReader ^ reader);

public static System.Xml.Linq.XNode ReadFrom(System.Xml.XmlReader reader);

static member ReadFrom : System.Xml.XmlReader -> System.Xml.Linq.XNode

Public Shared Function ReadFrom (reader As XmlReader) As XNode

Paramètres

Retours

Qui XNode contient le nœud et ses nœuds descendants qui ont été lus à partir du lecteur. Le type d’exécution du nœud est déterminé par le type de nœud (NodeType) du premier nœud rencontré dans le lecteur.

Exceptions

Exemples

Cet exemple utilise le fichier XML suivant, nommé Source.xml:

<?xml version="1.0" encoding="utf-8" ?>
<Root>
  <Child Key="01">
    <GrandChild>aaa</GrandChild>
  </Child>
  <Child Key="02">
    <GrandChild>bbb</GrandChild>
  </Child>
  <Child Key="03">
    <GrandChild>ccc</GrandChild>
  </Child>
</Root>

L’exemple suivant crée une méthode d’axe personnalisée qui utilise ReadFrom , puis interroge l’axe personnalisé à l’aide d’une requête LINQ :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml;
using System.Xml.Linq;

class Program
{
    static IEnumerable<XElement> StreamRootChildDoc(string uri)
    {
        using (XmlReader reader = XmlReader.Create(uri))
        {
            reader.MoveToContent();
            
            // Parse the file and return each of the nodes.
            while (!reader.EOF)
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name == "Child")
                {
                    XElement el = XElement.ReadFrom(reader) as XElement;
                    if (el != null)
                        yield return el;
                }
                else
                {
                    reader.Read();
                }
            }
        }
    }

    static void Main(string[] args)
    {
        IEnumerable<string> grandChildData =
            from el in StreamRootChildDoc("Source.xml")
            where (int)el.Attribute("Key") > 1
            select (string)el.Element("GrandChild");

        foreach (string str in grandChildData)
            Console.WriteLine(str);
    }
}

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml
Imports System.Xml.Linq

Module Program
    Iterator Function StreamRootChildDoc(ByVal uri As String) As IEnumerable(Of XElement)

        Using reader As XmlReader = XmlReader.Create(uri)
            reader.MoveToContent()

            ' Parse the file and return each of the nodes.
            While Not reader.EOF

                If reader.NodeType = XmlNodeType.Element AndAlso reader.Name = "Child" Then
                    Dim el As XElement = TryCast(XElement.ReadFrom(reader), XElement)
                    If el IsNot Nothing Then Yield el
                Else
                    reader.Read()
                End If
            End While
        End Using
    End Function

    Sub Main(args As String())

        Dim grandChildData As IEnumerable(Of String) =
            From el In StreamRootChildDoc("Source.xml")
            Where CInt(el.Attribute("Key")) > 1
            Select CStr(el.Element("GrandChild"))

        For Each str As String In grandChildData
            Console.WriteLine(str)
        Next

    End Sub

End Module

Cet exemple produit la sortie suivante :

bbb
ccc

Remarques

Vous pouvez utiliser cette méthode pour écrire une méthode qui retourne une collection de nœuds, ce qui génère chaque nœud au fur et à mesure que le nœud est lu à partir du lecteur. Cette méthode vous permet de traiter des fichiers XML arbitrairement volumineux avec un encombrement mémoire très faible.

Le lecteur que vous passez à cette méthode peut lever des exceptions. ReadFrom n’intercepte pas toutes les exceptions levées par le lecteur ; les exceptions non gérées sont en bulle jusqu’au code qui a appelé ReadFrom. En particulier, votre code doit être prêt à gérer XmlException.

Pour obtenir un exemple de diffusion en continu d’un document plus complexe, consultez Comment diffuser en continu des fragments XML avec accès aux informations d’en-tête.

Certains opérateurs de requête standard, tels que OrderBy, itérer leur source, collecter toutes les données, les trier, puis enfin générer le premier élément dans la séquence. Si vous utilisez un opérateur de requête qui matérialise sa source avant de générer le premier élément, vous ne conservez pas une petite empreinte mémoire.

Pour obtenir un exemple d’utilisation de LINQ to XML pour transformer des documents XML extrêmement volumineux tout en conservant une petite empreinte mémoire, consultez Comment effectuer une transformation de streaming de documents XML volumineux.

Voir aussi

• Vue d’ensemble de LINQ to XML