XDocument.Load Método

Definição

Namespace:

System.Xml.Linq

Assembly:

System.Xml.XDocument.dll

Assembly:

System.Xml.Linq.dll

Assembly:

netstandard.dll

Cria um novo XDocument de um arquivo especificado por um URI com base em um TextReader ou um XmlReader.

Sobrecargas

Load(Stream)	Cria uma nova instância XDocument usando o fluxo especificado.
Load(TextReader)	Cria um novo XDocument com base em um TextReader.
Load(String)	Cria um novo XDocument com base em um arquivo.
Load(XmlReader)	Cria um novo XDocument com base em um XmlReader.
Load(Stream, LoadOptions)	Cria uma nova instância de XDocument usando o fluxo especificado, com a opção de preservar espaços em branco, definir o URI base e reter informações de linha.
Load(TextReader, LoadOptions)	Cria um novo XDocument de um TextReader, opcionalmente preservando espaços em branco, configurando o URI base e retendo informações de linha.
Load(String, LoadOptions)	Cria um novo XDocument com base em um arquivo, opcionalmente, preservando os espaços em branco, definindo o URI base e retendo as informações de linha.
Load(XmlReader, LoadOptions)	Carrega um XDocument de um XmlReader, configurando opcionalmente o URI de base e retendo informações de linha.

Comentários

Usando uma das sobrecargas desse método, você pode carregar um XDocument de um arquivo, um TextReaderou um XmlReader.

Para criar uma cadeia XDocument de caracteres que contém XML, use Parse.

Load(Stream)

Cria uma nova instância XDocument usando o fluxo especificado.

public:
 static System::Xml::Linq::XDocument ^ Load(System::IO::Stream ^ stream);

public static System.Xml.Linq.XDocument Load (System.IO.Stream stream);

static member Load : System.IO.Stream -> System.Xml.Linq.XDocument

Public Shared Function Load (stream As Stream) As XDocument

Parâmetros

stream

Stream

O fluxo que contém os dados XML.

Retornos

XDocument

Um objeto XDocument que lê os dados contidos em um fluxo.

Comentários

Se você quiser controlar as opções de carga, use a Load sobrecarga que usa LoadOptions como parâmetro.

A funcionalidade de carregamento de LINQ to XML é criada em .XmlReader Portanto, você pode capturar quaisquer exceções geradas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Se você precisar modificar XmlReaderSettings, siga estas etapas:

1. Crie um XmlReader chamando uma das Create sobrecargas que tomam XmlReaderSettings como parâmetro.

2. Passe para XmlReader uma das Load sobrecargas que XDocument leva XmlReader como um parâmetro.

Load(TextReader)

Cria um novo XDocument com base em um TextReader.

public:
 static System::Xml::Linq::XDocument ^ Load(System::IO::TextReader ^ textReader);

public static System.Xml.Linq.XDocument Load (System.IO.TextReader textReader);

static member Load : System.IO.TextReader -> System.Xml.Linq.XDocument

Public Shared Function Load (textReader As TextReader) As XDocument

Parâmetros

textReader

TextReader

Um TextReader que contém o conteúdo do XDocument.

Retornos

XDocument

Um XDocument que contém o conteúdo do TextReader especificado.

Exemplos

O exemplo a seguir cria um documento de um StringReader.

TextReader tr = new StringReader("<Root>Content</Root>");  
XDocument doc = XDocument.Load(tr);  
Console.WriteLine(doc);  

Dim tr As TextReader = New StringReader("<Root>Content</Root>")  
Dim doc As XDocument = XDocument.Load(tr)  
Console.WriteLine(doc)  

Esse exemplo gera a saída a seguir:

<Root>Content</Root>  

Comentários

A funcionalidade de carregamento do LINQ to XML é criada.XmlReader Portanto, você pode capturar quaisquer exceções geradas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Confira também

• Parse
• Save
• WriteTo(XmlWriter)
• Visão geral do LINQ to XML
• Consultar um XDocument versus consultar um XElement

Load(String)

Cria um novo XDocument com base em um arquivo.

public:
 static System::Xml::Linq::XDocument ^ Load(System::String ^ uri);

public static System.Xml.Linq.XDocument Load (string uri);

