XElement.Load Método

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

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

Devoluções

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

Exemplos

O exemplo seguinte carrega um XElement de a StringReader partir de duas formas diferentes: preservando o espaço em branco e não preservando o espaço em branco. Depois, utiliza 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)

Este exemplo produz a seguinte saída:

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

O exemplo seguinte carrega a informação da linha à medida que carrega a partir do TextReader. Depois, imprime a informação da 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

Este exemplo produz a seguinte saída:

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

Observações

Se o XML de origem estiver indentado, ao definir a PreserveWhitespace flag em options faz com que o leitor leia todo o espaço em branco do XML de origem. Os nós de tipo XText são criados tanto para espaços em branco significativos como insignificantes.

Se o XML de origem estiver indentado, não definir a PreserveWhitespace flag options faz com que o leitor ignore todo o espaço em branco insignificante no XML de origem. A árvore XML é criada sem quaisquer nós de texto para espaço em branco insignificante.

Se o XML de origem não estiver indentado, definir a PreserveWhitespace flag não options tem efeito. Um espaço em branco significativo ainda está preservado, e não existem intervalos de espaços em branco insignificantes que possam causar a criação de mais nós de texto em espaços em branco.

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

Use Parse para criar um XElement a partir de uma string que contenha XML.

A definição SetBaseUri não terá efeito ao carregar a partir de um TextReader.

Há uma penalização de desempenho se definires a SetLineInfo bandeira.

A informação da linha é precisa imediatamente após o carregamento do documento XML. Se modificar a árvore XML após carregar o documento, a informação da linha pode tornar-se insignificante.

A funcionalidade de carregamento do LINQ para XML baseia-se em XmlReader. Portanto, pode detetar quaisquer exceções que sejam lançadas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Ver também

• Visão geral do LINQ to XML

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

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

Devoluções

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

Exemplos

O exemplo seguinte carrega a informação da linha que carrega a partir do XmlReader. Depois, imprime a informação da linha.

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

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

    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 exemplo produz a seguinte saída:

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

Observações

Ao criar um XmlNodeReader a partir de um documento DOM, e depois usar para XmlNodeReader criar um XElement, este método pode ser usado para criar uma cópia de um documento DOM numa árvore LINQ para XML.

Use Parse para criar um XElement a partir de uma string que contenha XML.

A definição PreserveWhitespace não é válida ao carregar a partir de um XmlReader. Eles XmlReader serão configurados para ler espaços em branco ou não. A árvore LINQ para XML será preenchida com os nós de espaço em branco que o leitor apresenta. Este será o comportamento independentemente de PreserveWhitespace estar definido ou não.

Podem XmlReader ter um URI base válido ou não. Se definires SetBaseUri, o URI base será definido na árvore XML a partir do URI base que é reportado pelo XmlReader.

Podem XmlReader ter uma informação válida da linha ou não. Se definir SetLineInfo, a informação de linha será definida na árvore XML a partir da informação de linha reportada pelo XmlReader.

Há uma penalização de desempenho se definires a SetLineInfo bandeira.

A informação da linha é precisa imediatamente após o carregamento do documento XML. Se modificar a árvore XML após carregar o documento, a informação da linha pode tornar-se insignificante.

A funcionalidade de carregamento do LINQ para XML baseia-se em XmlReader. Portanto, pode detetar quaisquer exceções que sejam lançadas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Ver também

• Visão geral do LINQ to XML

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

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

Devoluções

E XElement que contém o conteúdo do ficheiro especificado.

Exemplos

O exemplo seguinte carrega a XElement partir de um ficheiro de duas formas diferentes: preservando espaço em branco e não preservando espaço em branco. Depois, utiliza 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)

Este exemplo produz a seguinte saída:

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

O exemplo seguinte carrega o URI base e a informação de linha à medida que carrega o ficheiro. Depois imprime o URI base e a informação da linha.

