XElement.Load Methode

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

Parameter

Gibt zurück

Eine XElement , die den XML-Code enthält, der aus dem angegebenen TextReaderText gelesen wurde.

Beispiele

Im folgenden Beispiel wird eine XElement Von zwei StringReader unterschiedlichen Methoden geladen: Die Beibehaltung von Leerzeichen und nicht das Beibehalten von Leerzeichen. Anschließend wird eine Abfrage verwendet, um die Anzahl der Leerraumknoten in der resultierenden XML-Struktur zu bestimmen.

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)

Dieses Beispiel erzeugt die folgende Ausgabe:

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

Im folgenden Beispiel werden die Zeileninformationen geladen, während sie aus dem TextReader. Anschließend werden die Zeileninformationen gedruckt.

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

Dieses Beispiel erzeugt die folgende Ausgabe:

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

Hinweise

Wenn der Quell-XML-Code eingerückt ist, bewirkt das Festlegen des PreserveWhitespace Flags options , dass der Leser den gesamten Leerraum im Quell-XML-Code liest. Knoten des Typs XText werden sowohl für signifikante als auch für unbedeutende Leerräume erstellt.

Wenn der Quell-XML-Code eingerückt ist, wird das PreserveWhitespace Flag options nicht festgelegt, wodurch der Leser den gesamten unbedeutenden Leerraum im Quell-XML-Code ignoriert. Die XML-Struktur wird ohne Textknoten für unbedeuteten Leerraum erstellt.

Wenn der Quell-XML-Code nicht eingerückt ist, hat das Festlegen des PreserveWhitespace Flags options keine Auswirkung. Erheblicher Leerraum bleibt erhalten, und es gibt keine Spanne von unbedeutenden Leerzeichen, die die Erstellung von mehr Leerraum-Textknoten verursachen könnten.

Weitere Informationen finden Sie unter Beibehalten des Leerraums beim Laden oder Analysieren von XML und Beibehalten von Leerzeichen beim Serialisieren.

Dient Parse zum Erstellen einer XElement Aus einer Zeichenfolge, die XML enthält.

Die Einstellung SetBaseUri hat keine Auswirkung beim Laden von einem TextReader.

Es gibt eine Leistungseinbuße, wenn Sie die SetLineInfo Kennzeichnung festlegen.

Die Zeileninformationen sind unmittelbar nach dem Laden des XML-Dokuments genau. Wenn Sie die XML-Struktur nach dem Laden des Dokuments ändern, können die Zeileninformationen bedeutungslos werden.

LINQ to XML-Ladefunktionalität basiert auf XmlReader. Daher können Sie ausnahmen erfassen, die von den XmlReader.Create Überladungsmethoden und den XmlReader Methoden ausgelöst werden, die das Dokument lesen und analysieren.

Weitere Informationen

• Übersicht über LINQ to XML

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

Parameter

Gibt zurück

Eine XElement , die den XML-Code enthält, der aus dem angegebenen XmlReaderText gelesen wurde.

Beispiele

Im folgenden Beispiel werden die Zeileninformationen geladen, die sie aus dem XmlReader. Anschließend werden die Zeileninformationen gedruckt.

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

Dieses Beispiel erzeugt die folgende Ausgabe:

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

Hinweise

Wenn Sie ein XmlNodeReader DOM-Dokument erstellen und dann XmlNodeReader eine XElementDOM-Struktur erstellen, kann diese Methode verwendet werden, um eine Kopie eines DOM-Dokuments in einer LINQ to XML-Struktur zu erstellen.

Dient Parse zum Erstellen einer XElement Aus einer Zeichenfolge, die XML enthält.

Die Einstellung PreserveWhitespace ist beim Laden aus einem XmlReader. Die XmlReader Konfiguration erfolgt entweder für das Lesen von Leerzeichen oder nicht. Die LINQ to XML-Struktur wird mit den Leerzeichenknoten aufgefüllt, die der Leser anzeigt. Dies ist das Verhalten, unabhängig davon, ob PreserveWhitespace festgelegt wird oder nicht.

Möglicherweise verfügt der XmlReader Basis-URI über einen gültigen Basis-URI. Wenn Sie festlegen SetBaseUri, wird der Basis-URI in der XML-Struktur aus dem Basis-URI festgelegt, der von der XmlReader.