static member Load : string -> System.Xml.Linq.XDocument

Public Shared Function Load (uri As String) As XDocument

Parâmetros

uri

String

Uma cadeia de caracteres do URI que faz referência ao arquivo a ser carregado em um novo XDocument.

Retornos

XDocument

Um XDocument que contém o conteúdo do arquivo especificado.

Exemplos

O exemplo a seguir mostra como carregar um XDocument de um arquivo.

Este exemplo usa o seguinte documento XML:

Arquivo XML de exemplo: Ordem de compra típica (LINQ to XML)

XDocument doc = XDocument.Load("PurchaseOrder.xml");  
Console.WriteLine(doc);  

Dim doc As XDocument = XDocument.Load("PurchaseOrder.xml")  
Console.WriteLine(doc)  

Esse exemplo gera a saída a seguir:

<PurchaseOrder PurchaseOrderNumber="99503" OrderDate="1999-10-20">  
  <Address Type="Shipping">  
    <Name>Ellen Adams</Name>  
    <Street>123 Maple Street</Street>  
    <City>Mill Valley</City>  
    <State>CA</State>  
    <Zip>10999</Zip>  
    <Country>USA</Country>  
  </Address>  
  <Address Type="Billing">  
    <Name>Tai Yee</Name>  
    <Street>8 Oak Avenue</Street>  
    <City>Old Town</City>  
    <State>PA</State>  
    <Zip>95819</Zip>  
    <Country>USA</Country>  
  </Address>  
  <DeliveryNotes>Please leave packages in shed by driveway.</DeliveryNotes>  
  <Items>  
    <Item PartNumber="872-AA">  
      <ProductName>Lawnmower</ProductName>  
      <Quantity>1</Quantity>  
      <USPrice>148.95</USPrice>  
      <Comment>Confirm this is electric</Comment>  
    </Item>  
    <Item PartNumber="926-AA">  
      <ProductName>Baby Monitor</ProductName>  
      <Quantity>2</Quantity>  
      <USPrice>39.98</USPrice>  
      <ShipDate>1999-05-21</ShipDate>  
    </Item>  
  </Items>  
</PurchaseOrder>  

Comentários

Esse método usa um subjacente XmlReader para ler o XML em uma árvore XML.

Use Parse para criar uma cadeia XDocument de caracteres que contém XML.

A funcionalidade de carregamento do LINQ to XML é criada.XmlReader Portanto, você pode capturar quaisquer exceções geradas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Confira também

• Parse
• Save
• WriteTo(XmlWriter)
• Visão geral do LINQ to XML
• Consultar um XDocument versus consultar um XElement

Load(XmlReader)

Cria um novo XDocument com base em um XmlReader.

public:
 static System::Xml::Linq::XDocument ^ Load(System::Xml::XmlReader ^ reader);

public static System.Xml.Linq.XDocument Load (System.Xml.XmlReader reader);

static member Load : System.Xml.XmlReader -> System.Xml.Linq.XDocument

Public Shared Function Load (reader As XmlReader) As XDocument

Parâmetros

reader

XmlReader

Um XmlReader que contém o conteúdo do XDocument.

Retornos

XDocument

Um XDocument que contém o conteúdo do XmlReader especificado.

Exemplos

O exemplo a seguir cria um documento DOM, cria um XmlNodeReader documento do DOM e cria um XDocument uso do XmlNodeReader.

// Create a DOM document with some content.  
XmlDocument doc = new XmlDocument();  
XmlElement child = doc.CreateElement("Child");  
child.InnerText = "child contents";  
XmlElement root = doc.CreateElement("Root");  
root.AppendChild(child);  
doc.AppendChild(root);  

// create a reader and move to the content  
using (XmlNodeReader nodeReader = new XmlNodeReader(doc)) {  
    // the reader must be in the Interactive state in order to  
    // create a LINQ to XML tree from it.  
    nodeReader.MoveToContent();  

    XDocument xRoot = XDocument.Load(nodeReader);  
    Console.WriteLine(xRoot);  
}  

