Comment : écrire des requêtes LINQ en C#
Mise à jour : novembre 2007
Cette rubrique présente les trois façons d'écrire une requête LINQ en C# :
Utilisez la syntaxe de requête.
Utilisez la syntaxe de méthode.
Utilisez une combinaison de syntaxe de requête et de syntaxe de méthode.
Les exemples suivants montrent des requêtes LINQ simples en utilisant chaque approche répertoriée précédemment. En général, la règle consiste à utiliser (1) dès que possible et à utiliser (2) et (3) dès que cela est nécessaire.
.gif "Remarque") Remarque : |
|---|
Ces requêtes fonctionnent sur les collections simples en mémoire ; toutefois, la syntaxe de base est identique à celle utilisée dans LINQ to SQL et LINQ to XML. |
Exemple
Syntaxe de requête
La méthode recommandée pour écrire la plupart des requêtes consiste à utiliser la syntaxe de requête pour créer des expressions de requête. L'exemple suivant présente trois expressions de requête. La première expression de requête montre comment filtrer ou restreindre des résultats en appliquant des conditions avec une clause where. Tous les éléments dont les valeurs sont supérieures à 7 ou inférieures à 3 sont retournés dans la séquence source. La deuxième expression montre comment classer les résultats retournés. La troisième expression montre comment regrouper des résultats en fonction d'une clé. Cette requête retourne deux groupes en fonction de la première lettre du mot.
// Query #1.
List<int> numbers = new List<int>() { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
// The query variable can also be implicitly typed by using var
IEnumerable<int> filteringQuery =
from num in numbers
where num < 3 || num > 7
select num;
// Query #2.
IEnumerable<int> orderingQuery =
from num in numbers
where num < 3 || num > 7
orderby num ascending
select num;
// Query #3.
string[] groupingQuery = { "carrots", "cabbage", "broccoli", "beans", "barley" };
IEnumerable<IGrouping<char, string>> queryFoodGroups =
from item in groupingQuery
group item by item[0];
Notez que le type des requêtes est IEnumerable<T>. Toutes ces requêtes pourraient être écrites à l'aide de var, comme montré dans l'exemple suivant :
var query = from num in numbers...
Dans chacun des exemples précédents, les requêtes ne s'exécutent pas réellement tant vous n'avez pas parcouru la variable de requête dans une instruction foreach. Pour plus d'informations, consultez Introduction aux requêtes LINQ.
Syntaxe de méthode
Certaines opérations de requête doivent être exprimées comme un appel de méthode. Les plus répandues de ces méthodes retournent des valeurs numériques uniques, telles que Sum, Max, Min, Average, etc. Ces méthodes doivent toujours être appelées en dernier dans toutes les requêtes car elles ne représentent qu'une valeur unique et ne peuvent pas servir de source pour une opération de requête supplémentaire. L'exemple suivant présente un appel de méthode dans une expression de requête :
List<int> numbers1 = new List<int>() { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
List<int> numbers2 = new List<int>() { 15, 14, 11, 13, 19, 18, 16, 17, 12, 10 };
// Query #4.
double average = numbers1.Average();
// Query #5.
IEnumerable<int> concatenationQuery = numbers1.Concat(numbers2);
Si la méthode a des paramètres, ceux-ci sont fournis sous la forme d'une expression lambda, comme dans l'exemple suivant :
// Query #6.
IEnumerable<int> largeNumbersQuery = numbers2.Where(c => c > 15);
Dans les requêtes précédentes, seule la requête 4 s'exécute immédiatement. Cela s'explique par le fait qu'elle retourne une valeur unique et non pas une collection IEnumerable<T> générique. La méthode elle-même doit utiliser foreach pour calculer sa valeur.
Chacune des requêtes précédentes peut être écrite en utilisant des types implicites avec var, comme dans l'exemple suivant :
// var is used for convenience in these queries
var average = numbers1.Average();
var concatenationQuery = numbers1.Concat(numbers2);
var largeNumbersQuery = numbers2.Where(c => c > 15);
Syntaxe de méthode et de requête mixte
Cet exemple montre comment utiliser la syntaxe de méthode sur les résultats d'une clause de requête. Encadrez simplement l'expression de requête entre parenthèses, puis appliquez l'opérateur point et appelez la méthode. Dans l'exemple suivant, la requête 7 retourne les nombres dont la valeur est comprise entre 3 et 7. En général, toutefois, il est préférable d'utiliser une deuxième variable pour stocker le résultat de l'appel de méthode. De cette manière, il est moins probable que la requête soit confondue avec les résultats de la requête.
// Query #7.
// Using a query expression with method syntax
int numCount1 =
(from num in numbers1
where num < 3 || num > 7
select num).Count();
// Better: Create a new variable to store
// the method call result
IEnumerable<int> numbersQuery =
from num in numbers1
where num < 3 || num > 7
select num;
int numCount2 = numbersQuery.Count();
Comme la requête 7 retourne une valeur unique et non pas une collection, la requête s'exécute immédiatement.
La requête précédente peut être écrite en utilisant des types implicites avec var, comme suit :
var numCount = (from num in numbers...
Elle peut être écrite dans la syntaxe de méthode comme suit :
var numCount = numbers.Where(n => n < 3 || n > 7).Count();
Elle peut être écrite en utilisant des types explicites, comme suit :
int numCount = numbers.Where(n => n < 3 || n > 7).Count();
Voir aussi
Tâches
Procédure pas à pas : écriture de requêtes en C# (LINQ)
Concepts
Expressions de requête LINQ (Guide de programmation C#)