Möglicherweise XmlReader verfügen sie über gültige Zeileninformationen oder nicht. Wenn Sie festlegen SetLineInfo, werden die Zeileninformationen in der XML-Struktur aus den Zeileninformationen festgelegt, die von der XmlReader.

Es gibt eine Leistungseinbuße, wenn Sie die SetLineInfo Kennzeichnung festlegen.

Die Zeileninformationen sind unmittelbar nach dem Laden des XML-Dokuments genau. Wenn Sie die XML-Struktur nach dem Laden des Dokuments ändern, können die Zeileninformationen bedeutungslos werden.

LINQ to XML-Ladefunktionalität basiert auf XmlReader. Daher können Sie ausnahmen erfassen, die von den XmlReader.Create Überladungsmethoden und den XmlReader Methoden ausgelöst werden, die das Dokument lesen und analysieren.

Weitere Informationen

• Übersicht über LINQ to XML

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

Parameter

Gibt zurück

Eine XElement , die den Inhalt der angegebenen Datei enthält.

Beispiele

Im folgenden Beispiel wird eine XElement Datei auf zwei verschiedene Arten geladen: Beibehalten von Leerraum und nicht beibehaltener Leerraum. Anschließend wird eine Abfrage verwendet, um die Anzahl der Leerraumknoten in der resultierenden XML-Struktur zu bestimmen.

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)

Dieses Beispiel erzeugt die folgende Ausgabe:

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

Im folgenden Beispiel werden die Basis-URI und Zeileninformationen geladen, während sie die Datei lädt. Anschließend werden der Basis-URI und die Zeileninformationen gedruckt.

In diesem Beispiel wird die folgende Ressourcendatei verwendet: Xml-Beispieldatei: Typische Bestellung (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

Dieses Beispiel erzeugt die folgende Ausgabe:

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

Hinweise

Wenn der Quell-XML-Code eingerückt ist, bewirkt das Festlegen des PreserveWhitespace Flags options , dass der Leser den gesamten Leerraum im Quell-XML-Code liest. Knoten des Typs XText werden sowohl für signifikante als auch für unbedeutende Leerräume erstellt.

Wenn der Quell-XML-Code eingerückt ist, wird das PreserveWhitespace Flag options nicht festgelegt, wodurch der Leser den gesamten unbedeutenden Leerraum im Quell-XML-Code ignoriert. Die XML-Struktur wird ohne Textknoten für unbedeuteten Leerraum erstellt.

Wenn der Quell-XML-Code nicht eingerückt ist, hat das Festlegen des PreserveWhitespace Flags options keine Auswirkung. Erheblicher Leerraum bleibt erhalten, und es gibt keine Spanne von unbedeutenden Leerzeichen, die die Erstellung von mehr Leerraum-Textknoten verursachen könnten.

Weitere Informationen finden Sie unter Beibehalten des Leerraums beim Laden oder Analysieren von XML und Beibehalten von Leerzeichen beim Serialisieren.

Dient Parse zum Erstellen einer XElement Aus einer Zeichenfolge, die XML enthält.

Es gibt eine Leistungseinbuße, wenn Sie die SetBaseUri Kennzeichnungen und die SetLineInfo Kennzeichnungen festlegen.

Der Basis-URI und die Zeileninformationen sind unmittelbar nach dem Laden des XML-Dokuments genau. Wenn Sie die XML-Struktur nach dem Laden des Dokuments ändern, können die Basis-URI und Zeileninformationen bedeutungslos werden.

LINQ to XML-Ladefunktionalität basiert auf XmlReader. Daher können Sie ausnahmen erfassen, die von den XmlReader.Create Überladungsmethoden und den XmlReader Methoden ausgelöst werden, die das Dokument lesen und analysieren.

Weitere Informationen

• Übersicht über LINQ to XML

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

Parameter

Gibt zurück

Ein XElement Objekt, das zum Lesen der Daten verwendet wird, die der Datenstrom enthält.

Hinweise

LINQ to XML-Ladefunktionalität basiert auf XmlReader. Daher können Sie ausnahmen erfassen, die von den XmlReader.Create Überladungsmethoden und den XmlReader Methoden ausgelöst werden, die das Dokument lesen und analysieren.

Wenn Sie dies ändern XmlReaderSettingsmüssen, führen Sie die folgenden Schritte aus:

1. Erstellen Sie eine XmlReader durch Aufrufen einer der Überladungen, die Create als Parameter verwendet XmlReaderSettings werden.

2. Übergeben Sie den XmlReader Wert an eine der ÜberladungenLoad, die XElementals Parameter verwendet XmlReader werden.

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

Parameter

Gibt zurück

Eine XElement , die den XML-Code enthält, der aus dem angegebenen TextReaderText gelesen wurde.

Beispiele

Im folgenden Beispiel wird ein Element aus einem 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)