' Create a DOM document with some content.  
Dim doc As XmlDocument = New XmlDocument()  
Dim child As XmlElement = doc.CreateElement("Child")  
child.InnerText = "child contents"  
Dim root As XmlElement = doc.CreateElement("Root")  
root.AppendChild(child)  
doc.AppendChild(root)  

' create a reader and move to the content  
Using nodeReader = New XmlNodeReader(doc)  
    ' the reader must be in the Interactive state in order to  
    ' create a LINQ to XML tree from it.  
    nodeReader.MoveToContent()  

    Dim xRoot As XDocument = XDocument.Load(nodeReader)  
    Console.WriteLine(xRoot)  
End Using  

Esse exemplo gera a saída a seguir:

<Root>  
  <Child>child contents</Child>  
</Root>  

Comentários

Um possível uso para esse método é criar uma cópia de um documento DOM em uma árvore LINQ to XML. Para fazer isso, crie um XmlNodeReader documento do DOM e use-o XmlNodeReader para criar um XDocument.

A funcionalidade de carregamento do LINQ to XML é criada.XmlReader Portanto, você pode capturar quaisquer exceções geradas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Confira também

• Parse
• Save
• WriteTo(XmlWriter)
• Visão geral do LINQ to XML
• Consultar um XDocument versus consultar um XElement

Load(Stream, LoadOptions)

Cria uma nova instância de XDocument usando o fluxo especificado, com a opção de preservar espaços em branco, definir o URI base e reter informações de linha.

public:
 static System::Xml::Linq::XDocument ^ Load(System::IO::Stream ^ stream, System::Xml::Linq::LoadOptions options);

public static System.Xml.Linq.XDocument Load (System.IO.Stream stream, System.Xml.Linq.LoadOptions options);

static member Load : System.IO.Stream * System.Xml.Linq.LoadOptions -> System.Xml.Linq.XDocument

Public Shared Function Load (stream As Stream, options As LoadOptions) As XDocument

Parâmetros

stream

Stream

O fluxo que contém os dados XML.

options

LoadOptions

Um LoadOptions que especifica se informações de linha e URI base devem ser carregadas.

Retornos

XDocument

Um objeto XDocument que lê os dados contidos em um fluxo.

Comentários

A funcionalidade de carregamento de LINQ to XML é criada em .XmlReader Portanto, você pode capturar quaisquer exceções geradas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Se você precisar modificar XmlReaderSettings, siga estas etapas:

1. Crie uma XmlReader chamando uma das Create sobrecargas que usa XmlReaderSettings como parâmetro.

2. Passe para XmlReader uma das Load sobrecargas que XDocument leva XmlReader como um parâmetro.

Load(TextReader, LoadOptions)

Cria um novo XDocument de um TextReader, opcionalmente preservando espaços em branco, configurando o URI base e retendo informações de linha.

public:
 static System::Xml::Linq::XDocument ^ Load(System::IO::TextReader ^ textReader, System::Xml::Linq::LoadOptions options);

public static System.Xml.Linq.XDocument Load (System.IO.TextReader textReader, System.Xml.Linq.LoadOptions options);

static member Load : System.IO.TextReader * System.Xml.Linq.LoadOptions -> System.Xml.Linq.XDocument

Public Shared Function Load (textReader As TextReader, options As LoadOptions) As XDocument

Parâmetros

textReader

TextReader

Um TextReader que contém o conteúdo do XDocument.

options

LoadOptions

LoadOptions que especificam o comportamento de espaço em branco e se serão carregadas as informações de linha e o URI base.

Retornos

XDocument

Um XDocument que contém o XML que foi lido do TextReader especificado.

Exemplos

O exemplo a seguir cria um documento de um StringReader.

TextReader sr;  
int whiteSpaceNodes;  

sr = new StringReader("<Root> <Child> </Child> </Root>");  
XDocument xmlTree1 = XDocument.Load(sr, LoadOptions.None);  
sr.Close();  
whiteSpaceNodes = xmlTree1  
    .Element("Root")  
    .DescendantNodesAndSelf()  
    .OfType<XText>()  
    .Where(tNode => tNode.ToString().Trim().Length == 0)  
    .Count();  
Console.WriteLine("Count of white space nodes (not preserving whitespace): {0}", whiteSpaceNodes);  

