XElement.Load Método

Definición

Crea un nuevo XElement a partir de un archivo especificado por un URI, de un TextReader, o de un XmlReader.Creates a new XElement from a file specified by a URI, from an TextReader, or from an 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.Loads an XElement from a TextReader, optionally preserving white space and retaining line information.

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.Loads an XElement from an XmlReader, optionally preserving white space, setting the base URI, and retaining line information.

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.Loads an XElement from a file, optionally preserving white space, setting the base URI, and retaining line information.

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.Creates a new XElement instance by using the specified stream, optionally preserving white space, setting the base URI, and retaining line information.

Load(TextReader)

Carga un XElement desde TextReader.Loads an XElement from a TextReader.

Load(String)

Carga un XElement desde un archivo.Loads an XElement from a file.

Load(Stream)

Crea una nueva instancia de XElement usando la secuencia especificada.Creates a new XElement instance by using the specified stream.

Load(XmlReader)

Carga un XElement desde XmlReader.Loads an XElement from an XmlReader.

Comentarios

Puede utilizar una de las sobrecargas de este método para cargar un XElement desde un archivo, un TextReader o un XmlReader .You can use one of the overloads of this method to load an XElement from a file, a TextReader, or an XmlReader.

Para crear un a XElement partir de una cadena que contiene XML, use Parse .To create an XElement from a string that contains XML, use Parse.

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.Loads an XElement from a TextReader, optionally preserving white space and retaining line information.

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.A TextReader that will be read for the XElement content.

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.A LoadOptions that specifies white space behavior, and whether to load base URI and line information.

Devoluciones

XElement

XElement que contiene el XML que se leyó desde el objeto TextReader especificado.An XElement that contains the XML that was read from the specified TextReader.

Ejemplos

En el ejemplo siguiente se carga un XElement de StringReader de dos maneras diferentes: conservar el espacio en blanco y no conservar el espacio en blanco.The following example loads an XElement from a StringReader in two different ways: preserving white space, and not preserving white space. A continuación, usa una consulta para determinar el número de nodos de espacio en blanco en el árbol XML resultante.It then uses a query to determine the number of white space nodes in the resulting XML tree.

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:This example produces the following output:

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 .The following example loads the line information as it loads from the TextReader. A continuación, imprime la información de la línea.It then prints the line information.

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:This example produces the following output:

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

Comentarios

Si se aplica sangría al XML de origen, al establecer la PreserveWhitespace marca en, options el lector Lee todos los espacios en blanco en el XML de origen.If the source XML is indented, setting the PreserveWhitespace flag in options causes the reader to read all white space in the source XML. Los nodos de tipo XText se crean para espacios en blanco significativos e insignificantes.Nodes of type XText are created for both significant and insignificant white space.

Si se aplica sangría al XML de origen, no al establecer la PreserveWhitespace marca en, options el lector omite todos los espacios en blanco insignificantes en el XML de origen.If the source XML is indented, not setting the PreserveWhitespace flag in options causes the reader to ignore all of the insignificant white space in the source XML. El árbol XML se crea sin ningún nodo de texto para los espacios en blanco insignificantes.The XML tree is created without any text nodes for insignificant white space.

Si no se aplica sangría al XML de origen, el establecimiento PreserveWhitespace de la marca en options no tiene ningún efecto.If the source XML is not indented, setting the PreserveWhitespace flag in options has no effect. Todavía se conservan los espacios en blanco significativos 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.Significant white space is still preserved, and there are no spans of insignificant white space that could cause the creation of more white space text nodes.

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.For more information, see Preserve white space while loading or parsing XML and Preserve white space while serializing.

Use Parse para crear un a XElement partir de una cadena que contiene XML.Use Parse to create an XElement from a string that contains XML.

SetBaseUriLa configuración no tendrá ningún efecto cuando se cargue desde TextReader .Setting SetBaseUri will have no effect when loading from a TextReader.

Si establece la marca, se produce una reducción del rendimiento SetLineInfo .There is a performance penalty if you set the SetLineInfo flag.

La información de línea es precisa inmediatamente después de cargar el documento XML.The line information is accurate immediately after loading the XML document. Si modifica el árbol XML después de cargar el documento, es posible que la información de línea deje de ser significativa.If you modify the XML tree after loading the document, the line information may become meaningless.

