XDocument.Load Método

Definición

Espacio de nombres:

System.Xml.Linq

Ensamblado:

System.Xml.XDocument.dll

Ensamblado:

System.Xml.Linq.dll

Ensamblado:

netstandard.dll

Crea un nuevo XDocument a partir de un archivo especificado por un URI, de un TextReader, o de un XmlReader.

Sobrecargas

Load(Stream)	Crea una nueva instancia de XDocument usando la secuencia especificada.
Load(TextReader)	Crea una nueva clase de XDocument a partir de TextReader.
Load(String)	Crea un nuevo XDocument a partir de un archivo.
Load(XmlReader)	Crea un nuevo XDocument a partir de un XmlReader.
Load(Stream, LoadOptions)	Crea una nueva instancia de XDocument usando la secuencia especificada y, de forma opcional, conservando el espacio en blanco, estableciendo el identificador URI base y conservando la información de línea.
Load(TextReader, LoadOptions)	Crea un nuevo XDocument a partir de un TextReader y, de manera opcional, conserva el espacio en blanco, establece el URI base y retiene la información de línea.
Load(String, LoadOptions)	Crea un nuevo XDocument a partir de un archivo y, de manera opcional, conserva el espacio en blanco, establece el URI base y retiene la información de línea.
Load(XmlReader, LoadOptions)	Carga un XDocument desde un XmlReader y, de manera opcional, se establece el URI base y se retiene la información de línea.

Comentarios

Con una de las sobrecargas de este método, puede cargar un XDocument desde un archivo, un TextReader, o .XmlReader

Para crear un a XDocument partir de una cadena que contiene XML, use Parse.

Load(Stream)

Crea una nueva instancia de XDocument usando la secuencia especificada.

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

Flujo que contiene los datos XML.

Devoluciones

XDocument

Objeto XDocument que lee los datos contenidos en la secuencia.

Comentarios

Si desea controlar las opciones de carga, use la Load sobrecarga que toma LoadOptions como parámetro.

La funcionalidad de carga de LINQ to XML se basa en XmlReader. Por lo tanto, puede detectar las excepciones producidas por los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.

Si tiene que modificar XmlReaderSettings, siga estos pasos:

1. Cree un XmlReader mediante una llamada a una de las Create sobrecargas que toman XmlReaderSettings como parámetro.

2. XmlReader Pase a una de las Load sobrecargas de XDocument que toma XmlReader como parámetro.

Load(TextReader)

Crea una nueva clase de XDocument a partir de 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

Objeto TextReader que incluye el contenido del XDocument.

Devoluciones

XDocument

XDocument con el contenido del TextReader especificado.

Ejemplos

En el ejemplo siguiente se crea un documento a partir de .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)  

Este ejemplo produce el siguiente resultado:

<Root>Content</Root>  

Comentarios

la funcionalidad de carga de LINQ to XML se basa en XmlReader. Por lo tanto, puede detectar las excepciones producidas por los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.

Consulte también

• Parse
• Save
• WriteTo(XmlWriter)
• Información general de LINQ to XML
• Diferencias entre consultar un elemento XDocument y consultar un elemento XElement

Load(String)

Crea un nuevo XDocument a partir de un archivo.

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

Cadena URI que hace referencia al archivo que se va a cargar en un nuevo XDocument.

Devoluciones

XDocument

XDocument con el contenido del archivo especificado.

Ejemplos

En el ejemplo siguiente se muestra cómo cargar un XDocument desde un archivo.

Este ejemplo utiliza el siguiente documento XML:

Archivo XML de ejemplo: Pedido de compra común (LINQ to XML)

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

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

Este ejemplo produce el siguiente resultado:

<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>  

Comentarios

Este método usa un subyacente XmlReader para leer el XML en un árbol XML.

Use Parse para crear un XDocument objeto a partir de una cadena que contenga XML.

la funcionalidad de carga de LINQ to XML se basa en XmlReader. Por lo tanto, puede detectar las excepciones producidas por los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.

Consulte también

• Parse
• Save
• WriteTo(XmlWriter)
• Información general de LINQ to XML
• Diferencias entre consultar un elemento XDocument y consultar un elemento XElement

Load(XmlReader)

Crea un nuevo XDocument a partir de un 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

