XElement.Load Méthode

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

Paramètres

Retours

XElement

XElement qui contient le code XML qui a été lu à partir du TextReaderspécifié.

Exemples

L’exemple suivant charge une XElement d’une StringReader manière différente : préserver l’espace blanc et ne pas conserver l’espace blanc. Il utilise ensuite une requête pour déterminer le nombre de nœuds d’espace blanc dans l’arborescence XML résultante.

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)  

Cet exemple produit la sortie suivante :

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

L’exemple suivant charge les informations de ligne au fur et à mesure qu’elle se charge à partir du TextReader. Il imprime ensuite les informations de ligne.

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  

Cet exemple produit la sortie suivante :

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

Remarques

Si le code XML source est mis en retrait, la définition de l’indicateur PreserveWhitespace entraîne options la lecture de tous les espaces blancs dans le code XML source. Les nœuds de type XText sont créés pour un espace blanc significatif et non significatif.

Si le code XML source est mis en retrait, ne définissez pas l’indicateur PreserveWhitespace dans options lequel le lecteur doit ignorer tous les espaces blancs non significatifs dans le code XML source. L’arborescence XML est créée sans aucun nœud de texte pour un espace blanc non significatif.

Si le code XML source n’est pas mis en retrait, la définition de l’indicateur PreserveWhitespace n’a options aucun effet. L’espace blanc important est toujours conservé et il n’y a pas d’étendues d’espace blanc non significatif qui pourrait entraîner la création de nœuds de texte d’espace blanc plus.

Pour plus d’informations, consultez Conserver l’espace blanc lors du chargement ou de l’analyse du code XML et conserver l’espace blanc lors de la sérialisation.

Permet Parse de créer une XElement chaîne contenant du code XML.

Le paramètre SetBaseUri n’a aucun effet lors du chargement à partir d’un TextReader.

Il existe une pénalité de performance si vous définissez l’indicateur SetLineInfo .

Les informations de ligne sont exactes immédiatement après le chargement du document XML. Si vous modifiez l’arborescence XML après le chargement du document, les informations de ligne peuvent devenir sans signification.

LINQ to XML la fonctionnalité de chargement est basée sur XmlReader. Par conséquent, vous pouvez intercepter les exceptions levées par les XmlReader.Create méthodes de surcharge et les XmlReader méthodes qui lisent et analysent le document.

Voir aussi

• Vue d’ensemble de 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

Paramètres

Retours

XElement

XElement qui contient le code XML qui a été lu à partir du XmlReaderspécifié.

Exemples

L’exemple suivant charge les informations de ligne qu’il charge à partir du XmlReader. Il imprime ensuite les informations de ligne.

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  

Cet exemple produit la sortie suivante :

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

Remarques

En créant un XmlNodeReader document DOM, puis en utilisant le XmlNodeReader pour créer un XElement, cette méthode peut être utilisée pour créer une copie d’un document DOM dans une arborescence de LINQ to XML.

Permet Parse de créer une XElement chaîne contenant du code XML.

Le paramètre PreserveWhitespace n’est pas valide lors du chargement à partir d’un XmlReader. L’espace XmlReader blanc est configuré pour lire ou non l’espace blanc. L’arborescence LINQ to XML sera remplie avec les nœuds d’espace blanc que le lecteur surface. Il s’agit du PreserveWhitespace comportement, que ce soit défini ou non.

L’URI XmlReader de base peut avoir un URI de base valide ou non. Si vous définissez SetBaseUri, l’URI de base est défini dans l’arborescence XML à partir de l’URI de base signalé par le XmlReader.

Il XmlReader peut avoir des informations de ligne valides ou non. Si vous définissez SetLineInfo, les informations de ligne sont définies dans l’arborescence XML à partir des informations de ligne signalées par le XmlReader.

Il existe une pénalité de performance si vous définissez l’indicateur SetLineInfo .