La funcionalidad de carga de LINQ to XML se basa en XmlReader .LINQ to XML's loading functionality is built upon XmlReader. Por lo tanto, puede detectar cualquier excepción que produzcan los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.Therefore, you might catch any exceptions that are thrown by the XmlReader.Create overload methods and the XmlReader methods that read and parse the document.

Se aplica a

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.Loads an XElement from an XmlReader, optionally preserving white space, setting the base URI, and retaining line information.

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.A XmlReader that will be read for the content of the 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.A LoadOptions that specifies white space behavior, and whether to load base URI and line information.

Devoluciones

XElement

XElement que contiene el XML que se leyó desde el objeto XmlReader especificado.An XElement that contains the XML that was read from the specified XmlReader.

Ejemplos

En el ejemplo siguiente se carga la información de línea que carga desde XmlReader .The following example loads the line information that it loads from the XmlReader. A continuación, imprime la información de la línea.It then prints the line information.

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:This example produces the following output:

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

Comentarios

Mediante la creación XmlNodeReader de un a partir de un documento DOM y el uso de XmlNodeReader para crear un XElement , este método se puede utilizar para crear una copia de un documento DOM en un árbol de LINQ to XML.By creating an XmlNodeReader from a DOM document, and then using the XmlNodeReader to create an XElement, this method can be used to create a copy of a DOM document in a LINQ to XML tree.

Use Parse para crear un a XElement partir de una cadena que contiene XML.Use Parse to create an XElement from a string that contains XML.

PreserveWhitespaceLa configuración no es válida cuando se carga desde un XmlReader .Setting PreserveWhitespace is not valid when loading from a XmlReader. Se XmlReader configurará para leer el espacio en blanco o no.The XmlReader will be configured to either read whitespace or not. El árbol de LINQ to XML se rellenará con los nodos de espacio en blanco que el lector muestra.The LINQ to XML tree will be populated with the whitespace nodes that the reader surfaces. Este será el comportamiento independientemente de si PreserveWhitespace está establecido o no.This will be the behavior regardless of whether PreserveWhitespace is set or not.

XmlReaderPuede tener un URI base válido o no.The XmlReader may have a valid base URI or not. Si establece SetBaseUri , el URI base se establecerá en el árbol XML a partir del URI base al que se refiere el XmlReader .If you set SetBaseUri, the base URI will be set in the XML tree from the base URI that is reported by the XmlReader.

XmlReaderPuede tener una información de línea válida o no.The XmlReader may have a valid line information or not. Si establece SetLineInfo , la información de línea se establecerá en el árbol XML a partir de la información de línea que indica XmlReader .If you set SetLineInfo, the line information will be set in the XML tree from the line information that is reported by the XmlReader.

Si establece la marca, se produce una reducción del rendimiento SetLineInfo .There is a performance penalty if you set the SetLineInfo flag.

La información de línea es precisa inmediatamente después de cargar el documento XML.The line information is accurate immediately after loading the XML document. Si modifica el árbol XML después de cargar el documento, es posible que la información de línea deje de ser significativa.If you modify the XML tree after loading the document, the line information may become meaningless.

La funcionalidad de carga de LINQ to XML se basa en XmlReader .LINQ to XML's loading functionality is built upon XmlReader. Por lo tanto, puede detectar cualquier excepción que produzcan los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.Therefore, you might catch any exceptions that are thrown by the XmlReader.Create overload methods and the XmlReader methods that read and parse the document.

Se aplica a

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.Loads an XElement from a file, optionally preserving white space, setting the base URI, and retaining line information.

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.A URI string referencing the file to load into an 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.A LoadOptions that specifies white space behavior, and whether to load base URI and line information.

Devoluciones

XElement

XElement con el contenido del archivo especificado.An XElement that contains the contents of the specified file.

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.The following example loads an XElement from a file in two different ways: preserving white space, and not preserving white space. A continuación, usa una consulta para determinar el número de nodos de espacio en blanco en el árbol XML resultante.It then uses a query to determine the number of white space nodes in the resulting XML tree.

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:This example produces the following output:

<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.The following example loads the base URI and line information as it loads the file. A continuación, imprime el URI base y la información de línea.It then prints the base URI and the line information.