sr = new StringReader("<Root> <Child> </Child> </Root>");  
XDocument xmlTree2 = XDocument.Load(sr, LoadOptions.PreserveWhitespace);  
sr.Close();  
whiteSpaceNodes = xmlTree2  
    .Element("Root")  
    .DescendantNodesAndSelf()  
    .OfType<XText>()  
    .Where(tNode => tNode.ToString().Trim().Length == 0)  
    .Count();  
Console.WriteLine("Count of white space nodes (preserving whitespace): {0}", whiteSpaceNodes);  

Dim sr As TextReader  
Dim whiteSpaceNodes As Integer  

sr = New StringReader("<Root> <Child> </Child> </Root>")  
Dim xmlTree1 As XDocument = XDocument.Load(sr, LoadOptions.None)  
sr.Close()  
whiteSpaceNodes = xmlTree1 _  
              .Element("Root") _  
              .DescendantNodesAndSelf() _  
              .OfType(Of XText)() _  
              .Where(Function(ByVal tNode As XNode) tNode. _  
                  ToString().Trim().Length = 0).Count()  
Console.WriteLine("Count of white space nodes (not preserving whitespace): {0}", whiteSpaceNodes)  

sr = New StringReader("<Root> <Child> </Child> </Root>")  
Dim xmlTree2 As XDocument = XDocument.Load(sr, LoadOptions.PreserveWhitespace)  
sr.Close()  
whiteSpaceNodes = xmlTree2 _  
              .Element("Root") _  
              .DescendantNodesAndSelf() _  
              .OfType(Of XText)() _  
              .Where(Function(ByVal tNode As XNode) tNode. _  
                  ToString().Trim().Length = 0).Count()  
Console.WriteLine("Count of white space nodes (preserving whitespace): {0}", whiteSpaceNodes)  

Esse exemplo gera a saída a seguir:

Count of white space nodes (not preserving whitespace): 0  
Count of white space nodes (preserving whitespace): 3  

Comentários

Se o XML de origem estiver recuado, definir o PreserveWhitespace sinalizador options fará com que o leitor leia todo o espaço em branco no XML de origem. Nós de tipo XText são criados para espaço em branco significativo e insignificante.

Se o XML de origem estiver recuado, não definir o PreserveWhitespace sinalizador options fará com que o leitor ignore todo o espaço em branco insignificante no XML de origem. A árvore XML é criada sem nenhum nó de texto para espaço em branco insignificante.

Se o XML de origem não estiver recuado, a configuração do PreserveWhitespace sinalizador options não terá efeito. Espaço em branco significativo ainda é preservado, e não há intervalos de espaço em branco insignificante que possam causar a criação de mais nós de texto de espaço em branco.

Para obter mais informações, consulte Preservar espaço em branco ao carregar ou analisar XML e Preservar espaço em branco durante a serialização.

Use Parse para criar uma cadeia XElement de caracteres que contém XML.

A configuração SetBaseUri não é válida ao carregar de um TextReader.

Haverá uma penalidade de desempenho se você definir o SetLineInfo sinalizador.

As informações de linha são precisas imediatamente após o carregamento do documento XML. Se você modificar a árvore XML depois de carregar o documento, as informações de linha poderão se tornar sem sentido.

A funcionalidade de carregamento do LINQ to XML é criada.XmlReader Portanto, você pode capturar quaisquer exceções geradas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Confira também

• Parse
• Save
• WriteTo(XmlWriter)
• Visão geral do LINQ to XML
• Consultar um XDocument versus consultar um XElement

Load(String, LoadOptions)

Cria um novo XDocument com base em um arquivo, opcionalmente, preservando os espaços em branco, definindo o URI base e retendo as informações de linha.

public:
 static System::Xml::Linq::XDocument ^ Load(System::String ^ uri, System::Xml::Linq::LoadOptions options);

public static System.Xml.Linq.XDocument Load (string uri, System.Xml.Linq.LoadOptions options);

static member Load : string * System.Xml.Linq.LoadOptions -> System.Xml.Linq.XDocument

Public Shared Function Load (uri As String, options As LoadOptions) As XDocument

Parâmetros

uri

String

Uma cadeia de caracteres do URI que faz referência ao arquivo a ser carregado em um novo XDocument.

