LINQ to XML im Vergleich zu DOM

2025-06-19

In diesem Artikel werden einige wichtige Unterschiede zwischen LINQ to XML und der aktuellen vorherrschenden XML-Programmier-API, dem W3C Document Object Model (DOM), beschrieben.

Neue Möglichkeiten zum Erstellen von XML-Bäumen

Im W3C-DOM erstellen Sie eine XML-Struktur von unten nach oben. Das heißt, Sie erstellen ein Dokument, erstellen Elemente und fügen dann die Elemente zum Dokument hinzu.

Im folgenden Beispiel wird beispielsweise eine typische Methode zum Erstellen einer XML-Struktur mithilfe der Microsoft-Implementierung von DOM XmlDocumentverwendet.

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

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

Diese Codierungsart blendet die Struktur des XML-Baums aus. LINQ to XML unterstützt auch einen alternativen Ansatz, funktionale Konstruktion, der die Struktur besser zeigt. Dieser Ansatz kann mit den XElement und XAttribute Konstruktoren durchgeführt werden. In Visual Basic können sie auch mit XML-Literalen ausgeführt werden. In diesem Beispiel wird die Konstruktion derselben XML-Struktur mithilfe der funktionalen Konstruktion veranschaulicht:

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

Dim contacts = _
    <Contacts>
        <Contact>
            <Name>Patrick Hines</Name>
            <Phone Type="Home">206-555-0144</Phone>
            <Phone Type="Work">425-555-0145</Phone>
            <Address>
                <Street1>123 Main St</Street1>
                <City>Mercer Island</City>
                <State>WA</State>
                <Postal>68042</Postal>
            </Address>
        </Contact>
    </Contacts>

Die Codeeinzüge verdeutlichen den Aufbau des der XML-Struktur zugrunde liegenden XML-Codes. Die Visual Basic-Version verwendet XML-Literale.

Weitere Informationen finden Sie unter XML-Strukturen.

Direktes Arbeiten mit XML-Elementen

Wenn Sie mit XML programmieren, liegt ihr Hauptfokus in der Regel auf XML-Elemente und vielleicht auf Attribute. In LINQ to XML können Sie direkt mit XML-Elementen und -Attributen arbeiten. Sie können beispielsweise folgende Aufgaben ausführen:

Erstellen Sie XML-Elemente, ohne überhaupt ein Dokumentobjekt zu verwenden. Dies vereinfacht die Programmierung, wenn Sie mit Fragmenten von XML-Strukturen arbeiten müssen.
Laden Sie T:System.Xml.Linq.XElement Objekte direkt aus einer XML-Datei.
Serialisieren sie T:System.Xml.Linq.XElement Objekte in eine Datei oder einen Datenstrom.

Vergleichen Sie dies mit dem W3C-DOM, in dem das XML-Dokument als logischer Container für den XML-Baum verwendet wird. In DOM müssen XML-Knoten, einschließlich Elementen und Attributen, im Kontext eines XML-Dokuments erstellt werden. Hier ist ein Codefragment zum Erstellen eines Namenselements in DOM:

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

Dim doc As XmlDocument = New XmlDocument()
Dim name As XmlElement = doc.CreateElement("Name")
name.InnerText = "Patrick Hines"
doc.AppendChild(name)

Wenn Sie ein Element über mehrere Dokumente hinweg verwenden möchten, müssen Sie die Knoten über Dokumente hinweg importieren. LINQ to XML vermeidet diese Komplexitätsebene.

Wenn Sie LINQ to XML verwenden, verwenden Sie die XDocument Klasse nur, wenn Sie eine Kommentar- oder Verarbeitungsanweisung auf der Stammebene des Dokuments hinzufügen möchten.

Vereinfachte Verwaltung von Namen und Namespaces

Die Behandlung von Namen, Namespaces und Namespacepräfixen ist in der Regel ein komplexer Bestandteil der XML-Programmierung. LINQ to XML vereinfacht Namen und Namespaces, indem die Anforderung zum Umgang mit Namespacepräfixen beseitigt wird. Wenn Sie Namespacepräfixe steuern möchten, können Sie dies erreichen. Wenn Sie sich jedoch entscheiden, Namespacepräfixe nicht explizit zu steuern, weist LINQ to XML Namespacepräfixe während der Serialisierung zu, wenn sie erforderlich sind, oder serialisiert mit Standardnamespaces, wenn sie nicht erforderlich sind. Wenn Standardnamespaces verwendet werden, gibt es keine Namespacepräfixe im resultierenden Dokument. Weitere Informationen finden Sie in der Übersicht über Namespaces.