Objeto XmlReader que incluye el contenido del XDocument.

Devoluciones

XDocument

XDocument con el contenido del XmlReader especificado.

Ejemplos

En el ejemplo siguiente se crea un documento DOM, se crea un XmlNodeReader objeto a partir del documento DOM, se XmlNodeReadercrea mediante XDocument .

// 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  

Este ejemplo produce el siguiente resultado:

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

Comentarios

Un posible uso de este método es crear una copia de un documento DOM en un árbol de LINQ to XML. Para ello, cree un XmlNodeReader a partir de un documento DOM y, a continuación, use para XmlNodeReader crear un XDocument.

la funcionalidad de carga de LINQ to XML se basa en XmlReader. Por lo tanto, puede detectar las excepciones producidas por los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.

Consulte también

• Parse
• Save
• WriteTo(XmlWriter)
• Información general de LINQ to XML
• Diferencias entre consultar un elemento XDocument y consultar un elemento XElement

Load(Stream, LoadOptions)

Crea una nueva instancia de XDocument usando la secuencia especificada y, de forma opcional, conservando el espacio en blanco, estableciendo el identificador URI base y conservando la información de línea.

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

Flujo que contiene los datos XML.

options

LoadOptions

LoadOptions que especifica si se va a cargar el URI base y la información de la línea.

Devoluciones

XDocument

Objeto XDocument que lee los datos contenidos en la secuencia.

Comentarios

La funcionalidad de carga de LINQ to XML se basa en XmlReader. Por lo tanto, puede detectar las excepciones producidas por los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.

Si tiene que modificar XmlReaderSettings, siga estos pasos:

1. Cree un XmlReader mediante una llamada a una de las Create sobrecargas que toma XmlReaderSettings como parámetro.

2. Pase a XmlReader una de las Load sobrecargas de XDocument que toma XmlReader como parámetro.

Load(TextReader, LoadOptions)

Crea un nuevo XDocument a partir de un TextReader y, de manera opcional, conserva el espacio en blanco, establece el URI base y retiene la información de línea.

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

Objeto TextReader que incluye el contenido del XDocument.

options

LoadOptions

LoadOptions que especifica el comportamiento de los espacios en blanco y si se carga la información del URI base y de la línea base.

Devoluciones

XDocument

XDocument que contiene el XML que se leyó desde el objeto TextReader especificado.

Ejemplos

En el ejemplo siguiente se crea un documento a partir de .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)  

Este ejemplo produce el siguiente resultado:

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

Comentarios

Si el XML de origen está en sangría, establecer la PreserveWhitespace marca en options hace que el lector lea todo el espacio en blanco en el XML de origen. Los nodos de tipo XText se crean para espacios en blanco significativos e insignificantes.

Si se aplica sangría al XML de origen, no establecer la PreserveWhitespace marca en options hace que el lector omita todos los espacios en blanco insignificantes en el XML de origen. El árbol XML se crea sin nodos de texto para espacios en blanco insignificantes.

Si el XML de origen no tiene sangría, establecer la PreserveWhitespace marca en options no tiene ningún efecto. Todavía se conserva un espacio en blanco significativo y no hay intervalos de espacios en blanco insignificantes que podrían provocar la creación de más nodos de texto de espacio en blanco.

Para obtener más información, vea Conservar el espacio en blanco al cargar o analizar XML y Conservar el espacio en blanco durante la serialización.

Use Parse para crear un XElement objeto a partir de una cadena que contenga XML.

La configuración SetBaseUri no es válida al cargar desde .TextReader

Hay una penalización de rendimiento si establece la SetLineInfo marca.

La información de línea es precisa inmediatamente después de cargar el documento XML. Si modifica el árbol XML después de cargar el documento, es posible que la información de línea no tenga sentido.

la funcionalidad de carga de LINQ to XML se basa en XmlReader. Por lo tanto, puede detectar las excepciones producidas por los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.

Consulte también

• Parse
• Save
• WriteTo(XmlWriter)
• Información general de LINQ to XML
• Diferencias entre consultar un elemento XDocument y consultar un elemento XElement

Load(String, LoadOptions)

Crea un nuevo XDocument a partir de un archivo y, de manera opcional, conserva el espacio en blanco, establece el URI base y retiene la información de línea.

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

