Introduction à LINQ dans Visual Basic

Article
08/21/2008

Mise à jour : novembre 2007

LINQ (Language-Integrated Query) ajoute des fonctions de requête à Visual Basic et fournit des fonctions simples et puissantes permettant de travailler avec tous les types de données. Plutôt qu'envoyer une requête à une base de données à traiter ou utiliser une syntaxe de requête différente pour chaque type des données que vous recherchez, LINQ introduit des requêtes dans le cadre du langage Visual Basic. Il utilise une syntaxe unifiée indépendamment du type de données.

LINQ vous permet d'interroger les données d'une base de données SQL Server, données XML, collections et tableaux en mémoire, groupe de données ADO.NET ou toute autre source de données distante ou locale qui prend en charge LINQ. Vous pouvez faire toutes ces choses avec les éléments de langage Visual Basic communs. Comme vos requêtes sont écrites en langage Visual Basic, vos résultats de requête sont retournés comme objets fortement typés. Ces objets prennent en charge IntelliSense, qui vous permet d'écrire du code plus rapidement et d'intercepter les erreurs dans vos requêtes à la compilation plutôt qu'au moment de l'exécution. Les requêtes LINQ peuvent être utilisées comme source de requêtes supplémentaires pour affiner des résultats. Elles peuvent également être liées à des contrôles afin que les utilisateurs puissent afficher et modifier facilement vos résultats de requête.

Par exemple, l'exemple de code suivant affiche une requête LINQ qui retourne une liste de clients (customers) d'une collection et les regroupe en fonction de leur emplacement.

Dim customers As List(Of Customer) = GetCustomerList()

Dim customersByCountry = From cust In customers _
                         Order By cust.Country, cust.City _
                         Group By CountryName = cust.Country _
                         Into RegionalCustomers = Group, Count() _
                         Order By CountryName

For Each country In customersByCountry
  Console.WriteLine(country.CountryName & _
                    " (" & country.Count & ")" & vbCrLf)

  For Each customer In country.RegionalCustomers
    Console.WriteLine(vbTab & customer.CompanyName & _
                      " (" & customer.City & ")")
  Next
Next

Cette rubrique fournit des informations à propos des zones suivantes :

Fournisseurs LINQ
Structure d'une requête LINQ
Opérateurs de requête LINQ Visual Basic
Connexion à une base de données à l'aide de LINQ to SQL
Fonctionnalités Visual Basic prenant en charge LINQ
Exécution de requête différée et immédiate
XML dans Visual Basic
Ressources connexes
Rubriques "Comment" et "Procédure pas à pas"

Fournisseurs LINQ

Un fournisseur LINQ mappe vos requêtes LINQ Visual Basic à la source de données interrogée. Lorsque vous écrivez une requête LINQ, le fournisseur prend cette requête et la traduit en commandes que la source de données sera en mesure d'exécuter. Le fournisseur convertit également des données de la source en objets qui composent votre résultat de la requête. Enfin, il convertit des objets en données lorsque vous envoyez des mises à jour à la source de données.

Visual Basic inclut les fournisseurs LINQ suivants.

LINQ to Objects
Le fournisseur LINQ to Objects vous permet d'interroger des collections et des tableaux en mémoire. Si un objet prend en charge l'interface IEnumerable ou IEnumerable<T>, le fournisseur LINQ to Objects vous permet de l'interroger.

Vous pouvez activer le fournisseur LINQ to Objects en important l'espace de noms System.Linq, importé par défaut pour tous les projets Visual Basic.

Pour plus d'informations sur le fournisseur LINQ to Objects, consultez LINQ to Objects.
LINQ to SQL
Le fournisseur LINQ to SQL vous permet d'interroger et de modifier des données dans une base de données SQL Server. Cela facilite le mappage du modèle objet d'une application aux tables et objets d'une base de données.

