XElement.Load Metod

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

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

Parametrar

Returer

En XElement som innehåller xml-koden som lästes från den angivna TextReader.

Exempel

I följande exempel läses en XElement från en StringReader in på två olika sätt: bevara tomt utrymme och inte bevara tomt utrymme. Sedan används en fråga för att fastställa antalet blankstegsnoder i det resulterande XML-trädet.

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)

Det här exemplet genererar följande utdata:

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

I följande exempel läses radinformationen in när den TextReaderläses in från . Radinformationen skrivs sedan ut.

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

Det här exemplet genererar följande utdata:

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

Kommentarer

Om käll-XML:en är indragen gör inställningen PreserveWhitespace av flaggan i options att läsaren läser allt tomt utrymme i käll-XML:en. Noder av typen XText skapas för både betydande och obetydligt tomt utrymme.

Om käll-XML:en är indragen, gör inte inställningen PreserveWhitespace av flaggan i options att läsaren ignorerar allt obetydligt tomt utrymme i käll-XML:en. XML-trädet skapas utan textnoder för obetydligt tomt utrymme.

Om käll-XML inte är indraget har det ingen effekt att ange PreserveWhitespace flaggan i options . Betydande tomt utrymme bevaras fortfarande, och det finns inga intervall med obetydligt tomt utrymme som kan orsaka skapandet av fler blankstegstextnoder.

Mer information finns i Bevara tomt utrymme vid inläsning eller parsning av XML och Bevara tomt utrymme vid serialisering.

Använd Parse för att skapa en XElement från en sträng som innehåller XML.

Inställningen SetBaseUri har ingen effekt vid inläsning från en TextReader.

Det finns ett prestandastraff om du anger SetLineInfo flaggan.

Radinformationen är korrekt omedelbart efter att XML-dokumentet har lästs in. Om du ändrar XML-trädet när du har läst in dokumentet kan radinformationen bli meningslös.

LINQ till XML:s inläsningsfunktioner bygger på XmlReader. Därför kan du fånga eventuella undantag som genereras av överlagringsmetoderna XmlReader.Create och de XmlReader metoder som läser och parsar dokumentet.

Se även

• Översikt över LINQ till XML

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

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

Parametrar

Returer

En XElement som innehåller xml-koden som lästes från den angivna XmlReader.

Exempel

I följande exempel läses den radinformation som läses in från XmlReader. Radinformationen skrivs sedan ut.

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

Det här exemplet genererar följande utdata:

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

Kommentarer

Genom att skapa ett XmlNodeReader från ett DOM-dokument och sedan använda XmlNodeReader för att skapa en XElement, kan den här metoden användas för att skapa en kopia av ett DOM-dokument i ett LINQ till XML-träd.

Använd Parse för att skapa en XElement från en sträng som innehåller XML.

Inställningen PreserveWhitespace är inte giltig vid inläsning från en XmlReader. XmlReader Kommer att konfigureras för att antingen läsa tomt utrymme eller inte. LINQ till XML-trädet fylls i med de blankstegsnoder som läsaren visar. Det här är beteendet oavsett om PreserveWhitespace det har angetts eller inte.

XmlReader Kan ha en giltig bas-URI eller inte. Om du anger SetBaseUrianges bas-URI:n i XML-trädet från den bas-URI som rapporteras av XmlReader.

Kan XmlReader ha en giltig radinformation eller inte. Om du anger SetLineInfoanges radinformationen i XML-trädet från den radinformation som rapporteras av XmlReader.

Det finns ett prestandastraff om du anger SetLineInfo flaggan.

Radinformationen är korrekt omedelbart efter att XML-dokumentet har lästs in. Om du ändrar XML-trädet när du har läst in dokumentet kan radinformationen bli meningslös.

LINQ till XML:s inläsningsfunktioner bygger på XmlReader. Därför kan du fånga eventuella undantag som genereras av överlagringsmetoderna XmlReader.Create och de XmlReader metoder som läser och parsar dokumentet.

Se även

• Översikt över LINQ till XML

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

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

Parametrar

Returer

En XElement som innehåller innehållet i den angivna filen.

Exempel

I följande exempel läses en XElement från en fil in på två olika sätt: bevara tomt utrymme och inte bevara tomt utrymme. Sedan används en fråga för att fastställa antalet blankstegsnoder i det resulterande XML-trädet.

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)

Det här exemplet genererar följande utdata:

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

I följande exempel läses bas-URI:n och radinformationen in när filen läses in. Den skriver sedan ut bas-URI:n och radinformationen.

