Partager via


Opérations de requête de base (Visual Basic)

Cette rubrique fournit une brève introduction aux expressions LINQ (Language-Integrated Query) dans Visual Basic, et à certains des types d’opérations classiques que vous effectuez dans une requête. Pour plus d'informations, voir les rubriques suivantes :

Introduction à LINQ en Visual Basic

Requêtes

Procédure pas à pas : écriture de requêtes dans Visual Basic

Spécification de la source de données (From)

Dans une requête LINQ, la première étape consiste à spécifier la source de données à interroger. Par conséquent, la clause From d’une requête est toujours disponible en premier. Les opérateurs de requête sélectionnent et forment le résultat en fonction du type de la source.

Dim query = From cust In customers
'           ...

La clause From spécifie la source de données, customerset une variable de plage, cust. La variable de plage est semblable à une variable d’itération de boucle, sauf que dans une expression de requête, aucune itération réelle ne se produit. Lorsque la requête est exécutée, souvent à l’aide d’une boucle For Each, la variable de plage sert de référence à chaque élément successif dans customers. Comme le compilateur déduit le type de cust, vous n’avez pas à le spécifier explicitement. Pour obtenir des exemples de requêtes écrites avec et sans saisie explicite, consultez Relations de types dans les opérations de requête (Visual Basic).

Pour plus d’informations sur l’utilisation de la clause From dans Visual Basic, consultez Clause From.

Filtrage des données (Where)

L'opération de requête la plus courante est probablement l'application d'un filtre sous forme d'expression booléenne. La requête retourne ensuite uniquement les éléments pour lesquels l’expression est vraie. Une clause Where est utilisée pour effectuer le filtrage. Le filtre spécifie les éléments de la source de données à inclure dans la séquence résultante. Dans l’exemple suivant, seuls les clients ayant une adresse à Londres sont inclus.

Dim londonCusts = From cust In customers
                  Where cust.City = "London"
'                 ...

Vous pouvez utiliser des opérateurs logiques tels que And et Or pour combiner des expressions de filtre dans une clause Where. Par exemple, pour renvoyer uniquement les clients de Londres et dont le nom est Devon, utilisez le code suivant :

Where cust.City = "London" And cust.Name = "Devon"

Pour renvoyer des clients de Londres ou de Paris, utilisez le code suivant :

Where cust.City = "London" Or cust.City = "Paris"

Pour plus d’informations sur l’utilisation de la clause Where dans Visual Basic, consultez Clause Where.

Classement des données (Order by)

Il est souvent pratique de trier les données retournées dans un ordre particulier. La clause Order By entraîne le tri des éléments de la séquence retournée sur un champ ou des champs spécifiés. Par exemple, la requête suivante trie les résultats en fonction de la propriété Name. Étant donné que Name est une chaîne, les données retournées sont triées par ordre alphabétique, de A à Z.

Dim londonCusts1 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
'                   ...

Pour trier les résultats dans l’ordre inverse, de Z à A, utilisez la clause Order By...Descending. La valeur par défaut est Ascending quand ni Ascending ni Descending n’est spécifié.

Pour plus d’informations sur l’utilisation de la clause Order By dans Visual Basic, consultez Clause Order By.

Sélection de données (Select)

La clause Select spécifie la forme et le contenu des éléments retournés. Par exemple, vous pouvez spécifier si vos résultats doivent se composer d’objets complets Customer, d’une seule propriété Customer, d’un sous-ensemble de propriétés, d’une combinaison de propriétés provenant de différentes sources de données ou d’un nouveau type de résultat basé sur un calcul. Quand la clause Select produit autre chose qu’une copie de l’élément source, l’opération est appelée projection.

Pour récupérer une collection composée d’objets complets Customer, sélectionnez la variable de plage concernée :

Dim londonCusts2 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select cust

Si une instance Customer est un objet volumineux qui a de nombreux champs et que vous souhaitez en récupérer le nom, vous pouvez sélectionner cust.Name, comme illustré dans l’exemple suivant. L’inférence de type local reconnaît que cela modifie le type de résultat d’une collection d’objets Customer en une collection de chaînes.

Dim londonCusts3 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select cust.Name