Este exemplo utiliza o seguinte ficheiro de recurso: Ficheiro XML de Exemplo: Ordem de Compra Típica (LINQ para 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 exemplo produz a seguinte saída:

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

Observações

Se o XML de origem estiver indentado, ao definir a PreserveWhitespace flag em options faz com que o leitor leia todo o espaço em branco do XML de origem. Os nós de tipo XText são criados tanto para espaços em branco significativos como insignificantes.

Se o XML de origem estiver indentado, não definir a PreserveWhitespace flag options faz com que o leitor ignore todo o espaço em branco insignificante no XML de origem. A árvore XML é criada sem quaisquer nós de texto para espaço em branco insignificante.

Se o XML de origem não estiver indentado, definir a PreserveWhitespace flag não options tem efeito. Um espaço em branco significativo ainda está preservado, e não existem intervalos de espaços em branco insignificantes que possam causar a criação de mais nós de texto em espaços em branco.

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

Use Parse para criar um XElement a partir de uma string que contenha XML.

Há uma penalização de desempenho se definires as SetBaseUri e as SetLineInfo bandeiras.

O URI base e a informação da linha são precisos imediatamente após o carregamento do documento XML. Se modificar a árvore XML após carregar o documento, o URI base e a informação da linha podem tornar-se sem sentido.

A funcionalidade de carregamento do LINQ para XML baseia-se em XmlReader. Portanto, pode detetar quaisquer exceções que sejam lançadas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Ver também

• Visão geral do LINQ to XML

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

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

Devoluções

Um XElement objeto usado para ler os dados que o fluxo contém.

Observações

A funcionalidade de carregamento do LINQ para XML baseia-se em XmlReader. Portanto, pode detetar quaisquer exceções que sejam lançadas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Se tiver de modificar XmlReaderSettings, siga estes passos:

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

2. Passa o XmlReader para um dos XElementLoad 's overloads que toma XmlReader como parâmetro.

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

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

Devoluções

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

Exemplos

O exemplo seguinte carrega um elemento a partir 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)

Este exemplo produz a seguinte saída:

<Root>
  <Child />
</Root>

Observações

Este método lê o XML bruto na árvore XML. Descarta todo o espaço em branco insignificante no ficheiro.

A funcionalidade de carregamento do LINQ para XML baseia-se em XmlReader. Portanto, pode detetar quaisquer exceções que sejam lançadas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Ver também

• Visão geral do LINQ to XML

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

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

Devoluções

E XElement que contém o conteúdo do ficheiro especificado.

Exemplos

O exemplo seguinte cria uma árvore XML, guarda-a num ficheiro e depois usa este método para carregar a XElement árvore a partir do ficheiro.

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 exemplo produz a seguinte saída:

Root

Observações

Este método lê o XML bruto na árvore XML. Descarta todo o espaço em branco insignificante no ficheiro.

A funcionalidade de carregamento do LINQ para XML baseia-se em XmlReader. Portanto, pode detetar quaisquer exceções que sejam lançadas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Ver também

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

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

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

Devoluções

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

Observações

Se quiseres controlar as opções de carga, usa a Load sobrecarga que isso toma LoadOptions como parâmetro.

A funcionalidade de carregamento do LINQ para XML baseia-se em XmlReader. Portanto, pode detetar quaisquer exceções que sejam lançadas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Se tiver de modificar XmlReaderSettings, siga estes passos:

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

2. Passa o XmlReader para um dos XElementLoad 's overloads que toma XmlReader como parâmetro.

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

Origem:

XElement.cs

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

Devoluções

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

Exemplos

O exemplo seguinte cria um documento DOM, cria um XmlNodeReader a partir do documento DOM, instancia uma árvore a partir do leitor. Este código copia efetivamente um documento DOM para uma árvore LINQ para 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 exemplo produz a seguinte saída:

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

Observações

Ao criar um XmlNodeReader a partir de um documento DOM, e depois usar para XmlNodeReader criar um XElement, este método pode ser usado para criar uma cópia de um documento DOM numa árvore LINQ para XML.

A funcionalidade de carregamento do LINQ para XML baseia-se em XmlReader. Portanto, pode detetar quaisquer exceções que sejam lançadas pelos XmlReader.Create métodos de sobrecarga e pelos XmlReader métodos que leem e analisam o documento.

Ver também

• Visão geral do LINQ to XML