Partager via


Procédure : diffuser des fragments XML en continu à partir d'un XmlReader

Lorsque vous devez traiter de grands fichiers XML, il peut être impossible de charger l'intégralité de l'arborescence XML en mémoire.Cette rubrique montre comment diffuser des fragments en continu à l'aide d'un objet XmlReader.

L'une des manières les plus efficaces d'utiliser un objet XmlReader pour lire des objets XElement consiste à écrire votre propre méthode d'axe personnalisée.Une méthode d'axe retourne généralement une collection telle que IEnumerable<T> de XElement, comme illustré dans l'exemple de cette rubrique.Dans la méthode d'axe personnalisée, après avoir créé le fragment XML en appelant la méthode ReadFrom, retournez la collection à l'aide de yield return.Cela fournit une sémantique d'exécution différée à votre méthode d'axe personnalisée.

Lorsque vous créez une arborescence XML à partir d'un objet XmlReader, l'objet XmlReader doit être positionné sur un élément.La méthode ReadFrom ne retourne que lorsqu'elle a lu la balise de fermeture de l'élément.

Si vous souhaitez créer une arborescence partielle, vous pouvez instancier un objet XmlReader, positionner le lecteur sur le nœud que vous souhaitez convertir en une arborescence XElement, puis créer l'objet XElement.

La rubrique Procédure : diffuser des fragments XML en continu avec accès aux informations d'en-tête contient des informations et un exemple sur la façon de diffuser en continu un document plus complexe.

La rubrique Procédure : effectuer une transformation de diffusion en continu de documents XML volumineux contient un exemple d'utilisation de LINQ to XML pour transformer des documents XML extrêmement volumineux tout en maintenant un faible encombrement mémoire.

Exemple

Cet exemple crée une méthode d'axe personnalisée.Vous pouvez l'interroger à l'aide d'une requête LINQ. La méthode d'axe personnalisée, StreamRootChildDoc, est une méthode conçue spécifiquement pour lire un document qui possède un élément Child à répétition.

[!REMARQUE]

L'exemple suivant utilise la construction yield return de C#.Un code équivalent est fourni dans Visual Basic à l'aide d'une classe qui implémente l'interface IEnumerable(Of XElement).Pour obtenir un exemple d'une implémentation IEnumerable(Of T) dans Visual Basic, consultez Procédure pas à pas : implémentation d'IEnumerable(Of T) en Visual Basic.

static IEnumerable<XElement> StreamRootChildDoc(StringReader stringReader)
{
    using (XmlReader reader = XmlReader.Create(stringReader))
    {
        reader.MoveToContent();
        // Parse the file and display each of the nodes.
        while (reader.Read())
        {
            switch (reader.NodeType)
            {
                case XmlNodeType.Element:
                    if (reader.Name == "Child") {
                        XElement el = XElement.ReadFrom(reader) as XElement;
                        if (el != null)
                            yield return el;
                    }
                    break;
            }
        }
    }
}

static void Main(string[] args)
{
    string markup = @"<Root>
      <Child Key=""01"">
        <GrandChild>aaa</GrandChild>
      </Child>
      <Child Key=""02"">
        <GrandChild>bbb</GrandChild>
      </Child>
      <Child Key=""03"">
        <GrandChild>ccc</GrandChild>
      </Child>
    </Root>";

    IEnumerable<string> grandChildData =
        from el in StreamRootChildDoc(new StringReader(markup))
        where (int)el.Attribute("Key") > 1
        select (string)el.Element("GrandChild");

    foreach (string str in grandChildData) {
        Console.WriteLine(str);
    }
}
Module Module1
    Sub Main()
        Dim markup = "<Root>" &
                     "  <Child Key=""01"">" &
                     "    <GrandChild>aaa</GrandChild>" &
                     "  </Child>" &
                     "  <Child Key=""02"">" &
                     "    <GrandChild>bbb</GrandChild>" &
                     "  </Child>" &
                     "  <Child Key=""03"">" &
                     "    <GrandChild>ccc</GrandChild>" &
                     "  </Child>" &
                     "</Root>"

        Dim grandChildData =
             From el In New StreamRootChildDoc(New IO.StringReader(markup))
             Where CInt(el.@Key) > 1
             Select el.<GrandChild>.Value

        For Each s In grandChildData
            Console.WriteLine(s)
        Next
    End Sub
End Module

Public Class StreamRootChildDoc
    Implements IEnumerable(Of XElement)

    Private _stringReader As IO.StringReader

    Public Sub New(ByVal stringReader As IO.StringReader)
        _stringReader = stringReader
    End Sub

    Public Function GetEnumerator() As IEnumerator(Of XElement) Implements IEnumerable(Of XElement).GetEnumerator
        Return New StreamChildEnumerator(_stringReader)
    End Function

    Public Function GetEnumerator1() As IEnumerator Implements IEnumerable.GetEnumerator
        Return Me.GetEnumerator()
    End Function
End Class

Public Class StreamChildEnumerator
    Implements IEnumerator(Of XElement)

    Private _current As XElement
    Private _reader As Xml.XmlReader
    Private _stringReader As IO.StringReader

    Public Sub New(ByVal stringReader As IO.StringReader)
        _stringReader = stringReader
        _reader = Xml.XmlReader.Create(_stringReader)
        _reader.MoveToContent()
    End Sub

    Public ReadOnly Property Current As XElement Implements IEnumerator(Of XElement).Current
        Get
            Return _current
        End Get
    End Property

    Public ReadOnly Property Current1 As Object Implements IEnumerator.Current
        Get
            Return Me.Current
        End Get
    End Property

    Public Function MoveNext() As Boolean Implements IEnumerator.MoveNext
        While _reader.Read()
            Select Case _reader.NodeType
                Case Xml.XmlNodeType.Element
                    Dim el = TryCast(XElement.ReadFrom(_reader), XElement)
                    If el IsNot Nothing Then
                        _current = el
                        Return True
                    End If
            End Select
        End While

        Return False
    End Function

    Public Sub Reset() Implements IEnumerator.Reset
        _reader = Xml.XmlReader.Create(_stringReader)
        _reader.MoveToContent()
    End Sub

#Region "IDisposable Support"
    Private disposedValue As Boolean ' To detect redundant calls

    ' IDisposable
    Protected Overridable Sub Dispose(ByVal disposing As Boolean)
        If Not Me.disposedValue Then
            If disposing Then
                _reader.Close()
            End If
        End If
        Me.disposedValue = True
    End Sub

    Public Sub Dispose() Implements IDisposable.Dispose
        Dispose(True)
        GC.SuppressFinalize(Me)
    End Sub
#End Region

End Class

Cet exemple produit la sortie suivante :

bbb
ccc

Dans cet exemple, le document source est très petit.Toutefois, cet exemple aurait un faible encombrement mémoire même s'il y avait des millions d'éléments Child.

Voir aussi

Concepts

Analyse de code XML