XElement.Load Methode

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

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

Parameters

Retouren

Een XElement met de XML die is gelezen uit de opgegeven TextReader.

Voorbeelden

In het volgende voorbeeld wordt een XElementStringReader op twee verschillende manieren geladen: witruimte behouden en geen witruimte behouden. Vervolgens wordt een query gebruikt om het aantal witruimteknooppunten in de resulterende XML-structuur te bepalen.

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)

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

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

In het volgende voorbeeld worden de regelgegevens geladen terwijl deze worden geladen vanuit de TextReader. Vervolgens worden de regelgegevens afgedrukt.

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

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

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

Opmerkingen

Als de bron-XML is ingesprongen, zorgt het instellen van de PreserveWhitespace vlag options ervoor dat de lezer alle witruimte in de bron-XML leest. Knooppunten van het type XText worden gemaakt voor zowel significante als onbelangrijke witruimte.

Als de bron-XML is ingesprongen, hoeft u de PreserveWhitespace vlag niet in options te stellen, waardoor de lezer alle onbelangrijke witruimte in de bron-XML negeert. De XML-structuur wordt gemaakt zonder tekstknooppunten voor onbeduidende witruimte.

Als de bron-XML niet is ingesprongen, heeft het instellen van de PreserveWhitespace vlag options geen effect. Er blijft nog steeds aanzienlijke witruimte behouden en er zijn geen onbelangrijke witruimte die kan leiden tot het maken van meer witruimtetekstknooppunten.

Zie Witruimte behouden tijdens het laden of parseren van XML en Witruimte behouden tijdens het serialiseren van witruimte voor meer informatie.

Hiermee Parse maakt u een XElement tekenreeks die XML bevat.

Instelling SetBaseUri heeft geen effect bij het laden van een TextReader.

Er is een prestatiestraf als u de SetLineInfo vlag instelt.

De regelgegevens zijn direct na het laden van het XML-document nauwkeurig. Als u de XML-structuur wijzigt nadat u het document hebt geladen, kan de regelinformatie betekenisloos worden.

LinQ naar XML-laadfunctionaliteit is gebaseerd op XmlReader. Daarom kunt u eventuele uitzonderingen ondervangen die worden veroorzaakt door de XmlReader.Create overbelastingsmethoden en de XmlReader methoden die het document lezen en parseren.

Zie ook

• Overzicht van LINQ naar XML

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

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

Parameters

Retouren

Een XElement met de XML die is gelezen uit de opgegeven XmlReader.

Voorbeelden

In het volgende voorbeeld worden de regelgegevens geladen die vanuit de XmlReaderregel worden geladen. Vervolgens worden de regelgegevens afgedrukt.

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

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

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

Opmerkingen

Door een XmlNodeReader van een DOM-document te maken en vervolgens de methode XmlNodeReader te gebruiken om een XElementDOM-document te maken, kan deze methode worden gebruikt om een kopie van een DOM-document in een LINQ naar xml-structuur te maken.

Hiermee Parse maakt u een XElement tekenreeks die XML bevat.

Instelling PreserveWhitespace is niet geldig bij het laden vanaf een XmlReader. De XmlReader configuratie wordt geconfigureerd om witruimte te lezen of niet. De LINQ-naar-XML-structuur wordt gevuld met de witruimteknooppunten die door de lezer worden weergegeven. Dit is het gedrag, ongeacht of PreserveWhitespace deze is ingesteld of niet.

De XmlReader kan een geldige basis-URI hebben of niet. Als u instelt SetBaseUri, wordt de basis-URI ingesteld in de XML-structuur van de basis-URI die wordt gerapporteerd door de XmlReader.

De XmlReader regelgegevens zijn mogelijk geldig of niet. Als u deze optie instelt SetLineInfo, wordt de regelgegevens ingesteld in de XML-structuur van de lijngegevens die door de XmlReaderregel worden gerapporteerd.

Er is een prestatiestraf als u de SetLineInfo vlag instelt.

De regelgegevens zijn direct na het laden van het XML-document nauwkeurig. Als u de XML-structuur wijzigt nadat u het document hebt geladen, kan de regelinformatie betekenisloos worden.

LinQ naar XML-laadfunctionaliteit is gebaseerd op XmlReader. Daarom kunt u eventuele uitzonderingen ondervangen die worden veroorzaakt door de XmlReader.Create overbelastingsmethoden en de XmlReader methoden die het document lezen en parseren.

Zie ook

• Overzicht van LINQ naar XML

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

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

Parameters

Retouren

Een XElement met de inhoud van het opgegeven bestand.

Voorbeelden

In het volgende voorbeeld wordt een XElement bestand op twee verschillende manieren geladen: witruimte behouden en geen witruimte behouden. Vervolgens wordt een query gebruikt om het aantal witruimteknooppunten in de resulterende XML-structuur te bepalen.

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)

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

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

In het volgende voorbeeld worden de basis-URI en regelgegevens geladen terwijl het bestand wordt geladen. Vervolgens worden de basis-URI en de regelgegevens afgedrukt.