Les informations de ligne sont exactes immédiatement après le chargement du document XML. Si vous modifiez l’arborescence XML après le chargement du document, les informations de ligne peuvent devenir sans signification.

LINQ to XML la fonctionnalité de chargement est basée sur XmlReader. Par conséquent, vous pouvez intercepter les exceptions levées par les XmlReader.Create méthodes de surcharge et les XmlReader méthodes qui lisent et analysent le document.

Voir aussi

• Vue d’ensemble de 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

Paramètres

Retours

XElement

XElement qui contient le contenu du fichier spécifié.

Exemples

L’exemple suivant charge un XElement fichier de deux façons différentes : préserver l’espace blanc et ne pas conserver l’espace blanc. Il utilise ensuite une requête pour déterminer le nombre de nœuds d’espace blanc dans l’arborescence XML résultante.

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)  

Cet exemple produit la sortie suivante :

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

L’exemple suivant charge l’URI de base et les informations de ligne quand il charge le fichier. Il imprime ensuite l’URI de base et les informations de ligne.

Cet exemple utilise le fichier de ressources suivant : Exemple de fichier XML : Ordre d’achat standard (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  

Cet exemple produit la sortie suivante :

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  

Remarques

Si le code XML source est mis en retrait, la définition de l’indicateur PreserveWhitespace entraîne options la lecture de tous les espaces blancs dans le code XML source. Les nœuds de type XText sont créés pour un espace blanc significatif et non significatif.

Si le code XML source est mis en retrait, ne définissez pas l’indicateur PreserveWhitespace dans options lequel le lecteur doit ignorer tous les espaces blancs non significatifs dans le code XML source. L’arborescence XML est créée sans aucun nœud de texte pour un espace blanc non significatif.

Si le code XML source n’est pas mis en retrait, la définition de l’indicateur PreserveWhitespace n’a options aucun effet. L’espace blanc important est toujours conservé et il n’y a pas d’étendues d’espace blanc non significatif qui pourrait entraîner la création de nœuds de texte d’espace blanc plus.

Pour plus d’informations, consultez Conserver l’espace blanc lors du chargement ou de l’analyse du code XML et conserver l’espace blanc lors de la sérialisation.

Permet Parse de créer une XElement chaîne contenant du code XML.

Il existe une pénalité de performance si vous définissez les indicateurs et les SetBaseUri SetLineInfo indicateurs.

L’URI de base et les informations de ligne sont exactes immédiatement après le chargement du document XML. Si vous modifiez l’arborescence XML après le chargement du document, l’URI de base et les informations de ligne peuvent devenir sans signification.

LINQ to XML la fonctionnalité de chargement est basée sur XmlReader. Par conséquent, vous pouvez intercepter les exceptions levées par les XmlReader.Create méthodes de surcharge et les XmlReader méthodes qui lisent et analysent le document.

Voir aussi

• Vue d’ensemble de 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

Paramètres

Retours

XElement

Objet XElement permettant de lire les données contenues dans le flux de données.

Remarques

LINQ to XML la fonctionnalité de chargement est basée sur XmlReader. Par conséquent, vous pouvez intercepter les exceptions levées par les XmlReader.Create méthodes de surcharge et les XmlReader méthodes qui lisent et analysent le document.

Si vous devez modifier XmlReaderSettings, procédez comme suit :

1. Créez un XmlReader en appelant l’une des Create surcharges qui prennent XmlReaderSettings en tant que paramètre.

2. Passez l’une XmlReader des XElementLoad surcharges qui prend XmlReader en tant que paramètre.

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

Paramètres

Retours

XElement

XElement qui contient le code XML qui a été lu à partir du TextReaderspécifié.

Exemples

L’exemple suivant charge un élément à partir d’un 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)  

Cet exemple produit la sortie suivante :

<Root>  
  <Child />  
</Root>  

Remarques

Cette méthode lit le xml brut dans l’arborescence XML. Il ignore tous les espaces blancs non significatifs dans le fichier.