Visual Basic facilite l'utilisation de LINQ to SQL en incluant le Concepteur Objet/Relationnel (Concepteur O/R). Ce concepteur est utilisé pour créer, dans une application, un modèle objet qui effectue un mappage aux objets d'une base de données. Le Concepteur O/R propose également des fonctionnalités de mappage des procédures et des fonctions stockées à l'objet DataContext, qui gère la communication avec la base de données et stocke les informations d'état des contrôles d'accès concurrentiel optimiste.

Pour plus d'informations sur le fournisseur LINQ to SQL, consultez LINQ to SQL. Pour plus d'informations sur le Concepteur Objet/Relationnel, consultez Concepteur Objet/Relationnel (Concepteur O/R).
LINQ to XML
Le fournisseur LINQ to XML vous permet d'interroger et de modifier du XML. Vous pouvez modifier des données XML en mémoire ou les charger à partir d'un fichier, mais également les enregistrer dans un fichier.

En outre, le fournisseur LINQ to XML active des littéraux XML et des propriétés d'axe XML qui vous permettent d'écrire directement du XML dans votre code Visual Basic. Pour plus d'informations, consultez XML en Visual Basic.
LINQ to DataSet
Le fournisseur LINQ to DataSet vous permet d'interroger et de mettre à jour des données dans un groupe de données ADO.NET. Vous pouvez mettre en œuvre la puissance de LINQ dans les applications qui utilisent des groupes de données afin de simplifier et d'étendre vos fonctions de requête, d'agrégation et de mise à jour des données de votre groupe de données.

Pour plus d'informations, consultez LINQ to DataSet.

Structure d'une requête LINQ

Une requête LINQ, souvent appelée expression de requête, se compose d'une combinaison de clauses de requête qui identifient les sources de données et les variables d'itération pour la requête. Une expression de requête peut également inclure des instructions de tri, de filtrage, de regroupement et de jonction ou des calculs applicables aux données sources. La syntaxe d'expression de requête ressemble à la syntaxe de SQL ; par conséquent, une grande partie de cette syntaxe vous semblera familière.

Une expression de requête commence par une clause From. Cette clause identifie les données sources d'une requête et les variables utilisées pour faire individuellement référence à chaque élément des données sources. Ces variables sont appelées variables de portée ou variables d'itération. La clause From est nécessaire pour une requête, à l'exception des requêtes Aggregate, où la clause From est facultative. Après avoir identifié la portée et source de la requête dans les clauses From ou Aggregate, vous pouvez inclure toute combinaison de clauses de requête pour affiner la requête. Pour plus d'informations sur les clauses de requête, consultez la section Opérateurs de requête LINQ Visual Basic ultérieurement dans cette rubrique. Par exemple, la requête suivante identifie une collection de sources de données client comme variable customers et une variable d'itération appelée cust.

Dim queryResults = From cust In customers _
                   Select cust.CompanyName

Cet exemple représente une requête valide en elle-même ; toutefois, la requête gagne en puissance lorsque vous ajoutez davantage de clauses de requête pour affiner le résultat. Par exemple, vous pouvez ajouter une clause Where pour filtrer le résultat en fonction d'une ou plusieurs valeurs. Les expressions de requête forment une ligne unique de code ; il vous suffit d'ajouter des clauses de requête supplémentaires à la fin de la requête. Vous pouvez décomposer une requête en plusieurs lignes de texte pour améliorer la lisibilité à l'aide du trait de soulignement (_), un caractère de continuation de ligne. L'exemple de code suivant illustre une requête qui inclut une clause Where.

Dim queryResults = From cust In customers _
                   Where cust.Country = "USA"