En este ejemplo se usa el siguiente archivo de recursos: archivo XML de ejemplo: pedido de compra típico (LINQ to XML).This example uses the following resource file: Sample XML File: Typical Purchase Order (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:This example produces the following output:

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 se aplica sangría al XML de origen, al establecer la PreserveWhitespace marca en, options el lector Lee todos los espacios en blanco en el XML de origen.If the source XML is indented, setting the PreserveWhitespace flag in options causes the reader to read all white space in the source XML. Los nodos de tipo XText se crean para espacios en blanco significativos e insignificantes.Nodes of type XText are created for both significant and insignificant white space.

Si se aplica sangría al XML de origen, no al establecer la PreserveWhitespace marca en, options el lector omite todos los espacios en blanco insignificantes en el XML de origen.If the source XML is indented, not setting the PreserveWhitespace flag in options causes the reader to ignore all of the insignificant white space in the source XML. El árbol XML se crea sin ningún nodo de texto para los espacios en blanco insignificantes.The XML tree is created without any text nodes for insignificant white space.

Si no se aplica sangría al XML de origen, el establecimiento PreserveWhitespace de la marca en options no tiene ningún efecto.If the source XML is not indented, setting the PreserveWhitespace flag in options has no effect. Todavía se conservan los espacios en blanco significativos 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.Significant white space is still preserved, and there are no spans of insignificant white space that could cause the creation of more white space text nodes.

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.For more information, see Preserve white space while loading or parsing XML and Preserve white space while serializing.

Use Parse para crear un a XElement partir de una cadena que contiene XML.Use Parse to create an XElement from a string that contains XML.

Se produce una reducción del rendimiento si se establecen las SetBaseUri SetLineInfo marcas y.There is a performance penalty if you set the SetBaseUri and the SetLineInfo flags.

El URI base y la información de línea son precisos inmediatamente después de cargar el documento XML.The base URI and the line information are accurate immediately after loading the XML document. Si modifica el árbol XML después de cargar el documento, el URI base y la información de línea pueden quedar sin sentido.If you modify the XML tree after loading the document, the base URI and line information may become meaningless.

La funcionalidad de carga de LINQ to XML se basa en XmlReader .LINQ to XML's loading functionality is built upon XmlReader. Por lo tanto, puede detectar cualquier excepción que produzcan los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.Therefore, you might catch any exceptions that are thrown by the XmlReader.Create overload methods and the XmlReader methods that read and parse the document.

Se aplica a

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.Creates a new XElement instance by using the specified stream, optionally preserving white space, setting the base URI, and retaining line information.

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.The stream containing the XML data.

options
LoadOptions

Objeto LoadOptions que especifica si se va a cargar el identificador URI base y la información de línea.A LoadOptions object that specifies whether to load base URI and line information.

Devoluciones

XElement

Objeto XElement que se usa para leer los datos que contiene la secuencia.An XElement object used to read the data that the stream contains.

Comentarios

La funcionalidad de carga de LINQ to XML se basa en XmlReader .LINQ to XML's loading functionality is built upon XmlReader. Por lo tanto, puede detectar cualquier excepción que produzcan los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.Therefore, you might catch any exceptions that are thrown by the XmlReader.Create overload methods and the XmlReader methods that read and parse the document.

Si tiene que modificar XmlReaderSettings , siga estos pasos:If you have to modify XmlReaderSettings, following these steps:

  1. Cree una XmlReader llamada a una de las Create sobrecargas que toman XmlReaderSettings como parámetro.Create an XmlReader by calling one of the Create overloads that take XmlReaderSettings as a parameter.

  2. Pase XmlReader a una de las XElement Load sobrecargas de que toma XmlReader como parámetro.Pass the XmlReader to one of the XElement's Load overloads that takes XmlReader as a parameter.

Se aplica a

Load(TextReader)

Carga un XElement desde TextReader.Loads an XElement from a 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.A TextReader that will be read for the XElement content.

Devoluciones

XElement

XElement que contiene el XML que se leyó desde el objeto TextReader especificado.An XElement that contains the XML that was read from the specified TextReader.

Ejemplos

En el ejemplo siguiente se carga un elemento de un StringReader .The following example loads an element from a 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:This example produces the following output:

<Root>  
  <Child />  
</Root>  

Comentarios

Este método lee el XML sin formato en el árbol XML.This method reads the raw XML into the XML tree. Descarta todos los espacios en blanco insignificantes del archivo.It discards all insignificant white space in the file.

La funcionalidad de carga de LINQ to XML se basa en XmlReader .LINQ to XML's loading functionality is built upon XmlReader. Por lo tanto, puede detectar cualquier excepción que produzcan los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.Therefore, you might catch any exceptions that are thrown by the XmlReader.Create overload methods and the XmlReader methods that read and parse the document.

Se aplica a

Load(String)

Carga un XElement desde un archivo.Loads an XElement from a file.

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.A URI string referencing the file to load into a new XElement.

Devoluciones

XElement

XElement con el contenido del archivo especificado.An XElement that contains the contents of the specified file.

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 el del XElement archivo.The following example creates an XML tree, saves it to a file, and then uses this method to load the XElement from the file.

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:This example produces the following output:

Root  

Comentarios

Este método lee el XML sin formato en el árbol XML.This method reads the raw XML into the XML tree. Descarta todos los espacios en blanco insignificantes del archivo.It discards all insignificant white space in the file.

La funcionalidad de carga de LINQ to XML se basa en XmlReader .LINQ to XML's loading functionality is built upon XmlReader. Por lo tanto, puede detectar cualquier excepción que produzcan los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.Therefore, you might catch any exceptions that are thrown by the XmlReader.Create overload methods and the XmlReader methods that read and parse the document.

Consulte también

Se aplica a

Load(Stream)

Crea una nueva instancia de XElement usando la secuencia especificada.Creates a new XElement instance by using the specified stream.

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.The stream that contains the XML data.

Devoluciones

XElement

Objeto XElement que se usa para leer los datos contenidos en la secuencia.An XElement object used to read the data that is contained in the stream.

Comentarios

Si desea controlar las opciones de carga, use la Load sobrecarga que toma LoadOptions como parámetro.If you want to control load options, use the Load overload that takes LoadOptions as a parameter.

La funcionalidad de carga de LINQ to XML se basa en XmlReader .LINQ to XML's loading functionality is built upon XmlReader. Por lo tanto, puede detectar cualquier excepción que produzcan los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.Therefore, you might catch any exceptions that are thrown by the XmlReader.Create overload methods and the XmlReader methods that read and parse the document.

Si tiene que modificar XmlReaderSettings , siga estos pasos:If you have to modify XmlReaderSettings, following these steps:

  1. Cree una XmlReader llamada a una de las Create sobrecargas que toman XmlReaderSettings como parámetro.Create an XmlReader by calling one of the Create overloads that take XmlReaderSettings as a parameter.

  2. Pase XmlReader a una de las XElement Load sobrecargas de que toma XmlReader como parámetro.Pass the XmlReader to one of the XElement's Load overloads that takes XmlReader as a parameter.

Se aplica a

Load(XmlReader)

Carga un XElement desde XmlReader.Loads an XElement from an 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.A XmlReader that will be read for the content of the XElement.

Devoluciones

XElement

XElement que contiene el XML que se leyó desde el objeto XmlReader especificado.An XElement that contains the XML that was read from the specified XmlReader.

Ejemplos

En el ejemplo siguiente se crea un documento DOM, se crea un XmlNodeReader a partir del documento DOM, se crean instancias de un árbol desde el lector.The following example creates a DOM document, creates an XmlNodeReader from the DOM document, instantiates a tree from the reader. Este código copia eficazmente un documento DOM en un árbol de LINQ to XML.This code effectively copies a DOM document into a LINQ to XML tree.

// 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:This example produces the following output:

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

Comentarios

Mediante la creación XmlNodeReader de un a partir de un documento DOM y el uso de XmlNodeReader para crear un XElement , este método se puede utilizar para crear una copia de un documento DOM en un árbol de LINQ to XML.By creating an XmlNodeReader from a DOM document, and then using the XmlNodeReader to create an XElement, this method can be used to create a copy of a DOM document in a LINQ to XML tree.

La funcionalidad de carga de LINQ to XML se basa en XmlReader .LINQ to XML's loading functionality is built upon XmlReader. Por lo tanto, puede detectar cualquier excepción que produzcan los XmlReader.Create métodos de sobrecarga y los XmlReader métodos que leen y analizan el documento.Therefore, you might catch any exceptions that are thrown by the XmlReader.Create overload methods and the XmlReader methods that read and parse the document.

Se aplica a