XNode.ReadFrom(XmlReader) Método

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

Parámetros

Devoluciones

Objeto XNode que contiene el nodo y sus nodos descendientes que se leyeron desde el lector. El tipo de nodo (NodeType) del primer nodo situado en el lector determina el tipo del nodo en tiempo de ejecución.

Excepciones

Ejemplos

En este ejemplo se usa el siguiente archivo XML, denominado 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>

En el ejemplo siguiente se crea un método de eje personalizado que usa ReadFrom y, a continuación, consulta el eje personalizado mediante una consulta 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

Este ejemplo produce el siguiente resultado:

bbb  
ccc  

Comentarios

Puede usar este método para escribir un método que devuelva una colección de nodos, lo que produce cada nodo a medida que se lee el nodo del lector. Este método permite procesar archivos XML de gran tamaño arbitrariamente con una superficie de memoria muy pequeña.

El lector que se pasa a este método podría producir excepciones. ReadFrom no detecta todas las excepciones producidas por el lector; Las excepciones no controladas se propagan hasta el código que llamó a ReadFrom. En concreto, el código debe estar preparado para controlar XmlException.

Para obtener un ejemplo de cómo transmitir un documento más complejo, vea Cómo transmitir fragmentos XML con acceso a la información de encabezado.

Ciertos operadores de consulta estándar, como OrderBy, recorren en iteración su origen, recaban todos los datos, los ordenan y finalmente producen el primer elemento de la secuencia. Si utiliza un operador de consulta que materializa su origen antes de producir el primer elemento, no retendrá una superficie de memoria pequeña.

Para obtener un ejemplo de uso de LINQ to XML para transformar documentos XML extremadamente grandes al tiempo que se mantiene una superficie de memoria pequeña, vea Cómo realizar la transformación de streaming de documentos XML grandes.

Se aplica a

Consulte también

• Información general de LINQ to XML