Autre clause de requête performante, la clause Select vous permet de retourner uniquement des champs sélectionnés de la source de données. Les requêtes LINQ retournent des collections énumérables d'objets fortement typés. Une requête peut retourner une collection de types anonymes ou nommés. Vous pouvez utiliser la clause Select pour retourner uniquement un champ de la source de données. Dans ce cas, le type de la collection retournée est le type de ce champ unique. Vous pouvez également utiliser la clause Select pour retourner plusieurs champs de la source de données. Dans ce cas, le type de la collection retournée est un nouveau type anonyme. Vous pouvez également faire correspondre les champs retournés par la requête aux champs d'un type nommé spécifié. L'exemple de code suivant affiche une expression de requête qui retourne une collection de types anonymes dont des membres sont remplis des données des champs sélectionnés de la source de données.

Dim queryResults = From cust In customers _
               Where cust.Country = "USA" _
               Select cust.CompanyName, cust.Country

Les requêtes LINQ peuvent également être utilisées pour combiner plusieurs sources de données et retourner un résultat unique. Cette opération peut être effectuée à l'aide d'une ou plusieurs clauses From ou en utilisant les clauses de requête Join ou Group Join. L'exemple de code suivant illustre une expression de requête qui combine des données de client et de commande et retourne une collection de types anonymes contenant ces deux types de données.

Dim queryResults = From cust In customers, ord In orders _
                   Where cust.CustomerID = ord.CustomerID _
                   Select cust, ord

Vous pouvez utiliser la clause Group Join pour créer un résultat de requête hiérarchique contenant une collection d'objets Customer. Chaque objet customer possède une propriété contenant une collection de toutes les commandes de ce client. L'exemple de code suivant affiche une expression de requête qui combine des données client/commande sous forme de résultat hiérarchique et retourne une collection de types anonymes. La requête retourne un type qui inclut une propriété CustomerOrders contenant une collection de données de commande pour le client. Il inclut également une propriété OrderTotal qui contient la somme des totaux pour toutes les commandes de ce client. (Cette requête est équivalente à une JOINTURE EXTERNE GAUCHE.)

Dim queryResults = From cust In customers _
                   Group Join ord In orders On _
                     cust.CustomerID Equals ord.CustomerID _
                     Into CustomerOrders = Group, _
                          OrderTotal = Sum(ord.Total) _
                   Select cust.CompanyName, cust.CustomerID, _
                          CustomerOrders, OrderTotal

Il existe plusieurs opérateurs de requête LINQ supplémentaires qui vous permettent de créer des expressions de requête puissantes. La section suivante de cette rubrique présente les différentes clauses de requête que vous pouvez inclure dans une expression de requête. Pour plus d'informations sur les clauses de requête Visual Basic, consultez Requêtes (Visual Basic).

Opérateurs de requête LINQ Visual Basic

Les classes de l'espace de noms System.Linq et les autres espaces de noms prenant en charge les requêtes LINQ incluent des méthodes que vous pouvez appeler pour créer et affiner des requêtes selon les besoins de votre application. Visual Basic inclut des mots clés pour les clauses de requête les plus courantes, comme l'illustre le tableau suivant.

From, clause (Visual Basic)
Une requête doit commencer par une clause From ou Aggregate. Une clause From spécifie une collection de sources et une variable d'itération pour une requête. Par exemple :
```
' Returns the company name for all customers for whom
' State is equal to "WA".
Dim names = From cust In customers _
            Where cust.State = "WA" _
            Select cust.CompanyName
```
Select, clause (Visual Basic)
Facultatif. Déclare un jeu de variables d'itération pour une requête. Par exemple :
```
' Returns the company name and ID value for each
' customer as a collection of a new anonymous type.
Dim customerList = From cust In customers _
                   Select cust.CompanyName, cust.CustomerID
```
Si une clause Select n'est pas spécifiée, les variables d'itération de la requête se composent des variables d'itération spécifiées par la clause From ou Aggregate.

Where, clause (Visual Basic)
Facultatif. Spécifie une condition de filtrage pour une requête. Par exemple :

' Returns all product names for which the Category of
' the product is "Beverages".
Dim names = From product In products _
            Where product.Category = "Beverages" _
            Select product.Name

