XElement.Load Método

Definición

Espacio de nombres:

System.Xml.Linq

Ensamblado:

System.Xml.XDocument.dll

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

Sobrecargas

Load(TextReader, LoadOptions)	Carga un XElement desde un objeto TextReader y, de manera opcional, conserva los espacios en blanco y retiene la información de línea.
Load(XmlReader, LoadOptions)	Carga un XElement desde XmlReader y, de manera opcional, conserva los espacios en blanco, establece el URI base y retiene la información de línea.
Load(String, LoadOptions)	Carga un XElement desde un archivo y, de manera opcional, conserva los espacios en blanco, establece el URI base y retiene la información de línea.
Load(Stream, LoadOptions)	Crea una nueva instancia de XElement 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)	Carga un XElement desde TextReader.
Load(String)	Carga un XElement desde un archivo.
Load(Stream)	Crea una nueva instancia de XElement usando la secuencia especificada.
Load(XmlReader)	Carga un XElement desde XmlReader.

Comentarios

Puede usar una de las sobrecargas de este método para cargar un XElement desde un archivo, un TextReadero .XmlReader

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

Load(TextReader, LoadOptions)

Source:

XElement.cs

Carga un XElement desde un objeto TextReader y, de manera opcional, conserva los espacios en blanco y retiene la información de línea.

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

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

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

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

Parámetros

textReader

TextReader

TextReader que se leerá para obtener el contenido del XElement.

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

XElement

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

Ejemplos

En el ejemplo siguiente se carga un XElement objeto de dos StringReader maneras diferentes: conservar el espacio en blanco y no conservar el espacio en blanco. A continuación, usa una consulta para determinar el número de nodos de espacio en blanco en el árbol XML resultante.

TextReader sr;
int whiteSpaceNodes;

sr = new StringReader("<Root> <Child> </Child> </Root>");
XElement xmlTree1 = XElement.Load(sr, LoadOptions.None);
sr.Close();
whiteSpaceNodes = xmlTree1
    .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>");
XElement xmlTree2 = XElement.Load(sr, LoadOptions.PreserveWhitespace);
sr.Close();
whiteSpaceNodes = xmlTree2
    .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 XElement = XElement.Load(sr, LoadOptions.None)
sr.Close()
whiteSpaceNodes = xmlTree1 _
    .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 XElement = XElement.Load(sr, LoadOptions.PreserveWhitespace)
sr.Close()
whiteSpaceNodes = xmlTree2 _
    .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

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