I det här exemplet används följande resursfil: XML-exempelfil: Vanlig inköpsorder (LINQ till 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

Det här exemplet genererar följande utdata:

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

Kommentarer

Om käll-XML:en är indragen gör inställningen PreserveWhitespace av flaggan i options att läsaren läser allt tomt utrymme i käll-XML:en. Noder av typen XText skapas för både betydande och obetydligt tomt utrymme.

Om käll-XML:en är indragen, gör inte inställningen PreserveWhitespace av flaggan i options att läsaren ignorerar allt obetydligt tomt utrymme i käll-XML:en. XML-trädet skapas utan textnoder för obetydligt tomt utrymme.

Om käll-XML inte är indraget har det ingen effekt att ange PreserveWhitespace flaggan i options . Betydande tomt utrymme bevaras fortfarande, och det finns inga intervall med obetydligt tomt utrymme som kan orsaka skapandet av fler blankstegstextnoder.

Mer information finns i Bevara tomt utrymme vid inläsning eller parsning av XML och Bevara tomt utrymme vid serialisering.

Använd Parse för att skapa en XElement från en sträng som innehåller XML.

Det finns ett prestandastraff om du anger flaggorna SetBaseUriSetLineInfo och .

Bas-URI:n och radinformationen är korrekta omedelbart efter att XML-dokumentet har lästs in. Om du ändrar XML-trädet när du har läst in dokumentet kan bas-URI:n och radinformationen bli meningslösa.

LINQ till XML:s inläsningsfunktioner bygger på XmlReader. Därför kan du fånga eventuella undantag som genereras av överlagringsmetoderna XmlReader.Create och de XmlReader metoder som läser och parsar dokumentet.

Se även

• Översikt över LINQ till XML

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

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

Parametrar

Returer

Ett XElement objekt som används för att läsa data som dataströmmen innehåller.

Kommentarer

LINQ till XML:s inläsningsfunktioner bygger på XmlReader. Därför kan du fånga eventuella undantag som genereras av överlagringsmetoderna XmlReader.Create och de XmlReader metoder som läser och parsar dokumentet.

Om du måste ändra XmlReaderSettingsföljer du dessa steg:

1. Skapa en XmlReader genom att anropa en av de Create överlagringar som tar XmlReaderSettings som en parameter.

2. XmlReader Skicka till en av de XElementLoad överlagringar som tar XmlReader som en parameter.

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

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

Parametrar

Returer

En XElement som innehåller xml-koden som lästes från den angivna TextReader.

Exempel

I följande exempel läses ett element in från en 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)

Det här exemplet genererar följande utdata:

<Root>
  <Child />
</Root>

Kommentarer

Den här metoden läser den råa XML-koden i XML-trädet. Det tar bort allt obetydligt tomt utrymme i filen.

LINQ till XML:s inläsningsfunktioner bygger på XmlReader. Därför kan du fånga eventuella undantag som genereras av överlagringsmetoderna XmlReader.Create och de XmlReader metoder som läser och parsar dokumentet.

Se även

• Översikt över LINQ till XML

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

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

Parametrar

Returer

En XElement som innehåller innehållet i den angivna filen.

Exempel

Följande exempel skapar ett XML-träd, sparar det i en fil och använder sedan den här metoden för att läsa in XElement från filen.

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)

Det här exemplet genererar följande utdata:

Root

Kommentarer

Den här metoden läser den råa XML-koden i XML-trädet. Det tar bort allt obetydligt tomt utrymme i filen.

LINQ till XML:s inläsningsfunktioner bygger på XmlReader. Därför kan du fånga eventuella undantag som genereras av överlagringsmetoderna XmlReader.Create och de XmlReader metoder som läser och parsar dokumentet.

Se även

• Load
• Parse
• Översikt över LINQ till XML

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

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

Parametrar

Returer

Ett XElement objekt som används för att läsa data som finns i dataströmmen.

Kommentarer

Om du vill styra inläsningsalternativen använder du den Load överlagring som tar LoadOptions som parameter.

LINQ till XML:s inläsningsfunktioner bygger på XmlReader. Därför kan du fånga eventuella undantag som genereras av överlagringsmetoderna XmlReader.Create och de XmlReader metoder som läser och parsar dokumentet.

Om du måste ändra XmlReaderSettingsföljer du dessa steg:

1. Skapa en XmlReader genom att anropa en av de Create överlagringar som tar XmlReaderSettings som en parameter.

2. XmlReader Skicka till en av de XElementLoad överlagringar som tar XmlReader som en parameter.

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

XElement.cs

Källa:

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

Parametrar

Returer

En XElement som innehåller xml-koden som lästes från den angivna XmlReader.

Exempel

Följande exempel skapar ett DOM-dokument, skapar ett XmlNodeReader från DOM-dokumentet, instansierar ett träd från läsaren. Den här koden kopierar effektivt ett DOM-dokument till ett LINQ till XML-träd.

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

Det här exemplet genererar följande utdata:

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

Kommentarer

Genom att skapa ett XmlNodeReader från ett DOM-dokument och sedan använda XmlNodeReader för att skapa en XElement, kan den här metoden användas för att skapa en kopia av ett DOM-dokument i ett LINQ till XML-träd.

LINQ till XML:s inläsningsfunktioner bygger på XmlReader. Därför kan du fånga eventuella undantag som genereras av överlagringsmetoderna XmlReader.Create och de XmlReader metoder som läser och parsar dokumentet.

Se även

• Översikt över LINQ till XML