LINQ to XML la fonctionnalité de chargement est basée sur XmlReader. Par conséquent, vous pouvez intercepter les exceptions levées par les XmlReader.Create méthodes de surcharge et les XmlReader méthodes qui lisent et analysent le document.

Voir aussi

• Vue d’ensemble de 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

Paramètres

Retours

XElement

XElement qui contient le contenu du fichier spécifié.

Exemples

L’exemple suivant crée une arborescence XML, l’enregistre dans un fichier, puis utilise cette méthode pour charger le XElement fichier à partir du fichier.

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)  

Cet exemple produit la sortie suivante :

Root  

Remarques

Cette méthode lit le xml brut dans l’arborescence XML. Il ignore tous les espaces blancs non significatifs dans le fichier.

LINQ to XML la fonctionnalité de chargement est basée sur XmlReader. Par conséquent, vous pouvez intercepter les exceptions levées par les XmlReader.Create méthodes de surcharge et les XmlReader méthodes qui lisent et analysent le document.

Voir aussi

• Load
• Parse
• Vue d’ensemble de 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

Paramètres

Retours

XElement

Objet XElement permettant de lire les données contenues dans le flux de données.

Remarques

Si vous souhaitez contrôler les options de charge, utilisez la Load surcharge qui prend LoadOptions en tant que paramètre.

LINQ to XML la fonctionnalité de chargement est basée sur XmlReader. Par conséquent, vous pouvez intercepter les exceptions levées par les XmlReader.Create méthodes de surcharge et les XmlReader méthodes qui lisent et analysent le document.

Si vous devez modifier XmlReaderSettings, procédez comme suit :

1. Créez un XmlReader en appelant l’une des Create surcharges qui prennent XmlReaderSettings en tant que paramètre.

2. Passez l’une XmlReader des XElementLoad surcharges qui prend XmlReader en tant que paramètre.

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

Paramètres

Retours

XElement

XElement qui contient le code XML qui a été lu à partir du XmlReaderspécifié.

Exemples

L’exemple suivant crée un document DOM, crée un XmlNodeReader document DOM, instancie une arborescence à partir du lecteur. Ce code copie efficacement un document DOM dans une arborescence LINQ to XML.

// Create a DOM document with some content.  
XmlDocument doc = new XmlDocument();  
XmlElement child = doc.CreateElement("Child");  
child.InnerText = "child contents";  
XmlElement root = doc.CreateElement("Root");  
root.AppendChild(child);  
doc.AppendChild(root);  

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

    XElement xRoot = XElement.Load(nodeReader);  
    Console.WriteLine(xRoot);  
}  

' Create a DOM document with some content.  
Dim doc As XmlDocument = New XmlDocument()  
Dim child As XmlElement = doc.CreateElement("Child")  
child.InnerText = "child contents"  
Dim root As XmlElement = doc.CreateElement("Root")  
root.AppendChild(child)  
doc.AppendChild(root)  

' Create a reader and move to the content.  
Using nodeReader = New XmlNodeReader(doc)  
    ' the reader must be in the Interactive state in order to  
    ' Create a LINQ to XML tree from it.  
    nodeReader.MoveToContent()  

    Dim xRoot As XElement = XElement.Load(nodeReader)  
    Console.WriteLine(xRoot)  
End Using  

Cet exemple produit la sortie suivante :

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

Remarques

En créant un XmlNodeReader document DOM, puis en utilisant le XmlNodeReader pour créer un XElement, cette méthode peut être utilisée pour créer une copie d’un document DOM dans une arborescence de LINQ to XML.

LINQ to XML la fonctionnalité de chargement est basée sur XmlReader. Par conséquent, vous pouvez intercepter les exceptions levées par les XmlReader.Create méthodes de surcharge et les XmlReader méthodes qui lisent et analysent le document.

Voir aussi

• Vue d’ensemble de LINQ to XML