Partager via

Vue d’ensemble de LINQ to XML

LINQ to XML fournit une interface de programmation XML en mémoire qui tire parti du .NET Language-Integrated Query (LINQ). LINQ to XML utilise des fonctionnalités .NET et est comparable à une interface de programmation XML dom (Document Object Model) mise à jour et repensée.

XML a été largement adopté comme moyen de mettre en forme les données dans de nombreux contextes. Par exemple, vous pouvez trouver du code XML sur le web, dans des fichiers de configuration, dans des fichiers Microsoft Office Word et dans des bases de données.

LINQ to XML est une approche moderne et repensée de la programmation avec XML. Il fournit les fonctionnalités de modification de document en mémoire du modèle DOM (Document Object Model) et prend en charge les expressions de requête LINQ. Bien que ces expressions de requête soient syntactiques différentes de XPath, elles fournissent des fonctionnalités similaires.

Développeurs de "LINQ to XML"

LINQ to XML cible un large éventail de développeurs. Pour un développeur moyen qui souhaite simplement effectuer quelque chose, LINQ to XML facilite la tâche XML en fournissant une expérience de requête similaire à SQL. Avec un peu d’étude, les programmeurs peuvent apprendre à écrire des requêtes succinctes et puissantes dans leur langage de programmation de choix.

Les développeurs professionnels peuvent utiliser LINQ to XML pour augmenter considérablement leur productivité. Avec LINQ to XML, ils peuvent écrire moins de code plus expressif, plus compact et plus puissant. Ils peuvent utiliser des expressions de requête à partir de plusieurs domaines de données en même temps.

LINQ to XML est une interface de programmation XML

LINQ to XML est une interface de programmation XML en mémoire compatible LINQ qui vous permet d’utiliser du code XML à partir des langages de programmation .NET.

LINQ to XML est semblable au modèle DOM (Document Object Model) dans lequel il met le document XML en mémoire. Vous pouvez interroger et modifier le document, et après avoir modifié celui-ci, vous pouvez l’enregistrer dans un fichier ou le sérialiser et l’envoyer via Internet. Toutefois, LINQ to XML diffère du DOM :

  • Il fournit un nouveau modèle objet qui est plus léger et plus facile à utiliser.
  • Il tire parti des fonctionnalités de langage en C# et Visual Basic.

L’avantage le plus important de LINQ to XML est son intégration à Language-Integrated Query (LINQ). Cette intégration vous permet d’écrire des requêtes sur le document XML en mémoire pour récupérer des collections d’éléments et d’attributs. La capacité de requête de LINQ to XML est similaire en termes de fonctionnalité, bien que la syntaxe soit différente, à XPath et XQuery. L’intégration de LINQ dans C# et Visual Basic offre un typage plus strict, des vérifications compile-time et une prise en charge améliorée du débogueur.

Un autre avantage de LINQ to XML est la possibilité d’utiliser les résultats de requête comme paramètres dans les constructeurs d’objets XElement et XAttribute, ce qui permet une approche puissante de la création d’arborescences XML. Cette approche, appelée construction fonctionnelle, permet aux développeurs de transformer facilement des arborescences XML d’une forme à une autre.

Par exemple, vous pouvez avoir un bon de commande XML classique, comme décrit dans l’exemple de fichier XML : bon de commande classique. En utilisant LINQ to XML, vous pouvez exécuter la requête suivante pour obtenir la valeur d’attribut numéro de partie pour chaque élément d’élément dans le bon de commande :

// Load the XML file from our project directory containing the purchase orders
var filename = "PurchaseOrder.xml";
var currentDirectory = Directory.GetCurrentDirectory();
var purchaseOrderFilepath = Path.Combine(currentDirectory, filename);

XElement purchaseOrder = XElement.Load(purchaseOrderFilepath);

IEnumerable<string> partNos =  from item in purchaseOrder.Descendants("Item")
                               select (string) item.Attribute("PartNumber");