Order By, clause (Visual Basic)
Facultatif. Spécifie l'ordre de tri des colonnes d'une requête. Par exemple :

' Returns a list of books sorted by price in 
' ascending order.
Dim titlesAscendingPrice = From b In books _
                           Order By b.price

Join, clause (Visual Basic)
Facultatif. Regroupe deux collections en une collection unique. Par exemple :

' Returns a combined collection of all of the 
' processes currently running and a descriptive
' name for the process taken from a list of 
' descriptive names.
Dim processes = From proc In Process.GetProcesses _
                Join desc In processDescriptions _
                  On proc.ProcessName Equals desc.ProcessName _
                Select proc.ProcessName, proc.Id, desc.Description

Group By, clause (Visual Basic)
Facultatif. Groupe les éléments d'un résultat de requête. Peut être utilisé pour appliquer des fonctions d'agrégation à chaque groupe. Par exemple :

' Returns a list of orders grouped by the order date
' and sorted in ascending order by the order date.
Dim orderList = From order In orders _
                Order By order.OrderDate _
                Group By OrderDate = order.OrderDate _
                Into OrdersByDate = Group

Group Join, clause (Visual Basic)
Facultatif. Regroupe deux collections en une collection hiérarchique unique. Par exemple :

' Returns a combined collection of customers and
' customer orders.
Dim customerList = From cust In customers _
                   Group Join ord In orders On _
                     cust.CustomerID Equals ord.CustomerID _
                   Into CustomerOrders = Group, _
                        TotalOfOrders = Sum(ord.Total) _
                   Select cust.CompanyName, cust.CustomerID, _
                          CustomerOrders, TotalOfOrders

Aggregate, clause (Visual Basic)
Une requête doit commencer par une clause From ou Aggregate. Une clause Aggregate applique une ou plusieurs fonctions d'agrégation à une collection. Par exemple, vous pouvez utiliser la clause Aggregate pour calculer une somme de tous les éléments retournés par une requête.
```
' Returns the sum of all order totals.
Dim orderTotal = Aggregate order In orders _
                 Into Sum(order.Total)
```
Vous pouvez également utiliser la clause Aggregate pour modifier une requête. Par exemple, vous pouvez utiliser la clause Aggregate pour effectuer un calcul sur une collection de requêtes connexe.
```
' Returns the customer company name and largest 
' order total for each customer.
Dim customerMax = From cust In customers _
                  Aggregate order In cust.Orders _
                  Into MaxOrder = Max(order.Total) _
                  Select cust.CompanyName, MaxOrder
```

Let, clause (Visual Basic)
Facultatif. Calcule une valeur et l'assigne à une nouvelle variable dans la requête. Par exemple :

' Returns a list of products with a calculation of
' a ten percent discount.
Dim discountedProducts = From prod In products _
                         Let Discount = prod.UnitPrice * 0.1 _
                         Where Discount >= 50 _
                         Select prod.Name, prod.UnitPrice, Discount

Distinct, clause (Visual Basic)
Facultatif. Restreint les valeurs de la variable d'itération actuelle pour éliminer les valeurs en double dans les résultats de la requête. Par exemple :
```
' Returns a list of cities with no duplicate entries.
Dim cities = From item In customers _
             Select item.City _
             Distinct
```

Skip, clause (Visual Basic)
Facultatif. Ignore un nombre spécifié d'éléments dans une collection, puis retourne les éléments restants. Par exemple :

' Returns a list of customers. The first 10 customers
' are ignored and the remaining customers are
' returned.
Dim customerList = From cust In customers _
                   Skip 10

Skip While, clause (Visual Basic)
Facultatif. Ignore les éléments d'une collection tant qu'une condition spécifiée est true, puis retourne les éléments restants. Par exemple :

' Returns a list of customers. The query ignores all
' customers until the first customer for whom
' IsSubscriber returns false. That customer and all
' remaining customers are returned.
Dim customerList = From cust In customers _
                   Skip While IsSubscriber(cust)

