Programmazione con nodi (LINQ to XML)

Gli sviluppatori LINQ to XML che devono scrivere programmi come un editor XML, un sistema di trasformazione o un writer di report spesso necessitano di codice che funzioni a un livello di granularità più fine rispetto a elementi e attributi. Spesso devono lavorare a livello di nodo, modificare nodi di testo, istruzioni di elaborazione ed elaborazione dei commenti. Questo articolo fornisce informazioni sulla programmazione a livello di nodo.

Esempio: i Parent valori delle proprietà dei nodi figlio di XDocument sono impostati su null

La Parent proprietà contiene l'elemento padre XElement, non il nodo padre. I nodi figlio di XDocument non hanno padre XElement. Il relativo elemento padre è il documento, quindi la Parent proprietà per tali nodi è impostata su null.

Nell'esempio seguente viene illustrato quanto segue:

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)

In questo esempio viene generato l'output seguente:

True
True

Esempio: l'aggiunta di testo può o meno creare un nuovo nodo di testo

In diversi modelli di programmazione XML, i nodi di testo adiacenti vengono sempre uniti. Questa operazione viene talvolta definita normalizzazione dei nodi di testo. LINQ to XML non normalizza i nodi di testo. Se si aggiungono due nodi di testo allo stesso elemento, verranno visualizzati nodi di testo adiacenti. Tuttavia, se si aggiunge contenuto specificato come stringa anziché come XText nodo, LINQ to XML potrebbe unire la stringa con un nodo di testo adiacente. L'esempio seguente illustra questa operazione.

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())

In questo esempio viene generato l'output seguente:

1
1
2

Esempio: l'impostazione di un valore del nodo di testo sulla stringa vuota non comporta l'eliminazione del nodo

In alcuni modelli di programmazione XML, i nodi di testo non contengono la stringa vuota. Il motivo è che tale nodo di testo non ha alcun impatto sulla serializzazione del codice XML. Tuttavia, per lo stesso motivo per cui sono possibili nodi di testo adiacenti, se si rimuove il testo da un nodo di testo impostandone il valore sulla stringa vuota, il nodo di testo stesso non verrà eliminato.

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)

In questo esempio viene generato l'output seguente:

>><<

Esempio: un elemento con un nodo di testo vuoto viene serializzato in modo diverso da uno senza nodo di testo

Se un elemento contiene solo un nodo di testo figlio vuoto, viene serializzato con la sintassi dei tag lunghi: <Child></Child>. Se un elemento non contiene assolutamente nessun nodo figlio, viene serializzato con la sintassi di tag breve: <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)

In questo esempio viene generato l'output seguente:

<Child1></Child1>
<Child2 />

Esempio: Gli spazi dei nomi sono attributi nell'albero LINQ to XML

Anche se le dichiarazioni dello spazio dei nomi hanno una sintassi identica agli attributi, in alcune interfacce di programmazione, ad esempio XSLT e XPath, le dichiarazioni dello spazio dei nomi non vengono considerate attributi. Tuttavia, in LINQ to XML, i namespace vengono archiviati come oggetti XAttribute nell'albero XML. Quando si iterano gli attributi di un elemento che contiene una dichiarazione dello spazio dei nomi, la dichiarazione dello spazio dei nomi è uno degli elementi restituiti nella raccolta. La IsNamespaceDeclaration proprietà indica se un attributo è una dichiarazione dello spazio dei nomi.

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

In questo esempio viene generato l'output seguente:

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

Esempio: i metodi dell'asse XPath non restituiscono i nodi di testo figlio di XDocument

LINQ to XML consente i nodi di testo figlio di un oggettoXDocument, purché i nodi di testo contengano solo spazi bianchi. Tuttavia, il modello a oggetti XPath non include spazi vuoti come nodi figlio di un documento, quindi quando si scorre gli elementi figlio di un XDocument oggetto usando l'asse Nodes , verranno restituiti nodi di testo di spazio vuoto. Tuttavia, quando si scorre gli elementi figlio di un oggetto XDocument usando i metodi dell'asse XPath, i nodi di testo dello spazio vuoto non verranno restituiti.

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

In questo esempio viene generato l'output seguente:

3
0

Il nodo di dichiarazione XML di un XDocument è una proprietà, non un nodo figlio

Quando si scorre i nodi figlio di un oggetto XDocument, non è possibile visualizzare l'oggetto dichiarazione XML. La proprietà appartiene al documento e non è un nodo figlio di esso.

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())

In questo esempio viene generato l'output seguente:

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