Unterschiede zwischen LINQ to XML und DOM
Aktualisiert: November 2007
In diesem Abschnitt werden einige der wichtigsten Unterschiede zwischen LINQ to XML und der derzeit verbreitetsten XML-Programmier-API, dem W3C-Dokumentobjektmodell (DOM), beschrieben.
Neue Möglichkeiten zum Konstruieren von XML-Strukturen
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.
Das folgende Beispiel zeigt eine typische Herangehensweise an das Erstellen einer XML-Struktur mit der Microsoft-Implementierung des 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);
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 Form der Codierung bietet optisch nicht allzu viele Informationen zum Aufbau der XML-Struktur. LINQ to XML unterstützt diese Möglichkeit zum Konstruieren einer XML-Struktur, aber auch eine alternative Methode, die funktionale Konstruktion. Bei der funktionalen Konstruktion werden zum Erstellen einer XML-Struktur die Konstruktoren XElement und XAttribute verwendet.
Das folgende Beispiel zeigt, wie Sie dieselbe XML-Struktur wie oben mit der funktionalen Konstruktion in LINQ to XML konstruieren können:
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.
In Visual Basic ist der Code zum Konstruieren der XML-Struktur noch einfacher, da hier ein XML-Literal zum Einsatz kommt:
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>
Wenn Sie aus einem vorhandenen XML-Dokument eine XML-Struktur erstellen möchten, können Sie das XML-Dokument in einem Editor öffnen, den XML-Code in die Zwischenablage kopieren, in Visual Studio ein Visual Basic-Modul öffnen und den XML-Code direkt in den Visual Basic-Code-Editor einfügen.
Weitere Informationen dazu finden Sie unter Erstellen von XML-Strukturen.
Direktes Arbeiten mit XML-Elementen
Beim Programmieren mit XML liegt Ihr Hauptaugenmerk in der Regel auf XML-Elementen und vielleicht auch auf Attributen. In LINQ to XML können Sie direkt mit XML-Elementen und Attributen arbeiten. So können Sie z. B. Folgendes tun:
Sie können XML-Elemente ohne jegliche Verwendung eines Dokumentobjekts erstellen. Dies vereinfacht beim Arbeiten mit Fragmenten von XML-Strukturen die Programmierung.
Sie können T:System.Xml.Linq.XElement-Objekte direkt aus einer XML-Datei laden.
Sie können T:System.Xml.Linq.XElement-Objekte in eine Datei oder einen Stream serialisieren.
Vergleichen Sie dies mit dem W3C-DOM, bei dem das XML-Dokument als logischer Container für die XML-Struktur verwendet wird. Im DOM müssen die XML-Knoten einschließlich der Elemente und Attribute im Kontext eines XML-Dokuments erstellt werden. Das folgende Codefragment erstellt ein Namenselement im 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 in mehreren Dokumenten verwenden möchten, müssen Sie die Knoten dokumentübergreifend importieren. Diese Komplexität wird durch LINQ to XML vermieden.
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.
Vereinfachte Handhabung von Namen und Namespaces
Die Handhabung von Namen, Namespaces und Namespacepräfixen ist bei der XML-Programmierung in der Regel eine komplexe Angelegenheit. LINQ to XML vereinfacht die Verwendung von Namen und Namespaces, indem es den Umgang mit Namespacepräfixen. Das heißt aber nicht, dass Sie die Namespacepräfixe nicht mehr selbst steuern können. Wenn Sie sich aber dafür entscheiden, sich nicht mehr explizit um die Steuerung der Namespacepräfixe kümmern zu müssen, weist LINQ to XML bei der Serialisierung dort, wo dies erforderlich ist, entsprechende Namespacepräfixe zu oder greift für die Serialisierung auf die Standardnamespaces zurück. Wenn Standardnamespaces verwendet werden, gibt es im resultierenden Dokument keine Namespacepräfixe. Weitere Informationen dazu finden Sie unter Arbeiten mit XML-Namespaces.
Ein weiterer Nachteil des DOM ist, dass es nicht möglich ist, den Namen eines Knotens zu ändern. Stattdessen muss ein neuer Knoten erstellt werden, in den sämtliche untergeordneten Knoten kopiert werden. Dabei geht die Identität des ursprünglichen Knotens verloren. In LINQ to XML tritt dieses Problem nicht auf, da das Festlegen der XName-Eigenschaft für einen Knoten möglich ist.
Unterstützung statischer Methoden für das Laden von XML
In LINQ to XML können Sie zum Laden von XML anstelle von Instanzmethoden statische Methoden verwenden. Dadurch vereinfacht sich das Laden und das Analysieren. Weitere Informationen finden Sie unter Gewusst wie: Laden von XML aus einer Datei.
Entfernung der Unterstützung für DTD-Konstrukte
LINQ to XML vereinfacht die XML-Programmierung zusätzlich, indem die 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 dieser Unterstützung wird die Leistung verbessert und die Programmierung vereinfacht. Beim Auffüllen einer LINQ to XML-Struktur werden alle DTD-Entitäten erweitert.
Unterstützung für Fragmente
In LINQ to XML gibt es keine Entsprechung für die XmlDocumentFragment-Klasse. In vielen Fällen lassen sich aber mit dem Ergebnis einer Abfrage, die als IEnumerable<T>-Schnittstelle von XNode oder als IEnumerable<T>-Schnittstelle von XElement typisiert ist, die gleichen Ergebnisse wie mit der XmlDocumentFragment-Klasse erzielen.
Unterstützung für XPathNavigator
LINQ to XML bietet über die Erweiterungsmethoden im System.Xml.XPath-Namespace Unterstützung für XPathNavigator. Weitere Informationen dazu finden Sie unter System.Xml.XPath.Extensions.
Unterstützung für Leerzeichen und Einzüge
LINQ to XML handhabt Leerzeichen einfacher als das DOM.
Häufig passiert es, 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. Wenn Sie den XML-Code mit Formatierung serialisieren, bleibt nur signifikanter Leerraum in der XML-Struktur erhalten. Dies ist das Standardverhalten bei 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. Sie möchten nicht, dass diese Einzüge irgendwie geändert werden. 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.
LINQ to XML speichert Leerzeichen als XText-Knoten und nicht als speziellen Whitespace-Knotentyp, wie dies im DOM der Fall ist.
Unterstützung für Anmerkungen
LINQ to XML-Elemente unterstützen einen erweiterbaren Satz von Anmerkungen. 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. Weitere Informationen dazu finden Sie unter Anmerkungen in LINQ to XML.
Unterstützung für Schemainformationen
LINQ to XML bietet über die Erweiterungsmethoden im System.Xml.Schema-Namespace Unterstützung für die XSD-Validierung. Sie können prüfen, ob sich eine XML-Struktur nach einer XSD richtet. Sie können die XML-Struktur mit dem Post-Schema-Validierungs-Infoset (PSVI) auffüllen. Weitere Informationen dazu finden Sie unter Gewusst wie: Validieren mit XSD (LINQ to XML) und Extensions.