Introduction à LINQ dans Visual Basic

LINQ (Language-Integrated Query) ajoute des fonctions de requête à Visual Basic et fournit des fonctions simples et puissantes quand vous travaillez avec tous les types de données. Au lieu d’envoyer une requête à une base de données à des fins de traitement ou d’utiliser une syntaxe de requête différente pour chaque type de 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 prenant en charge LINQ. Vous pouvez faire tout ceci avec les éléments courants du langage Visual Basic. Comme vos requêtes sont écrites en langage Visual Basic, vos résultats de requête sont retournés en tant qu’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 au moment de 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 les résultats. Elles peuvent également être liées à des contrôles pour 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 à partir d'une collection et les regroupe en fonction de leur emplacement.

' Obtain a list of customers.
Dim customers As List(Of Customer) = GetCustomers()

' Return customers that are grouped based on country.
Dim countries = From cust In customers
                Order By cust.Country, cust.City
                Group By CountryName = cust.Country
                Into CustomersInCountry = Group, Count()
                Order By CountryName

' Output the results.
For Each country In countries
    Debug.WriteLine(country.CountryName & " count=" & country.Count)

    For Each customer In country.CustomersInCountry
        Debug.WriteLine("   " & customer.CompanyName & "  " & customer.City)
    Next
Next

' Output:
'   Canada count=2
'      Contoso, Ltd  Halifax
'      Fabrikam, Inc.  Vancouver
'   United States count=1
'      Margie's Travel  Redmond

Exécution des exemples

Pour exécuter les exemples de l’introduction et de la section Structure d’une requête LINQ, incluez le code suivant qui retourne les listes de clients et de commandes.

' Return a list of customers.
Private Function GetCustomers() As List(Of Customer)
    Return New List(Of Customer) From
        {
            New Customer With {.CustomerID = 1, .CompanyName = "Contoso, Ltd", .City = "Halifax", .Country = "Canada"},
            New Customer With {.CustomerID = 2, .CompanyName = "Margie's Travel", .City = "Redmond", .Country = "United States"},
            New Customer With {.CustomerID = 3, .CompanyName = "Fabrikam, Inc.", .City = "Vancouver", .Country = "Canada"}
        }
End Function

' Return a list of orders.
Private Function GetOrders() As List(Of Order)
    Return New List(Of Order) From
        {
            New Order With {.CustomerID = 1, .Amount = "200.00"},
            New Order With {.CustomerID = 3, .Amount = "600.00"},
            New Order With {.CustomerID = 1, .Amount = "300.00"},
            New Order With {.CustomerID = 2, .Amount = "100.00"},
            New Order With {.CustomerID = 3, .Amount = "800.00"}
        }
End Function

' Customer Class.
Private Class Customer
    Public Property CustomerID As Integer
    Public Property CompanyName As String
    Public Property City As String
    Public Property Country As String
End Class

' Order Class.
Private Class Order
    Public Property CustomerID As Integer
    Public Property Amount As Decimal
End Class

Fournisseurs LINQ

Un fournisseur LINQ mappe vos requêtes LINQ Visual Basic à la source de données interrogée. Quand 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 quand vous envoyez des mises à jour à la source de données.

Visual Basic inclut les fournisseurs LINQ suivants.

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 de l'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 la 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 Opérateurs de requête LINQ Visual Basic plus loin 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 customers = GetCustomers()

Dim queryResults = From cust In customers

For Each result In queryResults
    Debug.WriteLine(result.CompanyName & "  " & result.Country)
Next

' Output:
'   Contoso, Ltd  Canada
'   Margie's Travel  United States
'   Fabrikam, Inc.  Canada

Cet exemple représente une requête valide en elle-même ; toutefois, la requête gagne en puissance quand 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 = "Canada"

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 les 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 = "Canada"
               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 customers = GetCustomers()
Dim orders = GetOrders()

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

For Each result In queryResults
    Debug.WriteLine(result.ord.Amount & "  " & result.ord.CustomerID & "  " & result.cust.CompanyName)
Next

' Output:
'   200.00  1  Contoso, Ltd
'   300.00  1  Contoso, Ltd
'   100.00  2  Margie's Travel
'   600.00  3  Fabrikam, Inc.
'   800.00  3  Fabrikam, Inc.

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 customers = GetCustomers()
Dim orders = GetOrders()

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

For Each result In queryResults
    Debug.WriteLine(result.OrderTotal & "  " & result.CustomerID & "  " & result.CompanyName)
    For Each ordResult In result.CustomerOrders
        Debug.WriteLine("   " & ordResult.Amount)
    Next
Next

' Output:
'   500.00  1  Contoso, Ltd
'      200.00
'      300.00
'   100.00  2  Margie's Travel
'      100.00
'   1400.00  3  Fabrikam, Inc.
'      600.00
'      800.00

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.

Opérateurs de requête LINQ Visual Basic

Les classes de l'espace de noms System.Linq et des autres espaces de noms qui prennent en charge les requêtes LINQ incluent des méthodes que vous pouvez appeler pour créer et affiner les requêtes en fonction des besoins de votre application. Visual Basic inclut des mots clés pour les clauses de requête courantes suivantes. Pour plus d’informations sur les clauses de requête Visual Basic, consultez Requêtes.