Take, clause (Visual Basic)
Facultatif. Retourne un nombre spécifié d'éléments contigus à partir du début d'une collection. Par exemple :
```
' Returns the first 10 customers.
Dim customerList = From cust In customers _
                   Take 10
```

Take While, clause (Visual Basic)
Facultatif. Inclut des éléments dans une collection tant qu'une condition spécifiée est true et ignore les éléments restants. Par exemple :

' Returns a list of customers. The query returns
' customers until the first customer for whom 
' HasOrders returns false. That customer and all 
' remaining customers are ignored.
Dim customersWithOrders = From cust In customers _
                          Order By cust.Orders.Count Descending _
                          Take While HasOrders(cust)

Pour plus d'informations sur les clauses de requête Visual Basic, consultez Requêtes (Visual Basic).

Vous pouvez utiliser des fonctionnalités de requête LINQ supplémentaires en appelant des membres des types énumérables et requêtables fournis par LINQ. Vous pouvez utiliser ces fonctions supplémentaires en appelant un opérateur de requête particulier sur le résultat d'une expression de requête. Par exemple, l'exemple de code suivant utilise la méthode Union pour fusionner les résultats de deux requêtes. Il utilise la méthode ToList<TSource> pour retourner le résultat de la requête sous forme de liste générique.

VbVbalrIntroToLINQ#22

Pour plus d'informations sur les fonctions LINQ supplémentaires, consultez Vue d'ensemble des opérateurs de requête standard.

Connexion à une base de données à l'aide de LINQ to SQL

Dans Visual Basic, vous identifiez les objets de base de données SQL Server, comme les tables, vues et procédures stockées, auxquels vous souhaitez accéder en utilisant un fichier LINQ to SQL. Un fichier LINQ to SQL possède une extension .dbml.

Lorsque vous avez établi une connexion valide à une base de données SQL Server, vous pouvez ajouter un modèle d'élément Classes LINQ to SQL à votre projet. Le Concepteur Objet/Relationnel (Concepteur O/R) s'affichera alors. Le Concepteur O/R vous permet de faire glisser les éléments auxquels vous souhaitez accéder dans votre code de l'Explorateur de serveurs/Explorateur de bases de données sur l'aire du concepteur. Le fichier LINQ to SQL ajoute un objet DataContext à votre projet. Cet objet inclut des propriétés et des collections pour les tables et vues auxquelles vous souhaitez accéder, et aux méthodes des procédures stockées que vous souhaitez appeler. Après avoir enregistré vos modifications dans le fichier LINQ to SQL (.dbml), vous pouvez accéder à ces objets dans votre code en référençant l'objet DataContext défini par le Concepteur O/R. L'objet DataContext de votre projet est nommé d'après le nom de votre fichier LINQ to SQL. Par exemple, un fichier LINQ to SQL nommé Northwind.dbml créera un objet DataContext dénommé NorthwindDataContext.

Pour consulter des exemples accompagnés d'instructions pas à pas, consultez Comment : interroger une base de données à l'aide de LINQ (Visual Basic) et Comment : appeler une procédure stockée à l'aide de LINQ (Visual Basic).

Fonctionnalités Visual Basic prenant en charge LINQ

Visual Basic inclut d'autres fonctionnalités notables qui facilitent l'utilisation de LINQ et réduisent la quantité de code que vous devez écrire pour effectuer des requêtes LINQ. et notamment :

Les types anonymes, qui vous permettent de créer un nouveau type en fonction d'un résultat de requête.
Les variables implicitement typées, qui vous permettent de différer la spécification d'un type et laisser le compilateur le déduire en fonction du résultat de la requête.
Les méthodes d'extension, qui vous permettent d'étendre un type existant avec vos propres méthodes sans modifier le type lui-même.

Pour plus d'informations, consultez Fonctionnalités Visual Basic qui prennent en charge LINQ.