Pour sélectionner plusieurs champs dans la source de données, vous avez deux choix :

  • Dans la clause Select, spécifiez les champs que vous souhaitez inclure dans le résultat. Le compilateur définit un type anonyme ayant ces champs comme propriétés. Pour plus d’informations, consultez Types anonymes.

    Étant donné que les éléments retournés dans l’exemple suivant sont des instances de type anonyme, vous ne pouvez pas faire référence au type par nom ailleurs dans votre code. Le nom désigné par le compilateur pour le type contient des caractères qui ne sont pas valides dans le code Visual Basic normal. Dans l’exemple suivant, les éléments de la collection retournés par la requête londonCusts4 sont des instances de type anonyme

    Dim londonCusts4 = From cust In customers
                       Where cust.City = "London"
                       Order By cust.Name Ascending
                       Select Name = cust.Name, Phone = cust.Phone
    
    For Each londonCust In londonCusts4
        Console.WriteLine(londonCust.Name & " " & londonCust.Phone)
    Next
    

    -ou-

  • Définissez un type nommé contenant les champs que vous souhaitez inclure dans le résultat, puis créez et initialisez des instances du type dans la clause Select. Utilisez cette option uniquement si vous devez utiliser des résultats individuels en dehors de la collection dans laquelle ils sont retournés, ou si vous devez les transmettre en tant que paramètres dans les appels de méthode. Le type de londonCusts5 de l’exemple suivant est IEnumerable(Of NamePhone).

    Public Class NamePhone
        Public Name As String
        Public Phone As String
        ' Additional class elements
    End Class
    
    Dim londonCusts5 = From cust In customers
                       Where cust.City = "London"
                       Order By cust.Name Ascending
                       Select New NamePhone With {.Name = cust.Name,
                                                  .Phone = cust.Phone}
    

Pour plus d’informations sur l’utilisation de la clause Select dans Visual Basic, consultez Sélectionner une clause.

Jointure de données (Join et Group Join)

Vous pouvez combiner plusieurs sources de données dans la clause From de plusieurs façons. Par exemple, le code suivant utilise deux sources de données et combine implicitement les propriétés de chacune dans le résultat. La requête sélectionne les étudiants dont le nom commence par une voyelle.

Dim vowels() As String = {"A", "E", "I", "O", "U"}
Dim vowelNames = From student In students, vowel In vowels
                 Where student.Last.IndexOf(vowel) = 0
                 Select Name = student.First & " " &
                 student.Last, Initial = vowel
                 Order By Initial

For Each vName In vowelNames
    Console.WriteLine(vName.Initial & ":  " & vName.Name)
Next

Notes

Vous pouvez exécuter ce code avec la liste des étudiants créée dans Comment créer une liste d'éléments.

Dans SQL, le mot-clé Join est équivalent à un mot-clé INNER JOIN. Il combine deux collections basées sur des valeurs de clés correspondantes entre les éléments des deux collections. La requête retourne tous ou une partie des éléments de collection ayant des valeurs de clés correspondantes. Par exemple, le code suivant duplique l’action de la jointure implicite précédente.

Dim vowelNames2 = From student In students
                  Join vowel In vowels
                  On student.Last(0) Equals vowel
                  Select Name = student.First & " " &
                  student.Last, Initial = vowel
                  Order By Initial

Group Join combine des collections en une seule collection hiérarchique, comme LEFT JOIN dans SQL. Pour plus d’informations, consultez Clause Join etClause Group Join.

Regroupement de données (Group by)

Vous pouvez ajouter une clause Group By pour regrouper les éléments dans un résultat de requête en fonction d’un ou de plusieurs champs d’éléments. Par exemple, le code suivant regroupe les étudiants par classe.

Dim studentsByYear = From student In students
                     Select student
                     Group By year = student.Year
                     Into Classes = Group

For Each yearGroup In studentsByYear
    Console.WriteLine(vbCrLf & "Year: " & yearGroup.year)
    For Each student In yearGroup.Classes
        Console.WriteLine("   " & student.Last & ", " & student.First)
    Next
Next

Si vous exécutez ce code à l’aide de la liste des étudiants créés dans Comment créer une liste d'éléments, la sortie de l’instruction For Each sera :

Classe : Junior

Tucker, Michael

Garcia, Hugo

Garcia, Debra

Tucker, Lance

Classe : Senior

Omelchenko, Svetlana

Osada, Michiko

Fakhouri, Fadi

Feng, Hanying

Adams, Terry

Année : Freshman

Mortensen, Sven

Garcia, Cesar

La variation indiquée dans le code suivant commande les classes, puis commande les étudiants de chaque classe par nom.

Dim studentsByYear2 = From student In students
                      Select student
                      Order By student.Year, student.Last
                      Group By year = student.Year
                      Into Classes = Group

Pour plus d’informations sur Group By, consultez Clause Group By.

Voir aussi