options

LoadOptions

LoadOptions que especificam o comportamento de espaço em branco e se serão carregadas as informações de linha e o URI base.

Retornos

XDocument

Um XDocument que contém o conteúdo do arquivo especificado.

Exemplos

O exemplo a seguir mostra como carregar um XDocument de um arquivo.

Este exemplo usa o seguinte documento XML:

Arquivo XML de exemplo: Ordem de compra típica (LINQ to XML)

XDocument doc1 = XDocument.Load("PurchaseOrder.xml", LoadOptions.None);  
Console.WriteLine("nodes if not preserving whitespace: {0}", doc1.DescendantNodes().Count());  

XDocument doc2 = XDocument.Load("PurchaseOrder.xml", LoadOptions.PreserveWhitespace);  
Console.WriteLine("nodes if preserving whitespace: {0}", doc2.DescendantNodes().Count());  

Dim doc1 As XDocument = XDocument.Load("PurchaseOrder.xml", LoadOptions.None)  
Console.WriteLine("nodes if not preserving whitespace: {0}", doc1.DescendantNodes().Count())  

Dim doc2 As XDocument = XDocument.Load("PurchaseOrder.xml", LoadOptions.PreserveWhitespace)  
Console.WriteLine("nodes if preserving whitespace: {0}", doc2.DescendantNodes().Count())  

Esse exemplo gera a saída a seguir:

nodes if not preserving whitespace: 48  
nodes if preserving whitespace: 82  

Comentários

Se o XML de origem estiver recuado, definir o PreserveWhitespace sinalizador options fará com que o leitor leia todo o espaço em branco no XML de origem. Nós de tipo XText são criados para espaço em branco significativo e insignificante.

Se o XML de origem estiver recuado, não definir o PreserveWhitespace sinalizador options fará com que o leitor ignore todo o espaço em branco insignificante no XML de origem. A árvore XML é criada sem nenhum nó de texto para espaço em branco insignificante.

Se o XML de origem não estiver recuado, a configuração do PreserveWhitespace sinalizador options não terá efeito. Espaço em branco significativo ainda é preservado, e não há intervalos de espaço em branco insignificante que possam causar a criação de mais nós de texto de espaço em branco.

Para obter mais informações, consulte Preservar espaço em branco ao carregar ou analisar XML e Preservar espaço em branco durante a serialização.

Use Parse para criar uma cadeia XDocument de caracteres que contém XML.

Haverá uma penalidade de desempenho se você definir o SetBaseUri e os SetLineInfo sinalizadores.

O URI base e as informações de linha são precisos imediatamente após o carregamento do documento XML. Se você modificar a árvore XML depois de carregar o documento, o URI base e as informações de linha poderão se tornar sem sentido.

A funcionalidade de carregamento do LINQ to XML é criada.XmlReader Portanto, você pode capturar quaisquer exceções geradas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Confira também

• Parse
• Save
• WriteTo(XmlWriter)
• Visão geral do LINQ to XML
• Consultar um XDocument versus consultar um XElement

Load(XmlReader, LoadOptions)

Carrega um XDocument de um XmlReader, configurando opcionalmente o URI de base e retendo informações de linha.

public:
 static System::Xml::Linq::XDocument ^ Load(System::Xml::XmlReader ^ reader, System::Xml::Linq::LoadOptions options);

public static System.Xml.Linq.XDocument Load (System.Xml.XmlReader reader, System.Xml.Linq.LoadOptions options);

static member Load : System.Xml.XmlReader * System.Xml.Linq.LoadOptions -> System.Xml.Linq.XDocument

Public Shared Function Load (reader As XmlReader, options As LoadOptions) As XDocument

Parâmetros

reader

XmlReader

Um XmlReader que será lido para o conteúdo do XDocument.

options

LoadOptions

Um LoadOptions que especifica se informações de linha e URI base devem ser carregadas.

Retornos

XDocument

Um XDocument que contém o XML que foi lido do XmlReader especificado.

Exemplos

O exemplo a seguir carrega as informações de linha que ele carrega do XmlReader. Em seguida, ele imprime as informações da linha.

string markup =  
@"<Root>  
    <Child>  
        <GrandChild/>  
    </Child>  