Ein weiteres Problem mit dem DOM besteht darin, dass Sie den Namen eines Knotens nicht ändern können. Stattdessen müssen Sie einen neuen Knoten erstellen und alle untergeordneten Knoten kopieren und dabei die ursprüngliche Knotenidentität verlieren. LINQ to XML vermeidet dieses Problem, indem Sie die XName Eigenschaft auf einem Knoten festlegen können.

Unterstützung statischer Methoden zum Laden von XML

MIT LINQ to XML können Sie XML mithilfe statischer Methoden anstelle von Instanzmethoden laden. Dies vereinfacht das Laden und Analysieren. Weitere Informationen finden Sie unter Wie man XML aus einer Datei lädt.

Entfernung der Unterstützung für DTD-Konstrukte

LINQ to XML vereinfacht die XML-Programmierung weiter, indem unterstützung für Entitäten und Entitätsverweise entfernt wird. Die Verwaltung von Entitäten ist komplex und wird selten verwendet. Durch das Entfernen der Unterstützung wird die Leistung erhöht und die Programmierschnittstelle vereinfacht. Wenn eine LINQ to XML-Struktur aufgefüllt wird, werden alle DTD-Entitäten erweitert.

Unterstützung für Fragmente

LINQ to XML stellt keine Entsprechung für die XmlDocumentFragment Klasse bereit. In vielen Fällen kann das XmlDocumentFragment-Konzept jedoch durch das Ergebnis einer Abfrage behandelt werden, das als IEnumerable<T> von XNode oder als IEnumerable<T> von XElement vorliegt.

Unterstützung für XPathNavigator

LINQ to XML bietet Unterstützung für XPathNavigator durch Erweiterungsmethoden im System.Xml.XPath Namespace. Weitere Informationen finden Sie unter System.Xml.XPath.Extensions.

Unterstützung für Leerraum und Einzüge

LINQ to XML behandelt Leerzeichen einfacher als das DOM.

Ein gängiges Szenario besteht darin, XML mit Einrückungen zu lesen, eine XML-Struktur im Arbeitsspeicher ohne Leerzeichen-Textknoten zu erstellen (d. h. ohne Leerraum), einige Operationen am XML auszuführen und dann das XML mit Einrückungen zu speichern. Wenn Sie den XML-Code mit Formatierung serialisieren, bleibt nur signifikanter Leerraum in der XML-Struktur erhalten. Dies ist das Standardverhalten für LINQ to XML.

Ein weiteres gängiges Szenario ist das Lesen und Ändern von XML, das bereits absichtlich formatiert wurde. Sie möchten nicht, dass diese Einzüge irgendwie geändert werden. In LINQ to XML können Sie dies wie folgt tun:

Beibehalten von Leerraum beim Laden oder Analysieren des XML-Codes.
Deaktivieren der Formatierung beim Serialisieren des XML-Codes.

LINQ to XML speichert Leerraum als XText Knoten, anstatt einen speziellen Whitespace Knotentyp zu haben, wie das DOM tut.

Unterstützung für Anmerkungen

LINQ to XML-Elemente unterstützen einen erweiterbaren Satz von Anmerkungen. Dies ist nützlich, um verschiedene Informationen zu einem Element zu verfolgen, z. B. Schemainformationen, Informationen darüber, ob das Element an eine Benutzeroberfläche gebunden ist, oder andere anwendungsspezifische Informationen. Weitere Informationen finden Sie unter Anmerkungen zu LINQ to XML.

Unterstützung für Schemainformationen

LINQ to XML bietet Unterstützung für die XSD-Validierung über Erweiterungsmethoden im System.Xml.Schema Namespace. Sie können validieren, ob ein XML-Baum einem XSD entspricht. Sie können die XML-Struktur mit dem Post-Schema-Validierungs-Infoset (PSVI) auffüllen. Weitere Informationen finden Sie unter How to validate using XSD and Extensions.

Siehe auch

Übersicht über LINQ to XML

Freigeben über