In dit voorbeeld wordt het volgende resourcebestand gebruikt: Voorbeeld-XML-bestand: Typische inkooporder (LINQ naar 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

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

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

Opmerkingen

Als de bron-XML is ingesprongen, zorgt het instellen van de PreserveWhitespace vlag options ervoor dat de lezer alle witruimte in de bron-XML leest. Knooppunten van het type XText worden gemaakt voor zowel significante als onbelangrijke witruimte.

Als de bron-XML is ingesprongen, hoeft u de PreserveWhitespace vlag niet in options te stellen, waardoor de lezer alle onbelangrijke witruimte in de bron-XML negeert. De XML-structuur wordt gemaakt zonder tekstknooppunten voor onbeduidende witruimte.

Als de bron-XML niet is ingesprongen, heeft het instellen van de PreserveWhitespace vlag options geen effect. Er blijft nog steeds aanzienlijke witruimte behouden en er zijn geen onbelangrijke witruimte die kan leiden tot het maken van meer witruimtetekstknooppunten.

Zie Witruimte behouden tijdens het laden of parseren van XML en Witruimte behouden tijdens het serialiseren van witruimte voor meer informatie.

Hiermee Parse maakt u een XElement tekenreeks die XML bevat.

Er is een prestatiestraf als u de SetBaseUri en de SetLineInfo vlaggen instelt.

De basis-URI en de regelinformatie zijn direct na het laden van het XML-document nauwkeurig. Als u de XML-structuur wijzigt na het laden van het document, kunnen de basis-URI en regelinformatie betekenisloos worden.

LinQ naar XML-laadfunctionaliteit is gebaseerd op XmlReader. Daarom kunt u eventuele uitzonderingen ondervangen die worden veroorzaakt door de XmlReader.Create overbelastingsmethoden en de XmlReader methoden die het document lezen en parseren.

Zie ook

• Overzicht van LINQ naar XML

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

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

Parameters

Retouren

Een XElement object dat wordt gebruikt om de gegevens te lezen die de stream bevat.

Opmerkingen

LinQ naar XML-laadfunctionaliteit is gebaseerd op XmlReader. Daarom kunt u eventuele uitzonderingen ondervangen die worden veroorzaakt door de XmlReader.Create overbelastingsmethoden en de XmlReader methoden die het document lezen en parseren.

Als u dit moet wijzigen XmlReaderSettings, voert u de volgende stappen uit:

1. Maak een XmlReader door een van de Create overbelastingen aan te roepen die als parameter worden gebruikt XmlReaderSettings .

2. Geef de XmlReader waarde door aan een van de XElementoverbelastingen Load die als parameter worden gebruikt XmlReader .

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

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

Parameters

Retouren

Een XElement met de XML die is gelezen uit de opgegeven TextReader.

Voorbeelden

In het volgende voorbeeld wordt een element uit een 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)

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

<Root>
  <Child />
</Root>

Opmerkingen

Met deze methode wordt de onbewerkte XML in de XML-structuur gelezen. Alle onbelangrijke witruimte in het bestand wordt verwijderd.

LinQ naar XML-laadfunctionaliteit is gebaseerd op XmlReader. Daarom kunt u eventuele uitzonderingen ondervangen die worden veroorzaakt door de XmlReader.Create overbelastingsmethoden en de XmlReader methoden die het document lezen en parseren.

Zie ook

• Overzicht van LINQ naar XML

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

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

Parameters

Retouren

Een XElement met de inhoud van het opgegeven bestand.

Voorbeelden

In het volgende voorbeeld wordt een XML-structuur gemaakt, opgeslagen in een bestand en vervolgens gebruikt u deze methode om het XElement bestand te 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)

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

Root

Opmerkingen

Met deze methode wordt de onbewerkte XML in de XML-structuur gelezen. Alle onbelangrijke witruimte in het bestand wordt verwijderd.

LinQ naar XML-laadfunctionaliteit is gebaseerd op XmlReader. Daarom kunt u eventuele uitzonderingen ondervangen die worden veroorzaakt door de XmlReader.Create overbelastingsmethoden en de XmlReader methoden die het document lezen en parseren.

Zie ook

• Load
• Parse
• Overzicht van LINQ naar XML

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

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

Parameters

Retouren

Een XElement object dat wordt gebruikt om de gegevens te lezen die zich in de stroom bevinden.

Opmerkingen

Als u laadopties wilt beheren, gebruikt u de Load overbelasting die als parameter wordt gebruikt LoadOptions .

LinQ naar XML-laadfunctionaliteit is gebaseerd op XmlReader. Daarom kunt u eventuele uitzonderingen ondervangen die worden veroorzaakt door de XmlReader.Create overbelastingsmethoden en de XmlReader methoden die het document lezen en parseren.

Als u dit moet wijzigen XmlReaderSettings, voert u de volgende stappen uit:

1. Maak een XmlReader door een van de Create overbelastingen aan te roepen die als parameter worden gebruikt XmlReaderSettings .

2. Geef de XmlReader waarde door aan een van de XElementoverbelastingen Load die als parameter worden gebruikt XmlReader .

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

XElement.cs

Bron:

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

Parameters

Retouren

Een XElement met de XML die is gelezen uit de opgegeven XmlReader.

Voorbeelden

In het volgende voorbeeld wordt een DOM-document gemaakt, een XmlNodeReader van het DOM-document gemaakt, een structuur gemaakt van de lezer. Met deze code wordt een DOM-document in een LINQ naar de XML-structuur gekopieerd.

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

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

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

Opmerkingen

Door een XmlNodeReader van een DOM-document te maken en vervolgens de methode XmlNodeReader te gebruiken om een XElementDOM-document te maken, kan deze methode worden gebruikt om een kopie van een DOM-document in een LINQ naar xml-structuur te maken.

LinQ naar XML-laadfunctionaliteit is gebaseerd op XmlReader. Daarom kunt u eventuele uitzonderingen ondervangen die worden veroorzaakt door de XmlReader.Create overbelastingsmethoden en de XmlReader methoden die het document lezen en parseren.

Zie ook

• Overzicht van LINQ naar XML