1. Introduction
Souviens-toi comment marche un Select classique :
var names = users.Select(user => user.Name);
À chaque utilisateur, on associe son nom — on obtient une liste de noms. Facile ! Mais si on veut la liste de toutes les commandes de tous les utilisateurs ?
var ordersList = users.Select(user => user.Orders);
Qu'est-ce qui se passe ici ? Pour chaque utilisateur, on récupère une liste de commandes. Donc au final, c'est une collection de collections (IEnumerable<List<Order>>). C'est comme une étagère avec des boîtes : pour accéder à chaque commande, tu dois ouvrir chaque boîte (la liste de commandes de l'utilisateur) à la main.
Nous, on veut tout "déballer" pour bosser avec une simple liste de commandes. C'est là que SelectMany débarque à la rescousse.
Analogie : déballer des boîtes
Imagine que toutes tes affaires ne sont pas mélangées, mais rangées dans des caisses. Chaque caisse — c'est une collection, genre les achats d'un utilisateur. Si tu veux voir TOUS les objets d'un coup (genre pour un inventaire global), tu ne vas pas fouiller chaque caisse puis chaque objet, encore et encore. C'est bien plus simple de tout verser dans un gros tas — et de trier ensuite. Voilà comment marche SelectMany.
2. C'est quoi SelectMany ?
SelectMany — c'est une méthode LINQ qui prend une collection de collections et la transforme en une seule collection "plate". Par "plate", on veut dire que la séquence résultante n'a plus de listes internes — tous les éléments des collections imbriquées sont au même niveau, comme si on les avait "sortis". Pas de poupées russes, juste une longue chaîne de valeurs.
La signature de la méthode ressemble à ça :
IEnumerable<TResult> SelectMany<TSource, TResult>(
this IEnumerable<TSource> source,
Func<TSource, IEnumerable<TResult>> selector
)
C'est simple : t'as une collection (genre une liste d'utilisateurs), et chaque élément contient une autre collection (genre la liste des commandes de cet utilisateur). SelectMany prend chaque utilisateur, chope ses commandes et les fusionne dans un seul flux de commandes — sans "emballage", sans imbrication. C'est super pratique quand tu veux passer d'une "liste de listes" à une liste normale.
3. Exemples simples
Exemple 1 : Liste d'utilisateurs et leurs commandes
On part de notre modèle d'appli, qu'on fait évoluer petit à petit :
// Imaginons que ces classes existent déjà depuis les cours précédents
class User
{
public string Name { get; set; }
public List<Order> Orders { get; set; }
}
class Order
{
public int Id { get; set; }
public string ProductName { get; set; }
}
Disons qu'on a une liste d'utilisateurs :
var users = new List<User>
{
new User
{
Name = "Ivan",
Orders = new List<Order>
{
new Order { Id = 1, ProductName = "Livre" },
new Order { Id = 2, ProductName = "Stylo" }
}
},
new User
{
Name = "Maria",
Orders = new List<Order>
{
new Order { Id = 3, ProductName = "Ordinateur portable" }
}
}
};
Objectif : obtenir la liste de tous les produits achetés par tous les utilisateurs.
Un Select classique :
var ordersPerUser = users.Select(user => user.Orders);
// IEnumerable<List<Order>>
Ici, on a à la sortie plein de "boîtes", chacune avec la liste des commandes d'un utilisateur.
SelectMany :
var allOrders = users.SelectMany(user => user.Orders);
// IEnumerable<Order>
Là, on obtient une seule "longue" collection de toutes les commandes !
Visualisation
| Utilisateur | Commandes |
|---|---|
| Ivan | Livre, Stylo |
| Maria | Ordinateur portable |
- Après Select : [[Livre, Stylo], [Ordinateur portable]] — liste de listes
- Après SelectMany : [Livre, Stylo, Ordinateur portable] — liste unique
Exemple 2 : Travailler avec plusieurs niveaux d'imbrication
Si, par exemple, une commande a une liste de produits (panier), alors tu peux utiliser SelectMany plusieurs fois — comme une poupée russe !
class Product
{
public string Name { get; set; }
}
class Order
{
public int Id { get; set; }
public List<Product> Products { get; set; }
}
class User
{
public string Name { get; set; }
public List<Order> Orders { get; set; }
}
var users = new List<User>
{
new User
{
Name = "Petr",
Orders = new List<Order>
{
new Order
{
Id = 10,
Products = new List<Product>
{
new Product { Name = "Téléphone" },
new Product { Name = "Chargeur" }
}
}
}
}
};
Pour obtenir tous les produits de toutes les commandes de tous les utilisateurs, on utilise un double SelectMany :
var allProducts = users
.SelectMany(u => u.Orders)
.SelectMany(o => o.Products);
// IEnumerable<Product>
Comme ça, tu ouvres d'abord un niveau de "boîtes", puis le suivant.
Exemple 3 : Utiliser SelectMany en Query Syntax
Si tu préfères la syntaxe LINQ façon SQL (Query Syntax), alors SelectMany s'exprime avec plusieurs from à la suite :
var allProducts =
from user in users
from order in user.Orders
from product in order.Products
select product;
Ici, chaque from prend un élément de la collection retournée par le précédent.
users
└─ user1
└─ order1
└─ product1, product2
└─ order2
└─ product3
└─ user2
└─ order3
└─ product4
Query Syntax parcourt tous les chemins et retourne une seule longue liste de produits.
4. Variantes d'utilisation et subtilités
SelectMany pour transformer et filtrer
Avec SelectMany, tu peux non seulement "déballer", mais aussi filtrer ou projeter les éléments en même temps. Par exemple, sélectionner seulement les produits à plus de 1000 euros dans toutes les commandes :
var expensiveProducts = users
.SelectMany(u => u.Orders)
.SelectMany(o => o.Products)
.Where(p => p.Price > 1000);
Ou — en mettant un peu de logique directement dans SelectMany (avec un sélecteur supplémentaire) :
var expensiveProducts = users
.SelectMany(u => u.Orders.SelectMany(o => o.Products))
.Where(p => p.Price > 1000);
C'est une question de style : les deux façons découpent le problème en étapes successives.
Utiliser la surcharge de SelectMany avec projection
Une "avancée" de la méthode permet non seulement de déballer, mais aussi de former le résultat direct. Par exemple : obtenir des paires "Nom utilisateur — Nom produit" :
var userProductPairs = users.SelectMany(
user => user.Orders.SelectMany(order => order.Products),
(user, product) => new { user.Name, product.Name }
);
Comment ça marche ? Le premier paramètre — user => user.Orders.SelectMany(order => order.Products) — déballe tous les produits de l'utilisateur, le second combine l'objet utilisateur d'origine et le produit à l'intérieur de l'énumérateur imbriqué.
5. Points importants et erreurs fréquentes
Tu peux tomber sur une situation où t'as oublié de mettre SelectMany et au lieu d'une séquence plate, t'as un tableau de "boîtes". Par exemple, si tu utilises un Select classique au lieu de SelectMany là où il faut tout déballer. Résultat : tu ne peux pas parcourir ou traiter les éléments directement.
C'est super facile de s'embrouiller quand les collections sont imbriquées, surtout avec plusieurs niveaux. Prends l'habitude : si tu veux une liste plate et pas une liste de listes, utilise direct SelectMany.
Où ça sert en vrai ?
Dans n'importe quelle tâche où t'as un objet-collection, et chaque élément a sa propre collection (genre "utilisateur — commandes", "cours — étudiants", "news — commentaires"), tu vas revenir à SelectMany. En entretien, c'est un des sujets "préférés" : pas tous les débutants font la différence entre Select et SelectMany et savent bien déballer les collections.
Dans les vrais projets, ça permet d'écrire du code propre, concis et rapide sans niveau d'imbrication en trop. Sur la plateforme .NET, c'est la voie standard et optimisée pour gérer des collections "en couches".
Différence entre Select et SelectMany
La méthode Select garde la structure : si tu l'appliques à une collection d'utilisateurs, chacun ayant une liste de commandes, tu obtiens une collection de collections — genre [[A, B], [C]]. Pratique si tu veux bosser par groupes (par utilisateur, par exemple).
Mais SelectMany "aplatit" tout — il fusionne toutes les collections imbriquées en une seule séquence : [A, B, C]. Utile quand la répartition ne t'intéresse pas, et tu veux bosser avec tous les éléments internes comme une seule masse — genre trouver tous les produits, peu importe à quel utilisateur ou commande ils appartiennent.
+---------------------+ +--------------------+
| users | | allOrders |
+---------------------+ +--------------------+
| Ivan: [A, B] | --+ +-> Order A |
| Maria: [C] | --+ | +-> Order B |
+---------------------+ | | +-> Order C |
| | +--------------------+
Select: | |
[[A, B], [C]] <--------+ +
|
SelectMany: <--------+
[A, B, C]
En gros :
- Select → « donne-moi les listes de commandes par utilisateur » ;
- SelectMany → « donne-moi juste toutes les commandes ».
GO TO FULL VERSION