Partager via

LINQ to XML contre DOM

Cet article décrit certaines différences clés entre LINQ to XML et l’API de programmation XML prédominante actuelle, le modèle DOM (Document Object Model) W3C.

Nouvelles façons de construire des arborescences XML

Dans le DOM W3C, vous créez une arborescence XML à partir du bas en haut ; autrement dit, vous créez un document, vous créez des éléments, puis vous ajoutez les éléments au document.

Par exemple, l’exemple suivant utilise un moyen classique de créer une arborescence XML à l’aide de l’implémentation Microsoft de 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)

Ce style de codage masque la structure de l’arborescence XML. LINQ to XML prend également en charge une approche alternative, une construction fonctionnelle, qui montre mieux la structure. Cette approche peut être effectuée avec les constructeurs XElement et XAttribute. En Visual Basic, il peut également être effectué avec des littéraux XML. Cet exemple illustre la construction de la même arborescence XML à l’aide de la construction fonctionnelle :

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>

Notez que la mise en retrait du code pour construire l’arborescence XML affiche la structure des données XML sous-jacentes. La version de Visual Basic utilise des littéraux XML.

Pour plus d’informations, consultez les arborescences XML.

Utiliser directement des éléments XML

Lorsque vous programmez avec XML, votre focus principal est généralement sur les éléments XML et peut-être sur les attributs. Dans LINQ to XML, vous pouvez travailler directement avec des éléments et des attributs XML. Par exemple, vous pouvez effectuer les opérations suivantes :

  • Créez des éléments XML sans utiliser d’objet de document du tout. Cela simplifie la programmation lorsque vous devez utiliser des fragments d’arborescences XML.
  • Chargez des T:System.Xml.Linq.XElement objets directement à partir d’un fichier XML.
  • Sérialiser des T:System.Xml.Linq.XElement objets vers un fichier ou un flux.

Comparez-le au DOM W3C, dans lequel le document XML est utilisé comme conteneur logique pour l’arborescence XML. Dans DOM, les nœuds XML, y compris les éléments et les attributs, doivent être créés dans le contexte d’un document XML. Voici un fragment de code pour créer un élément de nom dans 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)

Si vous souhaitez utiliser un élément sur plusieurs documents, vous devez importer les nœuds entre les documents. LINQ to XML évite cette couche de complexité.

Lorsque vous utilisez LINQ to XML, vous utilisez la XDocument classe uniquement si vous souhaitez ajouter un commentaire ou une instruction de traitement au niveau racine du document.

Gestion simplifiée des noms et des espaces de noms

La gestion des noms, des espaces de noms et des préfixes d’espace de noms est généralement une partie complexe de la programmation XML. LINQ to XML simplifie les noms et les espaces de noms en éliminant la nécessité de traiter les préfixes d’espace de noms. Si vous souhaitez contrôler les préfixes d’espace de noms, vous pouvez. Toutefois, si vous décidez de ne pas contrôler explicitement les préfixes d’espace de noms, LINQ to XML affecte des préfixes d’espace de noms lors de la sérialisation s’ils sont requis ou sérialisent à l’aide d’espaces de noms par défaut s’ils ne le sont pas. Si les espaces de noms par défaut sont utilisés, aucun préfixe d’espace de noms n’est présent dans le document résultant. Pour plus d’informations, consultez la vue d’ensemble des espaces de noms.

Un autre problème avec le DOM est qu’il ne vous permet pas de modifier le nom d’un nœud. Au lieu de cela, vous devez créer un nouveau nœud et y copier tous les nœuds enfants, perdant ainsi l'identité du nœud d'origine. LINQ to XML évite ce problème en vous permettant de définir la XName propriété sur un nœud.

Prise en charge des méthodes statiques pour le chargement de données XML

LINQ to XML vous permet de charger du code XML à l’aide de méthodes statiques, au lieu de méthodes d’instance. Cela simplifie le chargement et l’analyse. Pour plus d’informations, consultez Comment charger du code XML à partir d’un fichier.

Suppression de la prise en charge des constructions de DTD

LINQ to XML simplifie davantage la programmation XML en supprimant la prise en charge des entités et des références d’entité. La gestion des entités est complexe et est rarement utilisée. La suppression de leur prise en charge augmente les performances et simplifie l’interface de programmation. Quand une arborescence LINQ to XML est remplie, toutes les entités DTD sont développées.

Prise en charge des fragments

LINQ to XML ne fournit pas d’équivalent pour la XmlDocumentFragment classe. Toutefois, dans de nombreux cas, le XmlDocumentFragment concept peut être traité par le résultat d'une requête typée comme IEnumerable<T> de XNode, ou IEnumerable<T> de XElement.

Prise en charge de XPathNavigator

LINQ to XML fournit une prise en charge pour XPathNavigator via les méthodes d’extension de l’espace de noms System.Xml.XPath. Pour plus d’informations, consultez System.Xml.XPath.Extensions.

Prise en charge des espaces blancs et de la mise en retrait

LINQ to XML gère l’espace blanc plus simplement que le DOM.

Un scénario courant consiste à lire le code XML mis en retrait, à créer une arborescence XML en mémoire sans aucun nœud de texte d’espace blanc (autrement dit, sans conserver d’espace blanc), effectuer certaines opérations sur le code XML, puis enregistrer le code XML avec mise en retrait. Lorsque vous sérialisez le code XML avec une mise en forme, seul un espace blanc significatif dans l’arborescence XML est conservé. Il s’agit du comportement par défaut pour LINQ to XML.

Un autre scénario courant consiste à lire et modifier du XML qui a déjà été intentionnellement indenté. Vous préférerez peut-être ne pas modifier cette indentation de quelque façon que ce soit. Dans LINQ to XML, vous pouvez procéder comme suit :

  • Conservation de l’espace blanc lorsque vous chargez ou analysez le code XML.
  • Désactivation de la mise en forme lorsque vous sérialisez le code XML.

LINQ to XML stocke l’espace blanc en tant que XText nœud, au lieu d’avoir un type de nœud spécialisé Whitespace , comme le fait le DOM.

Prise en charge des annotations

Les éléments LINQ to XML prennent en charge un ensemble extensible d’annotations. Cela est utile pour suivre des informations diverses sur un élément, telles que des informations de schéma, des informations sur la liaison de l’élément à une interface utilisateur ou tout autre type d’informations spécifiques à l’application. Pour plus d’informations, consultez les annotations de LINQ à XML.

Prise en charge des informations de schéma

LINQ to XML fournit une prise en charge de la validation XSD via les méthodes d’extension de l’espace de noms System.Xml.Schema. Vous pouvez vérifier qu’une arborescence XML est conforme à un XSD. Vous pouvez remplir l’arborescence XML avec l’ensemble des informations après validation de schéma (PSVI). Pour plus d’informations, consultez Comment valider à l’aide de XSD et Extensions.

Voir aussi

  • Last updated on