Dieses Beispiel erzeugt die folgende Ausgabe:

<Root>
  <Child />
</Root>

Hinweise

Diese Methode liest den unformatierten XML-Code in der XML-Struktur. Es verwirft alle unbedeutenden Leerzeichen in der Datei.

LINQ to XML-Ladefunktionalität basiert auf XmlReader. Daher können Sie ausnahmen erfassen, die von den XmlReader.Create Überladungsmethoden und den XmlReader Methoden ausgelöst werden, die das Dokument lesen und analysieren.

Weitere Informationen

• Übersicht über LINQ to XML

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

Parameter

Gibt zurück

Eine XElement , die den Inhalt der angegebenen Datei enthält.

Beispiele

Im folgenden Beispiel wird eine XML-Struktur erstellt, in einer Datei gespeichert und anschließend diese Methode verwendet, um die XElement Datei zu laden.

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)

Dieses Beispiel erzeugt die folgende Ausgabe:

Root

Hinweise

Diese Methode liest den unformatierten XML-Code in der XML-Struktur. Es verwirft alle unbedeutenden Leerzeichen in der Datei.

LINQ to XML-Ladefunktionalität basiert auf XmlReader. Daher können Sie ausnahmen erfassen, die von den XmlReader.Create Überladungsmethoden und den XmlReader Methoden ausgelöst werden, die das Dokument lesen und analysieren.

Weitere Informationen

• Load
• Parse
• Übersicht über LINQ to XML

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

Parameter

Gibt zurück

Ein XElement Objekt, das zum Lesen der Daten verwendet wird, die im Datenstrom enthalten sind.

Hinweise

Wenn Sie Ladeoptionen steuern möchten, verwenden Sie die Überladung, die Load als Parameter verwendet LoadOptions wird.

LINQ to XML-Ladefunktionalität basiert auf XmlReader. Daher können Sie ausnahmen erfassen, die von den XmlReader.Create Überladungsmethoden und den XmlReader Methoden ausgelöst werden, die das Dokument lesen und analysieren.

Wenn Sie dies ändern XmlReaderSettingsmüssen, führen Sie die folgenden Schritte aus:

1. Erstellen Sie eine XmlReader durch Aufrufen einer der Überladungen, die Create als Parameter verwendet XmlReaderSettings werden.

2. Übergeben Sie den XmlReader Wert an eine der ÜberladungenLoad, die XElementals Parameter verwendet XmlReader werden.

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

Parameter

Gibt zurück

Eine XElement , die den XML-Code enthält, der aus dem angegebenen XmlReaderText gelesen wurde.

Beispiele

Im folgenden Beispiel wird ein DOM-Dokument erstellt, ein XmlNodeReader AUS DEM DOM-Dokument erstellt, eine Struktur aus dem Reader instanziiert. Dieser Code kopiert effektiv ein DOM-Dokument in eine LINQ to XML-Struktur.

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

Dieses Beispiel erzeugt die folgende Ausgabe:

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

Hinweise

Wenn Sie ein XmlNodeReader DOM-Dokument erstellen und dann XmlNodeReader eine XElementDOM-Struktur erstellen, kann diese Methode verwendet werden, um eine Kopie eines DOM-Dokuments in einer LINQ to XML-Struktur zu erstellen.

LINQ to XML-Ladefunktionalität basiert auf XmlReader. Daher können Sie ausnahmen erfassen, die von den XmlReader.Create Überladungsmethoden und den XmlReader Methoden ausgelöst werden, die das Dokument lesen und analysieren.

Weitere Informationen

• Übersicht über LINQ to XML