Programmeren met knooppunten (LINQ naar XML)

LINQ naar XML-ontwikkelaars die programma's moeten schrijven, zoals een XML-editor, een transformatiesysteem of een rapportschrijver, hebben vaak code nodig die werkt op een nauwkeuriger granulariteitsniveau dan elementen en kenmerken. Ze moeten vaak op knooppuntniveau werken, tekstknooppunten bewerken, instructies verwerken en opmerkingen verwerken. Dit artikel bevat informatie over programmeren op knooppuntniveau.

Voorbeeld: De Parent eigenschapswaarden van de onderliggende knooppunten van XDocument zijn ingesteld op null

De Parent eigenschap bevat de bovenliggende XElement, niet het bovenliggende knooppunt. De onderliggende knooppunten van XDocument hebben geen bovenliggende XElement. Hun ouder is het document, dus de Parent-eigenschap voor deze knooppunten wordt ingesteld op null.

In het volgende voorbeeld ziet u dit:

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 dit voorbeeld wordt de volgende uitvoer gegenereerd:

True
True

Voorbeeld: Het toevoegen van tekst kan al dan niet een nieuw tekstknooppunt maken

In een aantal XML-programmeermodellen worden aangrenzende tekstknooppunten altijd samengevoegd. Dit wordt ook wel normalisatie van tekstknooppunten genoemd. LINQ naar XML normaliseert geen tekstknooppunten. Als u twee tekstknooppunten aan hetzelfde element toevoegt, resulteert dit in aangrenzende tekstknooppunten. Als u echter inhoud toevoegt die is opgegeven als een tekenreeks in plaats van als een XText knooppunt, kan LINQ aan XML de tekenreeks samenvoegen met een aangrenzend tekstknooppunt. In het volgende voorbeeld ziet u dit.

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 dit voorbeeld wordt de volgende uitvoer gegenereerd:

1
1
2

Voorbeeld: Als u een waarde voor een tekstknooppunt instelt op de lege tekenreeks, wordt het knooppunt niet verwijderd

In sommige XML-programmeermodellen bevatten tekstknooppunten gegarandeerd niet de lege tekenreeks. De redenering is dat een dergelijk tekstknooppunt geen invloed heeft op de serialisatie van de XML. Om dezelfde reden dat aangrenzende tekstknooppunten mogelijk zijn, wordt het tekstknooppunt zelf niet verwijderd als u de tekst uit een tekstknooppunt verwijdert door de waarde ervan in te stellen op de lege tekenreeks.

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 dit voorbeeld wordt de volgende uitvoer gegenereerd:

>><<

Voorbeeld: Een element met één leeg tekstknooppunt wordt anders geserialiseerd dan een knooppunt zonder tekstknooppunt

Als een element alleen een onderliggend tekstknooppunt bevat dat leeg is, wordt het geserialiseerd met de lange tagsyntaxis: <Child></Child>. Als een element geen onderliggende knooppunten bevat, wordt het geserialiseerd met de syntaxis van de korte tag: <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 dit voorbeeld wordt de volgende uitvoer gegenereerd:

<Child1></Child1>
<Child2 />

Voorbeeld: Namespaces zijn attributen in de LINQ to XML-structuur

Hoewel naamruimtedeclaraties identieke syntaxis hebben aan kenmerken, worden in sommige programmeerinterfaces, zoals XSLT en XPath, naamruimtedeclaraties niet beschouwd als kenmerken. In LINQ naar XML worden naamruimten echter opgeslagen als XAttribute objecten in de XML-structuur. Als u de kenmerken doorloopt van een element dat een naamruimtedeclaratie bevat, is de declaratie van de naamruimte een van de items in de geretourneerde verzameling. De IsNamespaceDeclaration eigenschap geeft aan of een kenmerk een naamruimtedeclaratie is.

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 dit voorbeeld wordt de volgende uitvoer gegenereerd:

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

Voorbeeld: De asmethoden van XPath retourneren niet de kindtekstknopen van XDocument

LINQ naar XML staat toe dat kindtekstknooppunten van een XDocument worden gemaakt, zolang de tekstknooppunten alleen uit witruimte bestaan. Het XPath-objectmodel bevat echter geen witruimte als onderliggende knooppunten van een document, dus wanneer u de onderliggende elementen van een XDocument object met behulp van de Nodes as doorloopt, worden tekstknooppunten met witruimte geretourneerd. Wanneer u echter door de kinderen van een XDocument met de XPath-asmethoden bladert, worden tekstknooppunten met witruimte niet geretourneerd.

// 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 dit voorbeeld wordt de volgende uitvoer gegenereerd:

3
0

Het knooppunt XML-declaratie van een XDocument is een eigenschap, niet een kindknooppunt

Wanneer u de onderliggende knooppunten van een XDocument-object doorloopt, ziet u het XML-declaratieobject niet. Het is een eigenschap van het document, niet een onderliggend knooppunt.

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 dit voorbeeld wordt de volgende uitvoer gegenereerd:

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