XNode.ReadFrom(XmlReader) Method

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

Parameters

Returns

An XNode that contains the node and its descendant nodes that were read from the reader. The runtime type of the node is determined by the node type (NodeType) of the first node encountered in the reader.

Exceptions

Examples

This example uses the following XML file, named 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>

The following example creates a custom axis method that uses ReadFrom and then queries the custom axis by using a LINQ query:

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

This example produces the following output:

bbb
ccc

Remarks

You can use this method to write a method that returns a collection of nodes, yielding each node as the node is read from the reader. This method enables you to process arbitrarily large XML files with a very small memory footprint.

The reader that you pass to this method might throw exceptions. ReadFrom does not catch all exceptions thrown by the reader; the unhandled exceptions bubble up to the code that called ReadFrom. In particular, your code should be prepared to handle XmlException.

For an example of how to stream a more complex document, see How to stream XML fragments with access to header information.

Certain standard query operators, such as OrderBy, iterate their source, collect all of the data, sort it, and then finally yield the first item in the sequence. If you use a query operator that materializes its source before yielding the first item, you will not retain a small memory footprint.

For an example of using LINQ to XML to transform extremely large XML documents while maintaining a small memory footprint, see How to perform streaming transform of large XML documents.

See also

• LINQ to XML overview