Dela via

LINQ till XML jämfört med DOM

  • Artikel

Den här artikeln beskriver några viktiga skillnader mellan LINQ till XML och det aktuella dominerande XML-programmerings-API:et, W3C Document Object Model (DOM).

Nya sätt att konstruera XML-träd

I W3C DOM skapar du ett XML-träd nedifrån och upp. Du skapar alltså ett dokument, skapar element och lägger sedan till elementen i dokumentet.

I följande exempel används till exempel ett typiskt sätt att skapa ett XML-träd med hjälp av Microsoft-implementeringen av 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)

Det här kodningsformatet döljer strukturen för XML-trädet. LINQ till XML har också stöd för en alternativ metod, funktionell konstruktion, som bättre visar strukturen. Den här metoden kan göras med konstruktorerna XElement och XAttribute . I Visual Basic kan det också göras med XML-literaler. Det här exemplet visar konstruktion av samma XML-träd med hjälp av funktionell konstruktion:

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>

Observera att indrag i koden för att konstruera XML-trädet visar strukturen för den underliggande XML-koden. Visual Basic-versionen använder XML-literaler.

Mer information finns i XML-träd.

Arbeta direkt med XML-element

När du programmerar med XML ligger ditt primära fokus vanligtvis på XML-element och kanske på attribut. I LINQ till XML kan du arbeta direkt med XML-element och attribut. Du kan till exempel göra följande:

  • Skapa XML-element utan att använda ett dokumentobjekt alls. Detta förenklar programmeringen när du måste arbeta med fragment av XML-träd.
  • Läs in T:System.Xml.Linq.XElement objekt direkt från en XML-fil.
  • Serialisera T:System.Xml.Linq.XElement objekt till en fil eller en dataström.

Jämför detta med W3C DOM, där XML-dokumentet används som en logisk container för XML-trädet. I DOM måste XML-noder, inklusive element och attribut, skapas i kontexten för ett XML-dokument. Här är ett fragment av kod för att skapa ett namnelement i 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)

Om du vill använda ett element i flera dokument måste du importera noderna mellan dokument. LINQ till XML undviker det här komplexitetsskiktet.

När du använder LINQ till XML använder XDocument du endast klassen om du vill lägga till en kommentar eller bearbetningsinstruktion på rotnivå i dokumentet.

Förenklad hantering av namn och namnområden

Hantering av namn, namnrymder och namnområdesprefix är vanligtvis en komplex del av XML-programmeringen. LINQ till XML förenklar namn och namnområden genom att eliminera kravet på att hantera namnområdesprefix. Om du vill styra namnområdesprefix kan du göra det. Men om du väljer att inte uttryckligen kontrollera namnområdesprefix tilldelar LINQ till XML namnområdesprefix under serialiseringen om de behövs, eller serialiserar med standardnamnrymder om de inte är det. Om standardnamnområden används finns det inga namnområdesprefix i det resulterande dokumentet. Mer information finns i Översikt över namnområden.

Ett annat problem med DOM är att du inte kan ändra namnet på en nod. I stället måste du skapa en ny nod och kopiera alla underordnade noder till den och förlora den ursprungliga nodidentiteten. LINQ till XML undviker det här problemet genom att du kan ange XName egenskapen på en nod.

Stöd för statisk metod för inläsning av XML

MED LINQ till XML kan du läsa in XML med hjälp av statiska metoder i stället för instansmetoder. Detta förenklar inläsning och parsning. Mer information finns i Läsa in XML från en fil.

Borttagning av stöd för DTD-konstruktioner

LINQ till XML förenklar XML-programmering ytterligare genom att ta bort stöd för entiteter och entitetsreferenser. Hanteringen av entiteter är komplex och används sällan. Att ta bort deras stöd ökar prestandan och förenklar programmeringsgränssnittet. När ett LINQ till XML-träd fylls i expanderas alla DTD-entiteter.

Stöd för fragment

LINQ till XML ger ingen motsvarighet för XmlDocumentFragment klassen. I många fall kan begreppet dock XmlDocumentFragment hanteras av resultatet av en fråga som skrivs från XNodeIEnumerable<T> och med , eller IEnumerable<T> av XElement.

Stöd för XPathNavigator

LINQ till XML ger stöd för XPathNavigator via tilläggsmetoder i System.Xml.XPath namnområdet. Mer information finns i System.Xml.XPath.Extensions.

Stöd för tomt utrymme och indrag

LINQ till XML hanterar tomt utrymme mer enkelt än DOM.

Ett vanligt scenario är att läsa indragad XML, skapa ett minnesinternt XML-träd utan blankstegstextnoder (dvs. inte bevara tomt utrymme), utföra vissa åtgärder på XML och sedan spara XML med indrag. När du serialiserar XML med formatering bevaras endast betydande tomt utrymme i XML-trädet. Det här är standardbeteendet för LINQ till XML.

Ett annat vanligt scenario är att läsa och ändra XML som redan avsiktligt har indragits. Du kanske inte vill ändra den här indraget på något sätt. I LINQ till XML kan du göra detta genom att:

  • Bevara tomt utrymme när du läser in eller parsar XML-koden.
  • Inaktivera formatering när du serialiserar XML-koden.

LINQ till XML lagrar tomt utrymme som en XText nod, i stället för att ha en specialiserad Whitespace nodtyp, som DOM gör.

Stöd för anteckningar

LINQ till XML-element stöder en utökningsbar uppsättning anteckningar. Detta är användbart för att spåra diverse information om ett element, till exempel schemainformation, information om huruvida elementet är bundet till ett användargränssnitt eller någon annan typ av programspecifik information. Mer information finns i LINQ till XML-anteckningar.

Stöd för schemainformation

LINQ till XML ger stöd för XSD-validering via tilläggsmetoder i System.Xml.Schema namnområdet. Du kan verifiera att ett XML-träd uppfyller en XSD. Du kan fylla i XML-trädet med infouppsättningen post-schema-validation (PSVI). Mer information finns i Verifiera med XSD och Extensions.

Se även