XElement.Load Método

Definição

Namespace:

System.Xml.Linq

Assembly:

System.Xml.XDocument.dll

Assembly:

System.Xml.Linq.dll

Assembly:

netstandard.dll

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

Sobrecargas

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

Comentários

Você pode usar uma das sobrecargas desse método para carregar um XElement de um arquivo, um TextReaderou um XmlReader.

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

Load(TextReader, LoadOptions)

Carrega um XElement de um TextReader, opcionalmente, preservando os espaços em branco e retendo as informações de linha.

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

Um TextReader que será lido para o conteúdo de XElement.

options

LoadOptions

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

Retornos

XElement

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

Exemplos

O exemplo a seguir carrega um XElement de duas StringReader maneiras diferentes: preservar o espaço em branco e não preservar o espaço em branco. Em seguida, ele usa uma consulta para determinar o número de nós de espaço em branco na árvore 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)  

Esse exemplo gera a saída a seguir:

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

O exemplo a seguir carrega as informações de linha enquanto ela é carregada do TextReader. Em seguida, ele imprime as informações de linha.

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  

Esse exemplo gera a saída a seguir:

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

Comentários

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

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

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

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

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

A configuração SetBaseUri não terá efeito ao carregar de um TextReader.

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

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

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

Confira também

• Visão geral do LINQ to XML

Load(XmlReader, LoadOptions)

Carrega um XElement de um XmlReader, opcionalmente preservando o espaço em branco, definindo o URI de base e retendo informações de linha.

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

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

options

LoadOptions

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

Retornos

XElement

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

Exemplos

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

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

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

    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  

Esse exemplo gera a saída a seguir:

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

Comentários

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

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

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

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

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

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

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

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

Confira também

• Visão geral do LINQ to XML

Load(String, LoadOptions)

Carrega um XElement de um arquivo, opcionalmente preservando espaço em branco, definindo o URI de base e retendo informações de linha.

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

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

options

LoadOptions

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

Retornos

XElement

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

Exemplos

O exemplo a seguir carrega um XElement de um arquivo de duas maneiras diferentes: preservar o espaço em branco e não preservar o espaço em branco. Em seguida, ele usa uma consulta para determinar o número de nós de espaço em branco na árvore 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)  

Esse exemplo gera a saída a seguir:

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

O exemplo a seguir carrega o URI base e as informações de linha enquanto carrega o arquivo. Em seguida, ele imprime o URI base e as informações de linha.

Este exemplo usa o seguinte arquivo de recurso: Arquivo XML de Exemplo: Ordem de Compra Típica (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  

Esse exemplo gera a saída a seguir:

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  

Comentários

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

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

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

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

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

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

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

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

Confira também

• Visão geral do LINQ to XML

Load(Stream, LoadOptions)

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

public:
 static System::Xml::Linq::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

O fluxo que contém os dados XML.

options

LoadOptions

Um objeto LoadOptions que especifica se o URI base e as informações de linha devem ser carregados.

Retornos

XElement

Um objeto XElement usado para ler os dados contidos no fluxo.

Comentários

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

Se você precisar modificar XmlReaderSettings, siga estas etapas:

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

2. Passe para XmlReader uma das XElementLoad sobrecargas que usa XmlReader como parâmetro.

Load(TextReader)

Carrega um XElement de um 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

Um TextReader que será lido para o conteúdo de XElement.

Retornos

XElement

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

Exemplos

O exemplo a seguir carrega um elemento de um 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)  

Esse exemplo gera a saída a seguir:

<Root>  
  <Child />  
</Root>  

Comentários

Esse método lê o XML bruto na árvore XML. Ele descarta todo o espaço em branco insignificante no arquivo.

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

Confira também

• Visão geral do LINQ to XML

Load(String)

Carrega um XElement de um arquivo.

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

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

Retornos

XElement

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

Exemplos

O exemplo a seguir cria uma árvore XML, salva-a em um arquivo e usa esse método para carregar o XElement arquivo.

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)  

Esse exemplo gera a saída a seguir:

Root  

Comentários

Esse método lê o XML bruto na árvore XML. Ele descarta todo o espaço em branco insignificante no arquivo.

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

Confira também

• Load
• Parse
• Visão geral do LINQ to XML

Load(Stream)

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

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

O fluxo que contém os dados XML.

Retornos

XElement

Um objeto XElement usado para ler os dados contidos em um fluxo.

Comentários

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

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

Se você precisar modificar XmlReaderSettings, siga estas etapas:

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

2. Passe para XmlReader uma das XElementLoad sobrecargas que usa XmlReader como parâmetro.

Load(XmlReader)

Carrega um XElement de um 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

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

Retornos

XElement

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

Exemplos

O exemplo a seguir cria um documento DOM, cria um XmlNodeReader documento do DOM e cria uma instância de uma árvore do leitor. Esse código copia efetivamente um documento DOM em uma árvore 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  

Esse exemplo gera a saída a seguir:

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

Comentários

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

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

Confira também

• Visão geral do LINQ to XML