</Root>";  

// Create a reader and move to the content.  
using (XmlReader nodeReader = XmlReader.Create(new StringReader(markup)))  
{  
    // the reader must be in the Interactive state in order to  
    // Create a LINQ to XML tree from it.  
    nodeReader.MoveToContent();  

    XDocument xRoot = XDocument.Load(nodeReader, LoadOptions.SetLineInfo);  
    Console.WriteLine("{0}{1}{2}",  
        "Element Name".PadRight(20),  
        "Line".PadRight(5),  
        "Position");  
    Console.WriteLine("{0}{1}{2}",  
        "------------".PadRight(20),  
        "----".PadRight(5),  
        "--------");  
    foreach (XElement e in xRoot.Elements("Root").DescendantsAndSelf())  
        Console.WriteLine("{0}{1}{2}",  
            ("".PadRight(e.Ancestors().Count() * 2) + e.Name).PadRight(20),  
            ((IXmlLineInfo)e).LineNumber.ToString().PadRight(5),  
            ((IXmlLineInfo)e).LinePosition);  
}  

Dim markup As String = _  
    "<Root>" & Environment.NewLine & _  
    "    <Child>" & Environment.NewLine & _  
    "        <GrandChild/>" & Environment.NewLine & _  
    "    </Child>" & Environment.NewLine & _  
    "</Root>"  

' Create a reader and move to the content.  
Using nodeReader As XmlReader = XmlReader.Create(New StringReader(markup))  

    ' The reader must be in the Interactive state in order to  
    ' create a LINQ to XML tree from it.  
    nodeReader.MoveToContent()  

    Dim xRoot As XDocument = XDocument.Load(nodeReader, LoadOptions.SetLineInfo)  
    Console.WriteLine("{0}{1}{2}", _  
        "Element Name".PadRight(20), _  
        "Line".PadRight(5), _  
        "Position")  
    Console.WriteLine("{0}{1}{2}", _  
        "------------".PadRight(20), _  
        "----".PadRight(5), _  
        "--------")  
    For Each e As XElement In xRoot.Elements("Root").DescendantsAndSelf()  
        Console.WriteLine("{0}{1}{2}", _  
            ("".PadRight(e.Ancestors().Count() * 2) & e.Name.ToString()).PadRight(20), _  
            (DirectCast(e, IXmlLineInfo)).LineNumber.ToString().PadRight(5), _  
            (DirectCast(e, IXmlLineInfo)).LinePosition)  
    Next  
End Using  

Esse exemplo gera a saída a seguir:

Element Name        Line Position  
------------        ---- --------  
Root                1    2  
  Child             2    6  
    GrandChild      3    10  

Comentários

Criando um XmlNodeReader documento do DOM e, em seguida, usando o XmlNodeReader para criar um XElementmétodo, esse método pode ser usado para criar uma cópia de um documento DOM em uma árvore LINQ to XML.

Use Parse para criar uma cadeia XDocument de caracteres que contém XML.

A configuração PreserveWhitespace não é válida ao carregar de um XmlReader. O XmlReader será configurado para ler o espaço em branco ou não. A árvore LINQ to XML será preenchida com os nós de espaço em branco que o leitor superfícies. Esse será o comportamento, independentemente de estar PreserveWhitespace definido ou não.

Pode XmlReader ter um URI base válido ou não. Se você definir SetBaseUri, o URI base será definido na árvore XML do URI base relatado pelo XmlReader.

Pode XmlReader ter uma informação de linha válida ou não. Se você definir SetLineInfo, as informações de linha serão definidas na árvore XML a partir das informações de linha relatadas XmlReaderpelo .

Haverá uma penalidade de desempenho se você definir o SetLineInfo sinalizador.

As informações de linha são precisas imediatamente após o carregamento do documento XML. Se você modificar a árvore XML depois de carregar o documento, as informações de linha poderão se tornar sem sentido.

A funcionalidade de carregamento do LINQ to XML é criada.XmlReader Portanto, você pode capturar quaisquer exceções geradas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Confira também

• WriteTo(XmlWriter)
• Save
• Parse
• Visão geral do LINQ to XML
• Como ler e escrever um documento codificado