Programmation avec des nœuds (LINQ to XML)

Les développeurs LINQ to XML qui ont besoin d’écrire des programmes tels qu’un éditeur XML, un système de transformation ou un enregistreur de rapports ont souvent besoin de code qui fonctionne à un niveau de granularité plus précis que les éléments et les attributs. Ils doivent souvent fonctionner au niveau du nœud, manipuler des nœuds de texte, traiter des instructions et traiter des commentaires. Cet article fournit des informations sur la programmation au niveau du nœud.

Exemple : les Parent valeurs de propriété des nœuds enfants de XDocument sont définies sur null

La Parent propriété contient le parent XElement, et non le nœud parent. Les nœuds enfants n’ont pas de XDocument parent XElement. Leur parent est le document. Par conséquent, la Parent propriété de ces nœuds est définie nullsur .

Cela est illustré par l'exemple suivant :

XDocument doc = XDocument.Parse(@"<!-- a comment --><Root/>");
Console.WriteLine(doc.Nodes().OfType<XComment>().First().Parent == null);
Console.WriteLine(doc.Root.Parent == null);

Dim doc As XDocument = XDocument.Parse("<!-- a comment --><Root/>")
Console.WriteLine(doc.Nodes().OfType(Of XComment).First().Parent Is Nothing)
Console.WriteLine(doc.Root.Parent Is Nothing)

Cet exemple génère la sortie suivante :

True
True

Exemple : l’ajout de texte peut ou non créer un nœud de texte

Dans un certain nombre de modèles de programmation XML, les nœuds de texte adjacents sont toujours fusionnés. Il s’agit parfois de la normalisation des nœuds de texte. LINQ to XML ne normalise pas les nœuds de texte. Si vous ajoutez deux nœuds de texte au même élément, cela entraîne des nœuds de texte adjacents. Toutefois, si vous ajoutez du contenu spécifié en tant que chaîne plutôt qu’en tant que XText nœud, LINQ to XML peut fusionner la chaîne avec un nœud de texte adjacent. l’exemple ci-dessous illustre ce cas de figure.

XElement xmlTree = new XElement("Root", "Content");

Console.WriteLine(xmlTree.Nodes().OfType<XText>().Count());

// this doesn't add a new text node
xmlTree.Add("new content");
Console.WriteLine(xmlTree.Nodes().OfType<XText>().Count());

// this does add a new, adjacent text node
xmlTree.Add(new XText("more text"));
Console.WriteLine(xmlTree.Nodes().OfType<XText>().Count());

Dim xmlTree As XElement = <Root>Content</Root>
Console.WriteLine(xmlTree.Nodes().OfType(Of XText)().Count())

' This doesn't add a new text node.
xmlTree.Add("new content")
Console.WriteLine(xmlTree.Nodes().OfType(Of XText)().Count())

'// This does add a new, adjacent text node.
xmlTree.Add(New XText("more text"))
Console.WriteLine(xmlTree.Nodes().OfType(Of XText)().Count())

Cet exemple génère la sortie suivante :

1
1
2

Exemple : la définition d’une valeur de nœud de texte sur la chaîne vide ne supprime pas le nœud

Dans certains modèles de programmation XML, les nœuds de texte sont garantis de ne pas contenir la chaîne vide. Le raisonnement est qu’un tel nœud de texte n’a aucun impact sur la sérialisation du code XML. Toutefois, pour la même raison que les nœuds de texte adjacents sont possibles, si vous supprimez le texte d’un nœud de texte en définissant sa valeur sur la chaîne vide, le nœud de texte lui-même ne sera pas supprimé.

XElement xmlTree = new XElement("Root", "Content");
XText textNode = xmlTree.Nodes().OfType<XText>().First();

// the following line doesn't cause the removal of the text node.
textNode.Value = "";

XText textNode2 = xmlTree.Nodes().OfType<XText>().First();
Console.WriteLine(">>{0}<<", textNode2);

Dim xmlTree As XElement = <Root>Content</Root>
Dim textNode As XText = xmlTree.Nodes().OfType(Of XText)().First()

' The following line doesn't cause the removal of the text node.
textNode.Value = ""

Dim textNode2 As XText = xmlTree.Nodes().OfType(Of XText)().First()
Console.WriteLine(">>{0}<<", textNode2)

Cet exemple génère la sortie suivante :

>><<

Exemple : un élément avec un nœud de texte vide est sérialisé différemment d’un nœud de texte sans nœud de texte

Si un élément contient uniquement un nœud de texte enfant vide, il est sérialisé avec la syntaxe de balise longue : <Child></Child>. Si un élément ne contient aucun nœud enfant, il est sérialisé avec la syntaxe de balise courte : <Child />.

XElement child1 = new XElement("Child1",
    new XText("")
);
XElement child2 = new XElement("Child2");
Console.WriteLine(child1);
Console.WriteLine(child2);

