Comparaison de LINQ to XML et DOM
Cette section décrit certaines des principales différences entre LINQ to XML et l'API de programmation XML dominante actuellement, le modèle DOM (Document Object Model) W3C.
Nouvelles manières de construire des arborescences XML
Dans le modèle DOM W3C, vous construisez une arborescence XML de bas en haut ; autrement dit, vous créez un document, vous créez des éléments, puis vous ajoutez les éléments au document.
Voici un exemple typique de création d'une arborescence XML à l'aide de l'implémentation Microsoft du modèle 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 ne fournit visuellement que peu d'informations concernant la structure de l'arborescence XML. LINQ to XML prend en charge cette approche de la construction d'une arborescence XML, mais également une autre approche, la construction fonctionnelle. La construction fonctionnelle utilise les constructeurs XElement et XAttribute pour générer une arborescence XML.
Voici comment vous devez construire la même arborescence XML à l'aide de la construction fonctionnelle LINQ to XML :
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")
)
)
);
Notez que la mise en retrait du code pour construire l'arborescence XML affiche la structure des données XML sous-jacentes.
En Visual Basic, le code pour construire l'arborescence XML est encore plus simple car il utilise un littéral XML :
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>
Si vous avez un document XML existant et que vous souhaitez créer une arborescence XML à partir de ce document, vous pouvez ouvrir le document XML dans un éditeur, copier le code XML dans le Presse-papiers, ouvrir un module Visual Basic dans Visual Studio, puis coller le code XML directement dans l'éditeur de code Visual Basic.
Pour plus d'informations, consultez Création d'arborescences XML.
Utilisation directe des éléments XML
Lorsque vous programmez avec des données XML, vous travaillez en général principalement avec les éléments XML et éventuellement les attributs. Dans LINQ to XML, vous pouvez utiliser directement les éléments et les attributs XML. Vous pouvez par exemple effectuer les opérations suivantes :
Créer des éléments XML sans utiliser d'objet de document. Cela simplifie la programmation lorsque vous devez travailler avec des fragments d'arborescences XML.
Charger des objets T:System.Xml.Linq.XElement directement à partir d'un fichier XML.
Sérialiser des objets T:System.Xml.Linq.XElement dans un fichier ou un flux.
Comparez cela au modèle DOM W3C, dans lequel le document XML est utilisé en tant que conteneur logique pour l'arborescence XML. Dans le modèle DOM, les nœuds XML, y compris les éléments et attributs, doivent être créés dans le contexte d'un document XML. Voici un fragment de code permettant de créer un élément de nom dans le modèle 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 dans plusieurs documents, vous devez importer les nœuds d'un document à un autre. LINQ to XML évite cette couche de complexité.
Lors de l'utilisation de LINQ to XML, vous utilisez la classe XDocument uniquement si vous souhaitez ajouter un commentaire ou une information 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'espaces de noms est généralement un aspect complexe de la programmation XML. LINQ to XML simplifie les noms et les espaces de noms en éliminant totalement la nécessité de gérer les préfixes d'espaces de noms. Vous pouvez si vous le souhaitez contrôler les préfixes d'espaces de noms. Mais si vous décidez de ne pas contrôler de manière explicite les préfixes d'espaces de noms, LINQ to XML affectera des préfixes d'espaces de noms lors de la sérialisation s'ils sont requis ou effectuera la sérialisation à l'aide d'espaces de noms par défaut dans le cas contraire. Si des espaces de noms par défaut sont utilisés, il n'y aura pas de préfixes d'espaces de noms dans le document résultant. Pour plus d'informations, consultez Utilisation des espaces de noms XML.
L'un des autres problèmes associés au modè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é de nœud d'origine. LINQ to XML évite ce problème en vous permettant de définir la propriété XName 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 des données XML en utilisant des méthodes statiques au lieu de méthodes d'instance. Cela simplifie le chargement et l'analyse. Pour plus d'informations, voir Procédure : charger des données XML à partir d'un fichier.
Suppression de la prise en charge des constructions de DTD
LINQ to XML simplifie la programmation XML en supprimant la prise en charge des entités et des références d'entités. La gestion des entités est complexe et rarement utilisée. La suppression de leur prise en charge augmente les performances et simplifie l'interface de programmation. Lorsqu'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 classe XmlDocumentFragment. Dans de nombreux cas, toutefois, le concept de XmlDocumentFragment peut être géré 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 de l'objet XPathNavigator via l'extension de méthodes dans 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 les espaces blancs plus simplement que le modèle DOM.
Un scénario courant consiste à lire le code XML mis en retrait, à créer une arborescence XML en mémoire sans nœuds d'espaces (autrement dit, ne pas conserver les espaces), à 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 mise en forme, seuls les espaces significatifs dans l'arborescence XML sont conservés. Il s'agit du comportement par défaut pour LINQ to XML.
Un autre scénario courant consiste à lire et à modifier du code XML qui a déjà été intentionnellement mis en retrait. Vous ne souhaiterez peut-être modifier cette mise en retrait en aucune manière. Dans LINQ to XML, vous devez pour cela conserver les espaces lorsque vous chargez ou analysez le code XML et que vous désactivez la mise en forme lors de la sérialisation du code XML.
LINQ to XML stocke un espace blanc en tant que un nœud XText, au lieu d'avoir un type de nœud Whitespace spécialisé, comme le modè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 assurer le suivi de diverses informations relatives à un élément, telles que des informations de schéma, le fait que l'élément soit lié à une interface utilisateur ou tout autre type d'informations spécifiques aux applications. Pour plus d'informations, consultez Annotations LINQ to XML.
Prise en charge des informations de schéma
LINQ to XML fournit une prise en charge de la validation XSD via l'extension de méthodes dans l'espace de nomsSystem.Xml.Schema. Vous pouvez valider la conformité d'une arborescence XML à un schéma XSD. Vous pouvez remplir l'arborescence XML avec le PSVI (Post-Schema-Validation Infoset). Pour plus d'informations, consultez Procédure : valider à l'aide de XSD (LINQ to XML) et Extensions.