' Load the XML file from our project directory containing the purchase orders
Dim filename = "PurchaseOrder.xml"
Dim currentDirectory = Directory.GetCurrentDirectory()
Dim purchaseOrderFilepath = Path.Combine(currentDirectory, filename)

Dim purchaseOrder As XElement = XElement.Load(purchaseOrderFilepath)

Dim partNos = _
    From item In purchaseOrder...<Item> _
    Select item.@PartNumber

En C#, il peut être réécrit sous forme de syntaxe de méthode :

IEnumerable<string> partNos = purchaseOrder.Descendants("Item").Select(x => (string) x.Attribute("PartNumber"));

Dans un autre exemple, vous pouvez souhaiter une liste, triée par numéro de partie, des éléments dont la valeur est supérieure à 100 $. Pour obtenir ces informations, vous pouvez exécuter la requête suivante :

// Load the XML file from our project directory containing the purchase orders
var filename = "PurchaseOrder.xml";
var currentDirectory = Directory.GetCurrentDirectory();
var purchaseOrderFilepath = Path.Combine(currentDirectory, filename);

XElement purchaseOrder = XElement.Load(purchaseOrderFilepath);

IEnumerable<XElement> pricesByPartNos =  from item in purchaseOrder.Descendants("Item")
                                 where (int) item.Element("Quantity") * (decimal) item.Element("USPrice") > 100
                                 orderby (string)item.Element("PartNumber")
                                 select item;

' Load the XML file from our project directory containing the purchase orders
Dim filename = "PurchaseOrder.xml"
Dim currentDirectory = Directory.GetCurrentDirectory()
Dim purchaseOrderFilepath = Path.Combine(currentDirectory, filename)

Dim purchaseOrder As XElement = XElement.Load(purchaseOrderFilepath)

Dim partNos = _
From item In purchaseOrder...<Item> _
Where (item.<Quantity>.Value * _
       item.<USPrice>.Value) > 100 _
Order By item.<PartNumber>.Value _
Select item

Là encore, en C#, il peut être réécrit sous forme de syntaxe de méthode :

IEnumerable<XElement> pricesByPartNos = purchaseOrder.Descendants("Item")
                                        .Where(item => (int)item.Element("Quantity") * (decimal)item.Element("USPrice") > 100)
                                        .OrderBy(order => order.Element("PartNumber"));

En plus de ces fonctionnalités LINQ, LINQ to XML fournit une interface de programmation XML améliorée. À l’aide de LINQ to XML, vous pouvez :

  • Chargez du code XML à partir de fichiers ou de flux.
  • Sérialisez du code XML vers des fichiers ou des flux.
  • Créez du code XML à partir de zéro à l’aide de la construction fonctionnelle.
  • Interrogez xml à l’aide d’axes de type XPath.
  • Manipuler l’arborescence XML en mémoire à l’aide de méthodes telles que Add, , RemoveReplaceWith, et SetValue.
  • Validez les arborescences XML à l’aide de XSD.
  • Utilisez une combinaison de ces fonctionnalités pour transformer des arborescences XML d’une forme en une autre.

Créer des arborescences XML

L’un des avantages les plus significatifs de la programmation avec LINQ to XML est qu’il est facile de créer des arborescences XML. Par exemple, pour créer une petite arborescence XML, vous pouvez écrire du code comme suit :

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 As XElement = _
    <Contacts>
        <Contact>
            <Name>Patrick Hines</Name>
            <Phone>206-555-0144</Phone>
            <Address>
                <Street1>123 Main St</Street1>
                <City>Mercer Island</City>
                <State>WA</State>
                <Postal>68042</Postal>
            </Address>
        </Contact>
    </Contacts>

Remarque

La version Visual Basic de l’exemple utilise des littéraux XML. Vous pouvez également utiliser XElement en Visual Basic, comme dans la version C#.

Pour plus d’informations, consultez les arborescences XML.

Voir aussi