Introduction à LINQ dans Visual Basic

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.

' 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

Cette rubrique fournit des informations à propos des zones suivantes :

  • Exécuter les exemples

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

Exécuter les exemples

Pour exécuter les exemples dans l'introduction et dans la structure « la section de requête LINQ », incluent le code suivant, qui retourne les listes de clients et des 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.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.

Fournisseur

Description

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 un modèle objet dans une application qui mappe aux objets d'une base de données. Le concepteur O/R propose également des fonctionnalités aux procédures stockées et des fonctions de mappage à l'objet d' DataContext, qui gère la communication avec la base de données et état de magasins pour l'accès concurrentiel optimiste contrôle.

Pour plus d'informations sur le fournisseur LINQ to SQL, consultez LINQ to SQL.Pour plus d'informations sur le Concepteur Objet/Relationnel, consultez Object Relational Designer (O/R Designer).

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 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 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 = "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 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 = "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 (Visual Basic).

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 les plus courantes, comme indiqué par le tableau suivant.

Terme

Définition

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 :

Select, clause (Visual Basic)

Optionnel.Déclare un jeu de variables d'itération pour une requête.Par exemple :

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)

Optionnel.Spécifie une condition de filtrage pour une requête.Par exemple :

Order By, clause (Visual Basic)

Optionnel.Spécifie l'ordre de tri des colonnes dans une requête.Par exemple :

Join, clause (Visual Basic)

Optionnel.Regroupe deux collections en une collection unique.Par exemple :

Group By, clause (Visual Basic)

Optionnel.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 :

Group Join, clause (Visual Basic)

Optionnel.Regroupe deux collections en une collection hiérarchique unique.Par exemple :

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.

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.

Let, clause (Visual Basic)

Optionnel.Calcule une valeur et l'assigne à une nouvelle variable dans la requête.Par exemple :

Distinct, clause (Visual Basic)

Optionnel.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 :

Skip, clause (Visual Basic)

Optionnel.Ignore un nombre spécifié d'éléments dans une collection, puis retourne les éléments restants.Par exemple :

Skip While, clause (Visual Basic)

Optionnel.Ignore les éléments d'une collection tant qu'une condition spécifiée est true, puis retourne les éléments restants.Par exemple :

Take, clause (Visual Basic)

Optionnel.Retourne un nombre spécifié d'éléments contigus à partir du début d'une collection.Par exemple :

Take While, clause (Visual Basic)

Optionnel.Inclut des éléments dans une collection tant qu'une condition spécifiée est true et ignore les éléments restants.Par exemple :

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.

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.

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 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, 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 des 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

Rubrique

Description

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.

Rubriques "Comment" et "Procédure pas à pas"

Comment : interroger une base de données à l'aide de LINQ (Visual Basic)

Comment : appeler une procédure stockée à l'aide de LINQ (Visual Basic)

Comment : modifier des données dans une base de données à l'aide de LINQ (Visual Basic)

Comment : combiner des données avec LINQ à l'aide de jointures (Visual Basic)

Comment : trier les résultats d'une requête à l'aide de LINQ (Visual Basic)

Comment : filtrer les résultats d'une requête à l'aide de LINQ (Visual Basic)

Comment : compter, additionner ou faire la moyenne de données à l'aide de LINQ (Visual Basic)

Comment : rechercher la valeur minimale ou maximale dans un résultat de requête à l'aide de LINQ (Visual Basic)

Walkthrough: Creating LINQ to SQL Classes (O/R Designer)

How to: Assign Stored Procedures to Perform Updates, Inserts, and Deletes (O/R Designer)

Chapitres proposés

Chapter 17: LINQ dans Programming Visual Basic 2008

Voir aussi

Tâches

Exemples LINQ

Concepts

Vue d'ensemble de LINQ to XML dans Visual Basic

LINQ to DataSet Overview

DataContext Methods (O/R Designer)

Autres ressources

LINQ (Language-Integrated Query)

LINQ to SQL

Object Relational Designer (O/R Designer)