Exécution de requête différée et immédiate

L'exécution d'une requête est distincte de sa création. Après avoir créé une requête, son exécution est déclenchée par un mécanisme distinct. Une requête peut être exécutée dès qu'elle est définie (exécution immédiate) ou la définition peut être stockée et la requête peut être exécutée ultérieurement (exécution différée).

Par défaut, lorsque vous créez une requête, cette dernière ne s'exécute pas immédiatement. À la place, la définition de la requête est stockée dans la variable utilisée pour référencer le résultat de la requête. Lorsque vous accédez à la variable de résultat de la requête ultérieurement dans le code, par exemple, dans une boucle For…Next, la requête est exécutée. Ce processus est connu sous le nom d'exécution différée.

Les requêtes peuvent également être exécutées lorsqu'elles sont définies ; cette méthode est appelée exécution immédiate. Vous pouvez déclencher l'exécution immédiate en appliquant une méthode qui requiert l'accès aux éléments individuels du résultat de la requête. L'inclusion d'une fonction d'agrégation, telle que Count, Sum, Average, Minou Max peut engendrer un tel résultat. Pour plus d'informations sur les fonctions d'agrégation, consultez Aggregate, clause (Visual Basic).

L'utilisation des méthodes ToList ou ToArray forcera également l'exécution immédiate. Cela peut être utile lorsque vous souhaitez exécuter immédiatement la requête et mettre en cache les résultats. Pour plus d'informations sur ces méthodes, consultez Conversion de types de données.

Pour plus d'informations sur l'exécution de la requête, consultez Écriture de votre première requête LINQ (Visual Basic).

XML dans Visual Basic

Les fonctionnalités XML de Visual Basic incluent des littéraux et des propriétés d'axe XML, qui facilitent la création, l'accès, l'interrogation et la modification du XML dans votre code. Les littéraux XML vous permettent d'écrire directement en XML dans votre code. Le compilateur Visual Basic traite le XML comme un objet de donnée de première classe.

L'exemple de code suivant montre comment créer un élément XML, accéder à ses sous-éléments et attributs et interroger son contenu à l'aide de LINQ.

' Place Imports statements at the top of your program.  
Imports <xmlns:ns="http://SomeNamespace">

Module Sample1

    Sub SampleTransform()

        ' Create test by using a global XML namespace prefix. 

        Dim contact = _
            <ns:contact>
                <ns:name>Patrick Hines</ns:name>
                <ns:phone ns:type="home">206-555-0144</ns:phone>
                <ns:phone ns:type="work">425-555-0145</ns:phone>
            </ns:contact>

        Dim phoneTypes = _
          <phoneTypes>
              <%= From phone In contact.<ns:phone> _
                  Select <type><%= phone.@ns:type %></type> _
              %>
          </phoneTypes>

        Console.WriteLine(phoneTypes)
    End Sub

End Module

Pour plus d'informations, consultez XML en Visual Basic.

Ressources connexes

XML en Visual Basic
Décrit les fonctionnalités XML de Visual Basic qui peuvent être interrogées et qui vous permettent d'inclure du XML sous forme d'objets de données de première classe dans votre code Visual Basic.
Requêtes (Visual Basic)
Fournit des informations de référence sur les clauses de requête disponibles dans Visual Basic.
LINQ (Language-Integrated Query)
Inclut des informations générales, un guide de programmation et des exemples de requêtes LINQ.
LINQ to SQL
Inclut des informations générales, un guide de programmation et des exemples de LINQ to SQL.
LINQ to Objects
Inclut des informations générales, un guide de programmation et des exemples de LINQ to Objects.
LINQ to ADO.NET (page de portail)
Inclut des liens vers des informations générales, un guide de programmation et des exemples de LINQ to ADO.NET.
LINQ to XML
Inclut des informations générales, un guide de programmation et des exemples de LINQ to XML.