LINQ naar XML versus DOM

Artikel
03/05/2024

In dit artikel worden enkele belangrijke verschillen beschreven tussen LINQ naar XML en de huidige overheersende XML-programmeer-API, het W3C Document Object Model (DOM).

Nieuwe manieren om XML-structuren te maken

In de W3C DOM bouwt u een XML-structuur vanaf de onderkant; Dat wil gezegd: u maakt een document, u maakt elementen en vervolgens voegt u de elementen toe aan het document.

In het volgende voorbeeld wordt bijvoorbeeld een typische manier gebruikt om een XML-structuur te maken met behulp van de Microsoft-implementatie van 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)

Deze stijl van code verbergt de structuur van de XML-structuur. LINQ naar XML ondersteunt ook een alternatieve benadering, functionele constructie, die de structuur beter laat zien. Deze aanpak kan worden uitgevoerd met de XElement en XAttribute constructors. In Visual Basic kunt u dit ook doen met letterlijke XML-gegevens. In dit voorbeeld ziet u de constructie van dezelfde XML-structuur met behulp van functionele constructie:

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>

Als u de code inspringt om de XML-structuur te maken, wordt de structuur van de onderliggende XML weergegeven. De Visual Basic-versie maakt gebruik van letterlijke XML-gegevens.

Zie XML-structuren voor meer informatie.

Rechtstreeks werken met XML-elementen

Wanneer u met XML programmeert, is uw primaire focus meestal op XML-elementen en misschien op kenmerken. In LINQ naar XML kunt u rechtstreeks met XML-elementen en -kenmerken werken. U kunt bijvoorbeeld het volgende doen:

Xml-elementen maken zonder een documentobject te gebruiken. Dit vereenvoudigt het programmeren wanneer u met fragmenten van XML-structuren moet werken.
Objecten rechtstreeks vanuit een XML-bestand laden T:System.Xml.Linq.XElement .
Objecten serialiseren T:System.Xml.Linq.XElement naar een bestand of een stream.

Vergelijk dit met de W3C DOM, waarin het XML-document wordt gebruikt als een logische container voor de XML-structuur. In DOM moeten XML-knooppunten, inclusief elementen en kenmerken, worden gemaakt in de context van een XML-document. Hier volgt een codefragment voor het maken van een naamelement 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)

Als u een element in meerdere documenten wilt gebruiken, moet u de knooppunten in documenten importeren. LINQ naar XML voorkomt deze complexiteitslaag.

Wanneer u LINQ naar XML gebruikt, gebruikt u de XDocument klasse alleen als u een opmerking of verwerkingsinstructie wilt toevoegen op het hoofdniveau van het document.

Vereenvoudigde verwerking van namen en naamruimten

Het verwerken van namen, naamruimten en naamruimtevoorvoegsels is over het algemeen een complex onderdeel van XML-programmering. LINQ naar XML vereenvoudigt namen en naamruimten door de vereiste voor naamruimtevoorvoegsels te elimineren. Als u naamruimtevoorvoegsels wilt beheren, kunt u dat. Maar als u besluit niet expliciet naamruimtevoorvoegsels te beheren, wijst LINQ aan XML tijdens de serialisatie naamruimtevoorvoegsels toe als ze vereist zijn, of serialiseert ze met behulp van standaardnaamruimten als dat niet zo is. Als er standaardnaamruimten worden gebruikt, zijn er geen voorvoegsels voor de naamruimte in het resulterende document. Zie het overzicht van naamruimten voor meer informatie.

Een ander probleem met de DOM is dat u de naam van een knooppunt niet kunt wijzigen. In plaats daarvan moet u een nieuw knooppunt maken en alle onderliggende knooppunten ernaar kopiëren, waarbij de oorspronkelijke knooppuntidentiteit verloren gaat. LINQ naar XML voorkomt dit probleem doordat u de XName eigenschap op een knooppunt kunt instellen.

Ondersteuning voor statische methoden voor het laden van XML

MET LINQ naar XML kunt u XML laden met behulp van statische methoden, in plaats van exemplaarmethoden. Dit vereenvoudigt het laden en parseren. Zie XML laden vanuit een bestand voor meer informatie.

Ondersteuning voor DTD-constructies verwijderen

LINQ naar XML vereenvoudigt het programmeren van XML verder door ondersteuning voor entiteiten en entiteitsverwijzingen te verwijderen. Het beheer van entiteiten is complex en wordt zelden gebruikt. Het verwijderen van de ondersteuning verhoogt de prestaties en vereenvoudigt de programmeerinterface. Wanneer een LINQ-naar-XML-structuur wordt ingevuld, worden alle DTD-entiteiten uitgevouwen.

Ondersteuning voor fragmenten

LINQ naar XML biedt geen equivalent voor de XmlDocumentFragment klasse. In veel gevallen kan het XmlDocumentFragment concept echter worden verwerkt door het resultaat van een query die is getypt vanaf IEnumerable<T>XNode, of IEnumerable<T> van XElement.

Ondersteuning voor XPathNavigator

LINQ naar XML biedt ondersteuning voor XPathNavigator via extensiemethoden in de System.Xml.XPath naamruimte. Zie System.Xml.XPath.Extensions voor meer informatie.

Ondersteuning voor witruimte en inspringing

LINQ naar XML verwerkt witruimte eenvoudiger dan de DOM.

Een veelvoorkomend scenario is het lezen van ingesprongen XML, het maken van een in-memory XML-structuur zonder tekstknooppunten met witruimte (met behoud van witruimte), enkele bewerkingen in de XML uitvoeren en vervolgens de XML opslaan met inspringing. Wanneer u de XML serialiseert met opmaak, blijft alleen belangrijke witruimte in de XML-structuur behouden. Dit is het standaardgedrag voor LINQ naar XML.

Een ander veelvoorkomend scenario is het lezen en wijzigen van XML die al opzettelijk is ingesprongen. Mogelijk wilt u deze inspringing op geen enkele manier wijzigen. In LINQ naar XML kunt u dit doen door:

Witruimte behouden wanneer u de XML laadt of parseert.
Opmaak uitschakelen wanneer u de XML serialiseert.

LINQ naar XML slaat witruimte op als een XText knooppunt, in plaats van een speciaal Whitespace knooppunttype te hebben, zoals de DOM wel doet.

Ondersteuning voor aantekeningen

LINQ naar XML-elementen ondersteunen een uitbreidbare set aantekeningen. Dit is handig voor het bijhouden van diverse informatie over een element, zoals schemagegevens, informatie over of het element is gebonden aan een gebruikersinterface of andere soorten toepassingsspecifieke informatie. Zie LINQ voor XML-aantekeningen voor meer informatie.

Ondersteuning voor schemagegevens

LINQ naar XML biedt ondersteuning voor XSD-validatie via extensiemethoden in de System.Xml.Schema naamruimte. U kunt controleren of een XML-structuur voldoet aan een XSD. U kunt de XML-structuur vullen met de post-schemavalidatie-infoset (PSVI). Zie Valideren met XSD en Extensionsvoor meer informatie.

Zie ook

Overzicht van LINQ naar XML

Delen via