Dim child1 As XElement = New XElement("Child1", _
    New XText("") _
)
Dim child2 As XElement = New XElement("Child2")
Console.WriteLine(child1)
Console.WriteLine(child2)

Cet exemple génère la sortie suivante :

<Child1></Child1>
<Child2 />

Exemple : Les espaces de noms sont des attributs dans l’arborescence LINQ to XML

Même si les déclarations d’espace de noms ont une syntaxe identique aux attributs, dans certaines interfaces de programmation, telles que XSLT et XPath, les déclarations d’espace de noms ne sont pas considérées comme des attributs. Toutefois, dans LINQ to XML, les espaces de noms sont stockés en tant qu’objets XAttribute dans l’arborescence XML. Si vous effectuez une itération dans les attributs d’un élément qui contient une déclaration d’espace de noms, la déclaration d’espace de noms est l’un des éléments de la collection retournée. La IsNamespaceDeclaration propriété indique si un attribut est une déclaration d’espace de noms.

XElement root = XElement.Parse(
@"<Root
    xmlns='http://www.adventure-works.com'
    xmlns:fc='www.fourthcoffee.com'
    AnAttribute='abc'/>");
foreach (XAttribute att in root.Attributes())
    Console.WriteLine("{0}  IsNamespaceDeclaration:{1}", att, att.IsNamespaceDeclaration);

Dim root As XElement = _
<Root
    xmlns='http://www.adventure-works.com'
    xmlns:fc='www.fourthcoffee.com'
    AnAttribute='abc'/>
For Each att As XAttribute In root.Attributes()
    Console.WriteLine("{0}  IsNamespaceDeclaration:{1}", att, _
                      att.IsNamespaceDeclaration)
Next

Cet exemple génère la sortie suivante :

xmlns="http://www.adventure-works.com"  IsNamespaceDeclaration:True
xmlns:fc="www.fourthcoffee.com"  IsNamespaceDeclaration:True
AnAttribute="abc"  IsNamespaceDeclaration:False

Exemple : les méthodes d’axe XPath ne retournent pas les nœuds de texte enfants de XDocument

LINQ to XML autorise les nœuds de texte enfants d’un XDocument, tant que les nœuds de texte contiennent uniquement des espaces blancs. Toutefois, le modèle objet XPath n’inclut pas d’espace blanc en tant que nœuds enfants d’un document. Par conséquent, lorsque vous effectuez une itération au sein des enfants d’un XDocument axe à l’aide de l’axe Nodes , les nœuds de texte d’espace blanc sont renvoyés. Toutefois, lorsque vous effectuez une itération au sein des enfants d’une XDocument méthode d’axe XPath, les nœuds de texte d’espace blanc ne sont pas retournés.

// Create a document with some white space child nodes of the document.
XDocument root = XDocument.Parse(
@"<?xml version='1.0' encoding='utf-8' standalone='yes'?>

<Root/>

<!--a comment-->
", LoadOptions.PreserveWhitespace);

// count the white space child nodes using LINQ to XML
Console.WriteLine(root.Nodes().OfType<XText>().Count());

// count the white space child nodes using XPathEvaluate
Console.WriteLine(((IEnumerable)root.XPathEvaluate("text()")).OfType<XText>().Count());

' Create a document with some white space child nodes of the document.
Dim root As XDocument = XDocument.Parse( _
"<?xml version='1.0' encoding='utf-8' standalone='yes'?>" & _
vbNewLine & "<Root/>" & vbNewLine & "<!--a comment-->" & vbNewLine, _
LoadOptions.PreserveWhitespace)

' Count the white space child nodes using LINQ to XML.
Console.WriteLine(root.Nodes().OfType(Of XText)().Count())

' Count the white space child nodes using XPathEvaluate.
Dim nodes As IEnumerable = CType(root.XPathEvaluate("text()"), IEnumerable)
Console.WriteLine(nodes.OfType(Of XText)().Count())

Cet exemple génère la sortie suivante :

3
0

Le nœud de déclaration XML d’un XDocument est une propriété, et non un nœud enfant

Lorsque vous effectuez une itération via les nœuds enfants d’un XDocument, vous ne verrez pas l’objet de déclaration XML. Il s’agit d’une propriété du document, et non d’un nœud enfant.

XDocument doc = new XDocument(
    new XDeclaration("1.0", "utf-8", "yes"),
    new XElement("Root")
);
doc.Save("Temp.xml");
Console.WriteLine(File.ReadAllText("Temp.xml"));

// this shows that there is only one child node of the document
Console.WriteLine(doc.Nodes().Count());

Dim doc As XDocument = _
<?xml version='1.0' encoding='utf-8' standalone='yes'?>
<Root/>

doc.Save("Temp.xml")
Console.WriteLine(File.ReadAllText("Temp.xml"))

' This shows that there is only one child node of the document.
Console.WriteLine(doc.Nodes().Count())

Cet exemple génère la sortie suivante :

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Root />
1