LINQ to XML im Vergleich zu DOM (C#)LINQ to XML vs. DOM (C#)

In diesem Abschnitt werden einige der wichtigsten Unterschiede zwischen LINQ to XML und der derzeit verbreitetsten XML-Programmier-API, dem W3C-Dokumentobjektmodell (DOM), beschrieben.This section describes some key differences between LINQ to XML and the current predominant XML programming API, the W3C Document Object Model (DOM).

Neue Möglichkeiten zum Konstruieren von XML-StrukturenNew Ways to Construct XML Trees

Im W3C-DOM erstellen Sie eine XML-Struktur von unten nach oben. Das bedeutet, Sie erstellen ein Dokument, Sie erstellen Elemente, und anschließend fügen Sie die Elemente dem Dokument hinzu.In the W3C DOM, you build an XML tree from the bottom up; that is, you create a document, you create elements, and then you add the elements to the document.

Das folgende Beispiel zeigt eine typische Herangehensweise an das Erstellen einer XML-Struktur mit der Microsoft-Implementierung des DOM, XmlDocument:For example, the following would be a typical way to create an XML tree using the Microsoft implementation of DOM, XmlDocument:

XmlDocument doc = new XmlDocument();  
XmlElement name = doc.CreateElement("Name");  
name.InnerText = "Patrick Hines";  
XmlElement phone1 = doc.CreateElement("Phone");  
phone1.SetAttribute("Type", "Home");  
phone1.InnerText = "206-555-0144";          
XmlElement phone2 = doc.CreateElement("Phone");  
phone2.SetAttribute("Type", "Work");  
phone2.InnerText = "425-555-0145";          
XmlElement street1 = doc.CreateElement("Street1");          
street1.InnerText = "123 Main St";  
XmlElement city = doc.CreateElement("City");  
city.InnerText = "Mercer Island";  
XmlElement state = doc.CreateElement("State");  
state.InnerText = "WA";  
XmlElement postal = doc.CreateElement("Postal");  
postal.InnerText = "68042";  
XmlElement address = doc.CreateElement("Address");  
address.AppendChild(street1);  
address.AppendChild(city);  
address.AppendChild(state);  
address.AppendChild(postal);  
XmlElement contact = doc.CreateElement("Contact");  
contact.AppendChild(name);  
contact.AppendChild(phone1);  
contact.AppendChild(phone2);  
contact.AppendChild(address);  
XmlElement contacts = doc.CreateElement("Contacts");  
contacts.AppendChild(contact);  
doc.AppendChild(contacts);  

Dieses Format der Codierung liefert keine ausführlichen visuellen Informationen zum Aufbau der XML-Struktur.This style of coding does not visually provide much information about the structure of the XML tree. LINQ to XML unterstützt diesen Ansatz der Erstellung einer XML-Struktur, aber auch einen alternativen Ansatz, die so genannte funktionale Konstruktion. supports this approach to constructing an XML tree, but also supports an alternative approach, functional construction. Bei der funktionalen Konstruktion werden zum Erstellen einer XML-Struktur die Konstruktoren XElement und XAttribute verwendet.Functional construction uses the XElement and XAttribute constructors to build an XML tree.

Das folgende Beispiel zeigt, wie Sie dieselbe XML-Struktur wie oben mit der funktionalen Konstruktion in LINQ to XML konstruieren können:Here is how you would construct the same XML tree by using LINQ to XML functional construction:

XElement contacts =  
    new XElement("Contacts",  
        new XElement("Contact",  
            new XElement("Name", "Patrick Hines"),  
            new XElement("Phone", "206-555-0144",   
                new XAttribute("Type", "Home")),  
            new XElement("phone", "425-555-0145",  
                new XAttribute("Type", "Work")),  
            new XElement("Address",  
                new XElement("Street1", "123 Main St"),  
                new XElement("City", "Mercer Island"),  
                new XElement("State", "WA"),  
                new XElement("Postal", "68042")  
            )  
        )  
    );  

Die Codeeinzüge verdeutlichen den Aufbau des der XML-Struktur zugrunde liegenden XML-Codes.Notice that indenting the code to construct the XML tree shows the structure of the underlying XML.

Weitere Informationen finden Sie unter Creating XML Trees (C#) (Erstellen von XML-Strukturen (C#)).For more information, see Creating XML Trees (C#).

Direktes Arbeiten mit XML-ElementenWorking Directly with XML Elements

Beim Programmieren mit XML liegt Ihr Hauptaugenmerk in der Regel auf XML-Elementen und vielleicht auch auf Attributen.When you program with XML, your primary focus is usually on XML elements and perhaps on attributes. In LINQ to XML können Sie direkt mit XML-Elementen und Attributen arbeiten.In LINQ to XML, you can work directly with XML elements and attributes. So können Sie z. B. Folgendes tun:For example, you can do the following:

  • Sie können XML-Elemente ohne jegliche Verwendung eines Dokumentobjekts erstellen.Create XML elements without using a document object at all. Dies vereinfacht beim Arbeiten mit Fragmenten von XML-Strukturen die Programmierung.This simplifies programming when you have to work with fragments of XML trees.

  • Sie können T:System.Xml.Linq.XElement-Objekte direkt aus einer XML-Datei laden.Load T:System.Xml.Linq.XElement objects directly from an XML file.

  • Sie können T:System.Xml.Linq.XElement-Objekte in eine Datei oder einen Stream serialisieren.Serialize T:System.Xml.Linq.XElement objects to a file or a stream.

Vergleichen Sie dies mit dem W3C-DOM, bei dem das XML-Dokument als logischer Container für die XML-Struktur verwendet wird.Compare this to the W3C DOM, in which the XML document is used as a logical container for the XML tree. Im DOM müssen die XML-Knoten einschließlich der Elemente und Attribute im Kontext eines XML-Dokuments erstellt werden.In DOM, XML nodes, including elements and attributes, must be created in the context of an XML document. Das folgende Codefragment erstellt ein Namenselement im DOM:Here is a fragment of the code to create a name element in DOM:

XmlDocument doc = new XmlDocument();  
XmlElement name = doc.CreateElement("Name");  
name.InnerText = "Patrick Hines";  
doc.AppendChild(name);  

Wenn Sie ein Element in mehreren Dokumenten verwenden möchten, müssen Sie die Knoten dokumentübergreifend importieren.If you want to use an element across multiple documents, you must import the nodes across documents. LINQ to XML vermeidet diese Ebene der Komplexität. avoids this layer of complexity.

Bei der Verwendung von LINQ to XML müssen Sie die XDocument-Klasse nur dann verwenden, wenn Sie der Stammebene des Dokuments einen Kommentar oder eine Verarbeitungsanweisung hinzufügen möchten.When using LINQ to XML, you use the XDocument class only if you want to add a comment or processing instruction at the root level of the document.

Vereinfachte Handhabung von Namen und NamespacesSimplified Handling of Names and Namespaces

Die Handhabung von Namen, Namespaces und Namespacepräfixen ist im Allgemeinen ein komplexer Teil der XML-Programmierung.Handling names, namespaces, and namespace prefixes is generally a complex part of XML programming. LINQ to XML vereinfacht Namen und Namespaces, weil der Umgang mit Namespacepräfixen nicht zwingend erforderlich ist. simplifies names and namespaces by eliminating the requirement to deal with namespace prefixes. Das heißt aber nicht, dass Sie die Namespacepräfixe nicht mehr selbst steuern können.If you want to control namespace prefixes, you can. Wenn Sie sich aber dafür entscheiden, sich nicht mehr explizit um die Steuerung der Namespacepräfixe kümmern zu wollen, weist LINQ to XML bei der Serialisierung, wo erforderlich, entsprechende Namespacepräfixe zu oder greift für die Serialisierung auf die Standardnamespaces zurück.But if you decide to not explicitly control namespace prefixes, LINQ to XML will assign namespace prefixes during serialization if they are required, or will serialize using default namespaces if they are not. Wenn Standardnamespaces verwendet werden, gibt es im resultierenden Dokument keine Namespacepräfixe.If default namespaces are used, there will be no namespace prefixes in the resulting document. Weitere Informationen finden Sie unter Working with XML Namespaces (C#) (Arbeiten mit XML-Namespaces (C#)).For more information, see Working with XML Namespaces (C#).

Ein anderes Problem mit dem DOM besteht darin, dass es keine Änderung des Namens eines Knotens zulässt.Another problem with the DOM is that it does not let you change the name of a node. Stattdessen müssen Sie einen neuen Knoten erstellen und alle untergeordneten Knoten kopieren, sodass die ursprüngliche Knotenidentität verloren geht.Instead, you have to create a new node and copy all the child nodes to it, losing the original node identity. LINQ to XML vermeidet dieses Problem, indem es Ihnen ermöglicht wird, für einen Knoten die XName-Eigenschaft festzulegen. avoids this problem by enabling you to set the XName property on a node.

Unterstützung statischer Methoden für das Laden von XMLStatic Method Support for Loading XML

In LINQ to XML können Sie zum Laden von XML anstelle von Instanzmethoden statische Methoden verwenden.LINQ to XML lets you load XML by using static methods, instead of instance methods. Dadurch vereinfacht sich das Laden und das Analysieren.This simplifies loading and parsing. Weitere Informationen finden Sie unter Vorgehensweise: Laden von XML aus einer Datei.For more information, see How to: Load XML from a File (C#).

Entfernung der Unterstützung für DTD-KonstrukteRemoval of Support for DTD Constructs

LINQ to XML vereinfacht die XML-Programmierung zusätzlich, indem die Unterstützung für Entitäten und Entitätsverweise entfernt wird. further simplifies XML programming by removing support for entities and entity references. Die Verwaltung von Entitäten ist komplex und wird selten verwendet.The management of entities is complex, and is rarely used. Durch das Entfernen dieser Unterstützung wird die Leistung verbessert und die Programmierung vereinfacht.Removing their support increases performance and simplifies the programming interface. Beim Auffüllen einer LINQ to XML-Struktur werden alle DTD-Entitäten erweitert.When a LINQ to XML tree is populated, all DTD entities are expanded.

Unterstützung für FragmenteSupport for Fragments

In LINQ to XML gibt es keine Entsprechung für die Klasse XmlDocumentFragment.LINQ to XML does not provide an equivalent for the XmlDocumentFragment class. In vielen Fällen lassen sich aber mit dem Ergebnis einer Abfrage, die als XmlDocumentFragment-Schnittstelle von IEnumerable<T> oder als XNode-Schnittstelle von IEnumerable<T> typisiert ist, die gleichen Ergebnisse wie mit der XElement-Klasse erzielen.In many cases, however, the XmlDocumentFragment concept can be handled by the result of a query that is typed as IEnumerable<T> of XNode, or IEnumerable<T> of XElement.

Unterstützung für XPathNavigatorSupport for XPathNavigator

LINQ to XML bietet über die Erweiterungsmethoden im System.Xml.XPath-Namespace Unterstützung für XPathNavigator. provides support for XPathNavigator through extension methods in the System.Xml.XPath namespace. Weitere Informationen finden Sie unter System.Xml.XPath.Extensions.For more information, see System.Xml.XPath.Extensions.

Unterstützung für Leerraum und EinzügeSupport for White Space and Indentation

LINQ to XML handhabt Leerzeichen einfacher als das DOM. handles white space more simply than the DOM.

Es kommt häufig vor, dass XML mit Einzügen gelesen und dann im Arbeitsspeicher eine XML-Struktur ohne Leerraumtextknoten erstellt wird (Leerräume bleiben also nicht erhalten). Anschließend wird der XML-Code geändert und dann mit Einzügen gespeichert.A common scenario is to read indented XML, create an in-memory XML tree without any white space text nodes (that is, not preserving white space), perform some operations on the XML, and then save the XML with indentation. Wenn Sie den XML-Code mit Formatierung serialisieren, bleibt nur signifikanter Leerraum in der XML-Struktur erhalten.When you serialize the XML with formatting, only significant white space in the XML tree is preserved. Dies ist das Standardverhalten bei LINQ to XML.This is the default behavior for LINQ to XML.

Aber auch dieses Szenario ist häufig anzutreffen: XML-Code, der bereits absichtlich mit Einzügen versehen wurde, wird gelesen und geändert.Another common scenario is to read and modify XML that has already been intentionally indented. Sie möchten nicht, dass diese Einzüge irgendwie geändert werden.You might not want to change this indentation in any way. In LINQ to XML können Sie dies erreichen, indem Sie den Leerraum beim Laden oder Analysieren des XML-Codes beibehalten und dann beim Serialisieren des XML-Codes die Formatierung deaktivieren.In LINQ to XML, you can do this by preserving white space when you load or parse the XML and disabling formatting when you serialize the XML.

LINQ to XML speichert Leerraum als XText-Knoten und nicht als speziellen Whitespace-Knotentyp, wie dies im DOM der Fall ist. stores white space as an XText node, instead of having a specialized Whitespace node type, as the DOM does.

Unterstützung für AnmerkungenSupport for Annotations

LINQ to XML-Elemente unterstützen einen erweiterbaren Satz von Anmerkungen. elements support an extensible set of annotations. Dies ist hilfreich, wenn verschiedene Informationen zu einem Element nachverfolgt werden sollen, z.B. Schemainformationen, die Information, ob das Element an eine Benutzeroberfläche gebunden ist, oder andere anwendungsspezifische Informationen.This is useful for tracking miscellaneous information about an element, such as schema information, information about whether the element is bound to a UI, or any other kind of application-specific information. Weitere Informationen finden Sie unter Anmerkungen zu LINQ to XML.For more information, see LINQ to XML Annotations.

Unterstützung für SchemainformationenSupport for Schema Information

LINQ to XML bietet über die Erweiterungsmethoden im System.Xml.Schema-Namespace Unterstützung für die XSD-Validierung. provides support for XSD validation through extension methods in the System.Xml.Schema namespace. Sie können prüfen, ob sich eine XML-Struktur nach einer XSD richtet.You can validate that an XML tree complies with an XSD. Sie können die XML-Struktur mit dem Post-Schema-Validierungs-Infoset (PSVI) auffüllen.You can populate the XML tree with the post-schema-validation infoset (PSVI). Weitere Informationen finden Sie unter Vorgehensweise: Überprüfen mithilfe von XSD und Extensions.For more information, see How to: Validate Using XSD and Extensions.

Siehe auchSee Also

Erste Schritte (LINQ to XML)Getting Started (LINQ to XML)