TextReader sr = new StringReader(
@"<Root>
  <Child>
    <GrandChild1/>
    <GrandChild2/>
  </Child>
</Root>");
XElement po = XElement.Load(sr,
    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 po.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 sr As TextReader = New StringReader( _
    "<Root>" & Environment.NewLine & _
    "  <Child>" & Environment.NewLine & _
    "    <GrandChild1/>" & Environment.NewLine & _
    "    <GrandChild2/>" & Environment.NewLine & _
    "  </Child>" & Environment.NewLine & _
    "</Root>")
Dim po As XElement = XElement.Load(sr, 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 po.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

Este ejemplo produce el siguiente resultado:

Element Name        Line Position
------------        ---- --------
Root                1    2
  Child             2    4
    GrandChild1     3    6
    GrandChild2     4    6

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 tendrá ningún efecto 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

• Información general de LINQ to XML

Load(XmlReader, LoadOptions)

Source:

XElement.cs

Carga un XElement desde XmlReader y, de manera opcional, conserva los espacios en blanco, establece el URI base y retiene la información de línea.

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

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

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

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

Parámetros

reader

XmlReader

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

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

XElement

XElement 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();

    XElement xRoot = XElement.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.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 XElement = XElement.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.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 XElement 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

• Información general de LINQ to XML

Load(String, LoadOptions)

Source:

XElement.cs

Carga un XElement desde un archivo y, de manera opcional, conserva los espacios en blanco, establece el URI base y retiene la información de línea.

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

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

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

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

Parámetros

uri

String

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

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

XElement

XElement con el contenido del archivo especificado.

Ejemplos

En el ejemplo siguiente se carga un XElement desde un archivo de dos maneras diferentes: conservar el espacio en blanco y no conservar el espacio en blanco. A continuación, usa una consulta para determinar el número de nodos de espacio en blanco en el árbol XML resultante.

XElement xmlTree1 = XElement.Parse("<Root> <Child>  </Child> </Root>", LoadOptions.PreserveWhitespace);
xmlTree1.Save("Tree.xml");
Console.WriteLine(xmlTree1);

int whiteSpaceNodes;
XElement xmlTree2 = XElement.Load("Tree.xml",
    LoadOptions.None);
whiteSpaceNodes = xmlTree2
    .DescendantNodesAndSelf()
    .OfType<XText>()
    .Where(tNode => tNode.ToString().Trim().Length == 0)
    .Count();
Console.WriteLine("Count of white space nodes (not preserving whitespace): {0}", whiteSpaceNodes);

XElement xmlTree3 = XElement.Load("Tree.xml",
    LoadOptions.PreserveWhitespace);
whiteSpaceNodes = xmlTree3
    .DescendantNodesAndSelf()
    .OfType<XText>()
    .Where(tNode => tNode.ToString().Trim().Length == 0)
    .Count();
Console.WriteLine("Count of white space nodes (preserving whitespace): {0}", whiteSpaceNodes);

Dim xmlTree1 As XElement = XElement.Parse("<Root> <Child>  </Child> </Root>", LoadOptions.PreserveWhitespace)
xmlTree1.Save("Tree.xml")
Console.WriteLine(xmlTree1)

Dim whiteSpaceNodes As Integer
Dim xmlTree2 As XElement = XElement.Load("Tree.xml", LoadOptions.None)
whiteSpaceNodes = xmlTree2 _
                  .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)

Dim xmlTree3 As XElement = XElement.Load("Tree.xml", LoadOptions.PreserveWhitespace)
whiteSpaceNodes = xmlTree3 _
                  .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:

<Root> <Child>  </Child> </Root>
Count of white space nodes (not preserving whitespace): 0
Count of white space nodes (preserving whitespace): 3

En el ejemplo siguiente se carga el URI base y la información de línea a medida que carga el archivo. A continuación, imprime el URI base y la información de línea.

En este ejemplo se usa el siguiente archivo de recursos: Archivo XML de ejemplo: Pedido de compra típico (LINQ to XML) .

XElement po = XElement.Load("PurchaseOrder.xml",
    LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);
string[] splitUri = po.BaseUri.Split('/');
Console.WriteLine("BaseUri: {0}", splitUri[splitUri.Length - 1]);
Console.WriteLine();
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 po.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 po As XElement = XElement.Load("PurchaseOrder.xml", LoadOptions.SetBaseUri Or LoadOptions.SetLineInfo)
Dim splitUri() As String = po.BaseUri.Split("/")
Console.WriteLine("BaseUri: {0}", splitUri(splitUri.Length - 1))
Console.WriteLine()
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 po.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

Este ejemplo produce el siguiente resultado:

BaseUri: PurchaseOrder.xml

Element Name        Line Position
------------        ---- --------
PurchaseOrder       2    2
  Address           3    4
    Name            4    6
    Street          5    6
    City            6    6
    State           7    6
    Zip             8    6
    Country         9    6
  Address           11   4
    Name            12   6
    Street          13   6
    City            14   6
    State           15   6
    Zip             16   6
    Country         17   6
  DeliveryNotes     19   4
  Items             20   4
    Item            21   6
      ProductName   22   8
      Quantity      23   8
      USPrice       24   8
      Comment       25   8
    Item            27   6
      ProductName   28   8
      Quantity      29   8
      USPrice       30   8
      ShipDate      31   8

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.

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

• Información general de LINQ to XML

Load(Stream, LoadOptions)

Source:

XElement.cs

Crea una nueva instancia de XElement 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::XElement ^ Load(System::IO::Stream ^ stream, System::Xml::Linq::LoadOptions options);

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

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

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

Parámetros

stream

Stream

Flujo que contiene los datos XML.

options

LoadOptions

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

Devoluciones

XElement

Objeto XElement que se usa para leer los datos que contiene 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 toman XmlReaderSettings como parámetro.

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

Load(TextReader)

Source:

XElement.cs

Carga un XElement desde TextReader.

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

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

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

Public Shared Function Load (textReader As TextReader) As XElement

Parámetros

textReader

TextReader

TextReader que se leerá para obtener el contenido del XElement.

Devoluciones

XElement

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

Ejemplos

En el ejemplo siguiente se carga un elemento de .StringReader

TextReader sr = new StringReader("<Root><Child/></Root>");
XElement xmlTree = XElement.Load(sr);
sr.Close();
Console.WriteLine(xmlTree);

Dim sr As TextReader = New StringReader("<Root><Child/></Root>")
Dim xmlTree As XElement = XElement.Load(sr)
sr.Close()
Console.WriteLine(xmlTree)

Este ejemplo produce el siguiente resultado:

<Root>
  <Child />
</Root>

Comentarios

Este método lee el XML sin formato en el árbol XML. Descarta todos los espacios en blanco insignificantes del archivo.

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

• Información general de LINQ to XML

Load(String)

Source:

XElement.cs

Carga un XElement desde un archivo.

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

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

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

Public Shared Function Load (uri As String) As XElement

Parámetros

uri

String

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

Devoluciones

XElement

XElement con el contenido del archivo especificado.

Ejemplos

En el ejemplo siguiente se crea un árbol XML, se guarda en un archivo y, a continuación, se usa este método para cargar desde XElement el archivo.

XElement xmlTree1 = new XElement("Root",
    new XElement("Child", "content")
);
xmlTree1.Save("Tree.xml");

XElement xmlTree2 = XElement.Load("Tree.xml");
Console.WriteLine(xmlTree2.Name);

Dim xmlTree1 As XElement = _
        <Root>
            <Child>Content</Child>
        </Root>
xmlTree1.Save("Tree.xml")

Dim xmlTree2 As XElement = XElement.Load("Tree.xml")
Console.WriteLine(xmlTree2.Name)

Este ejemplo produce el siguiente resultado:

Root

Comentarios

Este método lee el XML sin formato en el árbol XML. Descarta todos los espacios en blanco insignificantes del archivo.

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

• Load
• Parse
• Información general de LINQ to XML

Load(Stream)

Source:

XElement.cs

Crea una nueva instancia de XElement usando la secuencia especificada.

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

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

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

Public Shared Function Load (stream As Stream) As XElement

Parámetros

stream

Stream

Flujo que contiene los datos XML.

Devoluciones

XElement

Objeto XElement que se usa para leer 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. Pase a XmlReader una de las XElementsobrecargas de Load que toma XmlReader como parámetro.

Load(XmlReader)

Source:

XElement.cs

Carga un XElement desde XmlReader.

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

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

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

Public Shared Function Load (reader As XmlReader) As XElement

Parámetros

reader

XmlReader

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

Devoluciones

XElement

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

Ejemplos

En el ejemplo siguiente se crea un documento DOM, se crea un XmlNodeReader objeto a partir del documento DOM y se crea una instancia de un árbol del lector. Este código copia eficazmente un documento DOM en un árbol de LINQ to XML.

// 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();

    XElement xRoot = XElement.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 XElement = XElement.Load(nodeReader)
    Console.WriteLine(xRoot)
End Using

Este ejemplo produce el siguiente resultado:

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

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.

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

• Información general de LINQ to XML