Programmieren mit Knoten (C#)Programming with Nodes (C#)

LINQ to XML-Entwickler, die Programme, wie einen XML-Editor, ein Transformationssystem oder einen Berichts-Generator schreiben müssen, müssen häufig Programme schreiben, die auf einer detaillierteren Ebene als Elemente und Attribute arbeiten. developers who need to write programs such as an XML editor, a transform system, or a report writer often need to write programs that work at a finer level of granularity than elements and attributes. Sie müssen oft auf der Ebene der Knoten arbeiten und dabei Textknoten, Verarbeitungsanweisungen und Kommentare bearbeiten.They often need to work at the node level, manipulating text nodes, processing instructions, and comments. Dieses Thema beschäftigt sich mit einigen Aspekten des Programmierens auf Knotenebene.This topic provides some details about programming at the node level.

KnotendetailsNode Details

Es gibt eine Reihe von Programmierdetails, die ein auf der Knotenebene arbeitender Programmierer kennen sollte.There are a number of details of programming that a programmer working at the node level should know.

Übergeordnete Eigenschaft der untergeordneten XDocument-Knoten ist gleich NULLParent Property of Children Nodes of XDocument is Set to Null

Die Parent-Eigenschaft enthält das übergeordnete XElement, nicht den übergeordneten Knoten.The Parent property contains the parent XElement, not the parent node. Für untergeordnete Knoten von XDocument gibt es kein übergeordnetes XElement.Child nodes of XDocument have no parent XElement. Ihr übergeordnetes Element ist das Dokument, weshalb die Parent-Eigenschaft dieser Knoten gleich NULL ist.Their parent is the document, so the Parent property for those nodes is set to null.

Dies wird im folgenden Beispiel veranschaulicht:The following example demonstrates this:

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

Dieses Beispiel erzeugt die folgende Ausgabe:This example produces the following output:

True  
True  

Textknoten können nebeneinander liegenAdjacent Text Nodes are Possible

In einer Reihe von XML-Programmiermodellen werden nebeneinander liegende Textknoten immer zusammengeführt.In a number of XML programming models, adjacent text nodes are always merged. Dies wird mitunter als Normalisierung von Textknoten bezeichnet.This is sometimes called normalization of text nodes. In LINQ to XML findet keine Normalisierung von Textknoten statt.LINQ to XML does not normalize text nodes. Wenn Sie einem Element zwei Textknoten hinzufügen, erhalten Sie zwei nebeneinander liegende Textknoten.If you add two text nodes to the same element, it will result in adjacent text nodes. Wird jedoch Inhalt in Form einer Zeichenfolge statt als XText-Knoten hinzugefügt, kann LINQ to XML die Zeichenfolge mit einem angrenzenden Textknoten zusammenführen.However, if you add content specified as a string rather than as an XText node, LINQ to XML might merge the string with an adjacent text node.

Dies wird im folgenden Beispiel veranschaulicht:The following example demonstrates this:

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

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

// this does not 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());  

Dieses Beispiel erzeugt die folgende Ausgabe:This example produces the following output:

1  
1  
2  

Textknoten können leer seinEmpty Text Nodes are Possible

In einigen XML-Programmiermodellen ist garantiert, dass Textknoten keine leere Zeichenfolge enthalten.In some XML programming models, text nodes are guaranteed to not contain the empty string. Der Grund dafür ist, dass ein Textknoten keine Auswirkungen auf die Serialisierung des XML-Codes haben.The reasoning is that such a text node has no impact on serialization of the XML. Aber aus demselben Grund, aus dem Textknoten nebeneinander liegen können, wird der Textknoten auch nicht gelöscht, wenn Sie den Text aus ihm entfernen, indem Sie eine leere Zeichenfolge als Wert für den Textknoten festlegen.However, for the same reason that adjacent text nodes are possible, if you remove the text from a text node by setting its value to the empty string, the text node itself will not be deleted.

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

// the following line does not cause the removal of the text node.  
textNode.Value = "";  

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

Dieses Beispiel erzeugt die folgende Ausgabe:This example produces the following output:

>><<  

Ein leerer Textknoten wirkt sich auf die Serialisierung ausAn Empty Text Node Impacts Serialization

Wenn ein Element nur einen untergeordneten Textknoten enthält, der leer ist, wird es mit der langen Tagsyntax serialisiert: <Child></Child>.If an element contains only a child text node that is empty, it is serialized with the long tag syntax: <Child></Child>. Wenn ein Element überhaupt keine untergeordneten Knoten enthält, wird es mit der kurzen Tagsyntax serialisiert: <Child />.If an element contains no child nodes whatsoever, it is serialized with the short tag syntax: <Child />.

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

Dieses Beispiel erzeugt die folgende Ausgabe:This example produces the following output:

<Child1></Child1>  
<Child2 />  

Namespaces sind Attribute in der LINQ to XML-StrukturNamespaces are Attributes in the LINQ to XML Tree

Auch wenn Namespacedeklarationen dieselbe Syntax wie Attribute haben, werden Namespacedeklarationen in einigen Programmierschnittstellen, wie XSLT und XPath, nicht als Attribute betrachtet.Even though namespace declarations have identical syntax to attributes, in some programming interfaces, such as XSLT and XPath, namespace declarations are not considered to be attributes. In LINQ to XML werden Namespaces jedoch als XAttribute-Objekte in der XML-Struktur gespeichert.However, in LINQ to XML, namespaces are stored as XAttribute objects in the XML tree. Wenn Sie die Attribute für ein Element durchlaufen, das eine Namespacedeklaration enthält, wird die Namespacedeklaration als eines der Elemente in der zurückgegebenen Auflistung angezeigt.If you iterate through the attributes for an element that contains a namespace declaration, you will see the namespace declaration as one of the items in the returned collection.

Die IsNamespaceDeclaration-Eigenschaft gibt an, ob ein Attribut eine Namespacedeklaration ist.The IsNamespaceDeclaration property indicates whether an attribute is a namespace declaration.

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

Dieses Beispiel erzeugt die folgende Ausgabe:This example produces the following output:

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

XPath-Achsenmethoden geben keinen untergeordneten XDocument-Leerraum zurückXPath Axis Methods Do Not Return Child White Space of XDocument

LINQ to XML ermöglicht untergeordnete Textknoten eines XDocument, solange die Textknoten nur Leerraum enthalten. allows for child text nodes of an XDocument, as long as the text nodes contain only white space. Das XPath-Objektmodell sieht jedoch keinen Leerraum als untergeordnete Knoten eines Dokuments vor. Das hat zur Folge, dass beim Durchlaufen der untergeordneten Elemente eines XDocument mit der Nodes-Achse Leerraumtextknoten zurückgegeben werden.However, the XPath object model does not include white space as child nodes of a document, so when you iterate through the children of an XDocument using the Nodes axis, white space text nodes will be returned. Werden dagegen die untergeordneten Elemente eines XDocument mit den XPath-Achsenmethoden durchlaufen, erfolgt keine Rückgabe von Leerraumtextknoten.However, when you iterate through the children of an XDocument using the XPath axis methods, white space text nodes will not be returned.

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

Dieses Beispiel erzeugt die folgende Ausgabe:This example produces the following output:

3  
0  

XDeclaration-Objekte sind keine KnotenXDeclaration Objects are not Nodes

Wenn Sie die untergeordneten Elemente eines XDocument-Objekts durchlaufen, wird das XML-Deklarationsobjekt nicht angezeigt.When you iterate through the children nodes of an XDocument, you will not see the XML declaration object. Es ist kein untergeordneter Knoten des Dokuments, sondern eine seiner Eigenschaften.It is a property of the document, not a child node of it.

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

Dieses Beispiel erzeugt die folgende Ausgabe:This example produces the following output:

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

Siehe auchSee Also

Advanced LINQ to XML Programming (C#) (Erweiterte LINQ to XML-Programmierung (C#))Advanced LINQ to XML Programming (C#)