Clause From

Une clause From ou une clause Aggregate doit commencer une requête. 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 which
' the Country is equal to "Canada".
Dim names = From cust In customers
            Where cust.Country = "Canada"
            Select cust.CompanyName

Select (clause)

Optionnel. Une clause Select 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.

Clause Where

Optionnel. Une clause Where 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)

Optionnel. Une clauseOrder By spécifie l’ordre de tri des colonnes dans 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)

Optionnel. Une clause Join combine deux collections en une seule collection. 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)

Optionnel. Une clause Group By regroupe les éléments d’un résultat de requête. Elle peut être utilisée 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)

Optionnel. Une clause Group Join combine deux collections en une seule collection hiérarchique. 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.Amount)
                   Select cust.CompanyName, cust.CustomerID,
                          CustomerOrders, TotalOfOrders

Aggregate (clause)

Une clause Aggregate ou une clause From doit commencer une requête. 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, comme le fait l’exemple suivant.

' Returns the sum of all order amounts.
Dim orderTotal = Aggregate order In orders
                 Into Sum(order.Amount)

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. Par exemple :

' Returns the customer company name and largest 
' order amount for each customer.
Dim customerMax = From cust In customers
                  Aggregate order In cust.Orders
                  Into MaxOrder = Max(order.Amount)
                  Select cust.CompanyName, MaxOrder

Let (clause)

Optionnel. Une clause Let 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)

Optionnel. Une clause Distinct 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)

Optionnel. Une clause Skip 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

SkipWhile (clause)

Optionnel. Une clause Skip While ignore les éléments d’une collection tant qu’une condition spécifiée a la valeur 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)

Optionnel. Une clause Take 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)

Optionnel. Une clauseTake While inclut les éléments d’une collection tant qu’une condition spécifiée a la valeur 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)

Utiliser des fonctionnalités de requête LINQ supplémentaires

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. L’exemple suivant utilise la méthode Enumerable.Union pour fusionner les résultats de deux requêtes. Il utilise la méthode Enumerable.ToList pour retourner le résultat de la requête sous forme de liste générique.

Public Function GetAllCustomers() As List(Of Customer)
    Dim customers1 = From cust In domesticCustomers
    Dim customers2 = From cust In internationalCustomers

    Dim customerList = customers1.Union(customers2)

    Return customerList.ToList()
End Function

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

Se connecter à une base de données en utilisant LINQ to SQL

En 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.

Quand 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'affiche alors. Le Concepteur O/R vous permet de faire glisser les éléments auxquels vous souhaitez accéder dans votre code depuis l’Explorateur de serveurs/Explorateur de bases de données vers 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 nommé NorthwindDataContext.

Pour obtenir des exemples accompagnés d’instructions pas à pas, consultez Guide pratique : Interroger une base de données et Guide pratique : Appeler une procédure stockée.

Fonctionnalités Visual Basic prenant en charge LINQ

Visual Basic inclut d’autres fonctionnalités notables qui simplifient l’utilisation de LINQ et réduisent la quantité de code que vous devez écrire pour effectuer des requêtes LINQ. Leurs thèmes sont les suivants :

• Types anonymes, qui vous permettent de créer un type en fonction d’un résultat de requête.

• 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.

• 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 de détails, consultez Fonctionnalités Visual Basic prenant 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, quand 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. Quand 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 quand elles sont définies. C’est ce que nous appelons une 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, Min ou Max peut engendrer un tel résultat. Pour plus d’informations sur les fonctions d’agrégation, consultez Aggregate, clause.

L'utilisation de la méthode ToList ou ToArray force également l'exécution immédiate. Cela peut être utile quand 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 des types de données.

Pour plus d’informations sur l’exécution des requêtes, consultez Écriture de votre première requête LINQ.

XML en Visual Basic

Les fonctionnalités XML de Visual Basic incluent des littéraux XML 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.

Ressources associées

Rubriques de guide pratique et de procédure pas à pas

Guide pratique : interroger une base de données

Guide pratique : appeler une procédure stockée

Guide pratique : modifier des données dans une base de données

Guide pratique : combiner des données avec des jointures

Guide pratique : trier les résultats d’une requête

Guide pratique : filtrer les résultats d’une requête

Guide pratique : compter, additionner ou faire la moyenne de données

Guide pratique : rechercher la valeur minimale ou maximale dans un résultat de requête

Guide pratique pour affecter des procédures stockées pour effectuer des mises à jour, des insertions et des suppressions (Concepteur O/R)

Chapitres proposés

Chapitre 17 : LINQ dans Programming Visual Basic 2008

Voir aussi

• LINQ (Language Integrated Query)
• Vue d’ensemble de LINQ to XML en Visual Basic
• Vue d'ensemble de LINQ to DataSet
• LINQ to SQL
• LINQ to SQL Tools dans Visual Studio
• DataContext, méthodes (Concepteur O/R)