Cadena URI que hace referencia al archivo que se va a cargar en un nuevo XDocument.

options

LoadOptions

LoadOptions que especifica el comportamiento de los espacios en blanco y si se carga la información del URI base y de la línea base.

Devoluciones

XDocument

XDocument con el contenido del archivo especificado.

Ejemplos

En el ejemplo siguiente se muestra cómo cargar un XDocument desde un archivo.

Este ejemplo utiliza el siguiente documento XML:

Archivo XML de ejemplo: Pedido de compra común (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())  

Este ejemplo produce el siguiente resultado:

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

Comentarios

Si el XML de origen está en sangría, establecer la PreserveWhitespace marca en options hace que el lector lea todo el espacio en blanco en el XML de origen. Los nodos de tipo XText se crean para espacios en blanco significativos e insignificantes.

Si se aplica sangría al XML de origen, no establecer la PreserveWhitespace marca en options hace que el lector omita todos los espacios en blanco insignificantes en el XML de origen. El árbol XML se crea sin nodos de texto para espacios en blanco insignificantes.

Si el XML de origen no tiene sangría, establecer la PreserveWhitespace marca en options no tiene ningún efecto. Todavía se conserva un espacio en blanco significativo y no hay intervalos de espacios en blanco insignificantes que podrían provocar la creación de más nodos de texto de espacio en blanco.

Para obtener más información, vea Conservar el espacio en blanco al cargar o analizar XML y Conservar el espacio en blanco durante la serialización.

Use Parse para crear un XDocument objeto a partir de una cadena que contenga XML.

Hay una penalización de rendimiento si establece las SetBaseUri marcas y SetLineInfo .

El URI base y la información de línea son precisos inmediatamente después de cargar el documento XML. Si modifica el árbol XML después de cargar el documento, el URI base y la información de línea pueden no tener sentido.

la funcionalidad de carga de LINQ to XML se basa en XmlReader. Por lo tanto, puede detectar las excepciones producidas por los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.

Consulte también

• Parse
• Save
• WriteTo(XmlWriter)
• Información general de LINQ to XML
• Diferencias entre consultar un elemento XDocument y consultar un elemento XElement

Load(XmlReader, LoadOptions)

Carga un XDocument desde un XmlReader y, de manera opcional, se establece el URI base y se retiene la información de línea.

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

XmlReader que se leerá para obtener el contenido del XDocument.

options

LoadOptions

LoadOptions que especifica si se va a cargar el URI base y la información de la línea.

Devoluciones

XDocument

XDocument que contiene el XML que se leyó desde el objeto XmlReader especificado.

Ejemplos

En el ejemplo siguiente se carga la información de línea que carga desde .XmlReader A continuación, imprime la información de línea.

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  

Este ejemplo produce el siguiente resultado:

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

Comentarios

Al crear un XmlNodeReader a partir de un documento DOM y, a continuación, usar para XmlNodeReader crear un XElement, este método se puede usar para crear una copia de un documento DOM en un árbol de LINQ to XML.

Use Parse para crear un XDocument objeto a partir de una cadena que contenga XML.

La configuración PreserveWhitespace no es válida al cargar desde .XmlReader XmlReader se configurará para leer espacios en blanco o no. El árbol de LINQ to XML se rellenará con los nodos de espacio en blanco que el lector expone. Este será el comportamiento independientemente de si PreserveWhitespace está establecido o no.

XmlReader puede tener un URI base válido o no. Si establece SetBaseUri, el URI base se establecerá en el árbol XML del URI base notificado por .XmlReader

XmlReader puede tener una información de línea válida o no. Si establece SetLineInfo, la información de línea se establecerá en el árbol XML de la información de línea notificada por .XmlReader

Hay una penalización de rendimiento si establece la SetLineInfo marca.

La información de línea es precisa inmediatamente después de cargar el documento XML. Si modifica el árbol XML después de cargar el documento, es posible que la información de línea no tenga sentido.

la funcionalidad de carga de LINQ to XML se basa en XmlReader. Por lo tanto, puede detectar las excepciones producidas por los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.

Consulte también

• WriteTo(XmlWriter)
• Save
• Parse
• Información general de LINQ to XML
• Procedimiento para leer y escribir un documento codificado