Entity Framework Core : bonnes pratiques pour écrire des requêtes performantes et éviter les pièges courants
Cet article fait partie de la série Entity Framework : 4 sur 12.
- Part 1 - Comprendre la "magie" derrière Entity Framework (EF Core)
- Part 2 - Le Database Context (EF Core)
- Part 3 - Le Change Tracker (EF Core)
- Part 4 - Cet article
- Part 5 - Manipuler le Change Tracker (EF Core)
- Part 6 - Optimiser les performances (EF Core)
- Part 7 - Mesurer et diagnostiquer les performances (EF Core)
- Part 8 - AsSplitQuery — maîtriser le chargement de plusieurs relations (EF Core)
- Part 9 - Migrations en équipe et en CI (EF Core)
- Part 10 - Concurrence optimiste (EF Core)
- Part 11 - Les intercepteurs (EF Core)
- Part 12 - Tester son code d'accès aux données (EF Core)
Bonnes pratiques à appliquer
Une requête LINQ n’est qu’une description : c’est le SQL généré qui s’exécute réellement. Pour chaque pratique, on regarde donc le SQL produit par EF Core 10 sur SQL Server. Pour l’afficher soi-même, deux options :
// 1. Sans exécuter la requête
var sql = db.Clients.Where(c => c.IsActive).ToQueryString();
// 2. En journalisant toutes les commandes envoyées à la base
optionsBuilder
.UseSqlServer(connectionString)
.LogTo(Console.WriteLine, LogLevel.Information);
1. Privilégier les requêtes côté serveur
- Utiliser des méthodes LINQ qui se traduisent en SQL (
Where,Select,OrderBy, etc.). - Éviter d’appeler des méthodes .NET non traduites en SQL avant d’avoir récupéré les données (par exemple :
.ToList(),.AsEnumerable()).
// ❌ Toute la table est chargée, le filtre s'applique en mémoire
var actifs = db.Clients.AsEnumerable().Where(c => c.IsActive).ToList();
// ✅ Le filtre est traduit en SQL
var actifs = db.Clients.Where(c => c.IsActive).ToList();
-- ❌ Version AsEnumerable : aucune clause WHERE
SELECT [c].[Id], [c].[Name], [c].[Email], [c].[IsActive]
FROM [Clients] AS [c]
-- ✅ Version IQueryable
SELECT [c].[Id], [c].[Name], [c].[Email], [c].[IsActive]
FROM [Clients] AS [c]
WHERE [c].[IsActive] = CAST(1 AS bit)
Depuis EF Core 3, une méthode non traduisible dans un
Wherelève uneInvalidOperationException(« could not be translated ») au lieu d’être évaluée silencieusement côté client. Seul leSelectfinal peut contenir du code .NET non traduisible.
2. Appliquer le filtrage le plus tôt possible
- Placer les
.Where()avant les.Select()ou.OrderBy()afin de limiter le volume de données transférées.
Sur un IQueryable, EF Core regroupe les opérateurs en une seule requête : l’ordre Where/OrderBy change peu le SQL. La règle est surtout cruciale avant toute matérialisation (ToList, AsEnumerable, foreach) : tout ce qui est après s’exécute en mémoire.
3. Projections avec Select
- Utiliser
.Select()pour ne récupérer que les colonnes nécessaires (DTO, ViewModel). - Exemple :
var clients = db.Clients
.Where(c => c.IsActive)
.Select(c => new ClientDto { Id = c.Id, Name = c.Name })
.ToList();
SELECT [c].[Id], [c].[Name]
FROM [Clients] AS [c]
WHERE [c].[IsActive] = CAST(1 AS bit)
Seules deux colonnes transitent sur le réseau, et les entités projetées ne sont pas suivies par le Change Tracker.
4. Pagination
- Utiliser
.Skip()et.Take()pour effectuer la pagination côté SQL.
var page = db.Products
.OrderBy(p => p.Name)
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToList();
SELECT [p].[Id], [p].[Name], [p].[Price]
FROM [Products] AS [p]
ORDER BY [p].[Name]
OFFSET @p ROWS FETCH NEXT @pageSize ROWS ONLY
Pièges :
- ❌ Paginer sans
OrderBy: l’ordre des lignes n’est pas garanti, une même ligne peut apparaître sur deux pages (EF Core émet un avertissement). - ❌ Trier sur une colonne non unique (
Name) : ajouter une clé de départage,.OrderBy(p => p.Name).ThenBy(p => p.Id). - Sur de très grandes tables,
OFFSETdevient coûteux sur les pages lointaines : la pagination par clé (Where(p => p.Id > lastId).Take(pageSize)) est alors préférable.
5. Chargement des relations
- Privilégier l’utilisation de
.Include()pour charger explicitement les relations nécessaires.
var orders = db.Orders.Include(o => o.Customer).ToList();
SELECT [o].[Id], [o].[CustomerId], [o].[OrderDate], [c].[Id], [c].[Name]
FROM [Orders] AS [o]
INNER JOIN [Customers] AS [c] ON [o].[CustomerId] = [c].[Id]
La relation étant obligatoire (CustomerId non nullable), EF Core génère un INNER JOIN ; pour une relation optionnelle, ce serait un LEFT JOIN.
- Éviter le chargement paresseux (lazy loading) lorsque l’on souhaite garder un contrôle précis sur les requêtes exécutées.
6. Éviter les requêtes N+1
Le problème N+1 survient lorsqu’une requête est exécutée pour une entité principale, puis une requête supplémentaire pour chaque entité liée.
- Utiliser
.Include()ou des projections pour éviter de charger les entités liées une par une.
Exemple du problème N+1
Supposons que l’on souhaite récupérer une liste de commandes et, pour chaque commande, ses lignes :
// Provoque N+1 requêtes SQL !
var commandes = db.CdeClients.ToList();
foreach (var commande in commandes)
{
var lignes = db.LigCdeClients.Where(l => l.CdeClientId == commande.Id).ToList();
// ...
}
- Ici, 1 requête pour les commandes, puis 1 requête par commande pour les lignes.
SELECT [c].[Id], [c].[Date] FROM [CdeClients] AS [c]
-- puis, répété N fois avec une valeur différente :
SELECT [l].[Id], [l].[CdeClientId], [l].[Quantite]
FROM [LigCdeClients] AS [l]
WHERE [l].[CdeClientId] = @Id
Bonne pratique : charger les relations en une seule requête
Utiliser .Include() pour charger les entités liées en une seule requête SQL :
var commandes = db.CdeClients
.Include(c => c.Lignes) // navigation property
.ToList();
- Résultat : 1 seule requête SQL qui ramène les commandes et leurs lignes.
SELECT [c].[Id], [c].[Date], [l].[Id], [l].[CdeClientId], [l].[Quantite]
FROM [CdeClients] AS [c]
LEFT JOIN [LigCdeClients] AS [l] ON [c].[Id] = [l].[CdeClientId]
ORDER BY [c].[Id]
Attention : les colonnes de la commande sont répétées pour chaque ligne. Avec plusieurs
Includede collections, le volume explose (« explosion cartésienne ») ;AsSplitQuery()permet alors de découper en plusieurs requêtes.
Alternative avec projection
Pour un DTO, il est possible de projeter les données de la manière suivante :
var commandes = db.CdeClients.Select(c => new CommandeDto
{
Id = c.Id,
Lignes = c.LigCdeClients.Select(l => new LigneDto { Id = l.Id, ... }).ToList()
})
.ToList();
Dans ce cas, Entity Framework générera une seule requête SQL avec jointure.
SELECT [c].[Id], [l].[Id], [l].[Quantite]
FROM [CdeClients] AS [c]
LEFT JOIN [LigCdeClients] AS [l] ON [c].[Id] = [l].[CdeClientId]
ORDER BY [c].[Id]
7. Utiliser Any() et Count() de manière appropriée
- Préférer
Any()pour vérifier l’existence, généralement plus performant queCount() > 0.
bool hasOrders = db.Orders.Any(o => o.CustomerId == id);
-- ✅ Any() : EXISTS s'arrête dès la première ligne trouvée
SELECT CASE
WHEN EXISTS (
SELECT 1
FROM [Orders] AS [o]
WHERE [o].[CustomerId] = @id) THEN CAST(1 AS bit)
ELSE CAST(0 AS bit)
END
-- ❌ Count() > 0 : toutes les lignes correspondantes sont comptées
SELECT COUNT(*)
FROM [Orders] AS [o]
WHERE [o].[CustomerId] = @id
Il convient toutefois de rester attentif aux utilisations de Any() et Count() susceptibles de générer des sous-requêtes (et donc des requêtes de type N+1).
db.Customers.Where(c => c.Orders.Any(o => o.IsPaid));
SELECT [c].[Id], [c].[Name]
FROM [Customers] AS [c]
WHERE EXISTS (
SELECT 1
FROM [Orders] AS [o]
WHERE [c].[Id] = [o].[CustomerId] AND [o].[IsPaid] = CAST(1 AS bit))
Ici, EF Core produit une seule requête avec une sous-requête corrélée : c’est la base qui l’évalue pour chaque client. Avec un index sur Orders.CustomerId, c’est généralement efficace ; sans index, le coût grimpe vite.
Dans certains cas, une requête explicite avec jointure, par exemple en sélectionnant le client et en filtrant sur les commandes payées, sera plus efficace qu’une sous-requête répétée.
Le vrai N+1 apparaît quand le Any()/Count() est appelé en mémoire, dans une boucle, sur une navigation chargée en lazy loading :
// ❌ Une requête par client si Orders est en lazy loading
foreach (var c in db.Customers.ToList())
if (c.Orders.Count > 0) { /* ... */ }
8. Utiliser AsNoTracking() pour la lecture
- Pour les requêtes en lecture seule, ajouter
.AsNoTracking()permet d’améliorer les performances.
var products = db.Products.AsNoTracking().ToList();
Le SQL est identique avec ou sans AsNoTracking() : le gain se situe côté .NET (pas de snapshot des valeurs, pas d’enregistrement dans le Change Tracker, moins d’allocations). Une projection Select vers un DTO n’est de toute façon pas suivie.
9. Éviter les requêtes complexes côté client
- Éviter les jointures ou les transformations complexes après l’appel à
.ToList(). Il est préférable de conserver le maximum de logique côté SQL.
10. Utiliser des expressions lambda claires
- Privilégier des expressions lisibles et nommer les variables de manière explicite.
11. Utiliser les méthodes asynchrones
Il est recommandé d’utiliser les méthodes asynchrones (async) avec Entity Framework pour plusieurs raisons :
- Performance et scalabilité : les méthodes asynchrones (
ToListAsync,SaveChangesAsync, etc.) libèrent le thread pendant l’attente des opérations d’E/S (accès à la base), ce qui permet au serveur de traiter d’autres requêtes. - Réactivité : dans les applications web ou desktop, l’utilisation d’
asyncévite de bloquer l’interface utilisateur ou les threads du serveur. - Bonne pratique moderne : le modèle asynchrone est particulièrement adapté aux architectures cloud et microservices, où la gestion efficace des ressources est essentielle.
L’utilisation systématique des méthodes asynchrones avec Entity Framework contribue à améliorer les performances, la réactivité et la capacité à traiter un grand nombre de requêtes simultanément.
var clients = await db.Clients
.Where(c => c.IsActive)
.ToListAsync(cancellationToken);
Un
DbContextn’est pas thread-safe : ne jamais lancer deux requêtes en parallèle (Task.WhenAll) sur la même instance. Toujours faireawaitavant la requête suivante.
Pièges courants
Comparer des chaînes avec StringComparison
// ❌ Non traduisible : InvalidOperationException
db.Clients.Where(c => c.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
// ✅ La sensibilité à la casse dépend de la collation de la colonne (insensible par défaut sur SQL Server)
db.Clients.Where(c => c.Name == name);
Contains sur une liste
int[] ids = [1, 2, 3];
var produits = await db.Products.Where(p => ids.Contains(p.Id)).ToListAsync();
En EF Core 10, chaque valeur devient un paramètre (la liste est « paddée » pour limiter le nombre de variantes de requêtes) :
SELECT [p].[Id], [p].[Name], [p].[Price]
FROM [Products] AS [p]
WHERE [p].[Id] IN (@ids1, @ids2, @ids3)
Les versions 8 et 9 envoyaient un seul paramètre JSON décodé par OPENJSON ; le mode peut être choisi avec UseParameterizedCollectionMode(...). Pour des listes de plusieurs milliers d’éléments, mieux vaut passer par une table temporaire ou une jointure.
Réutiliser un IQueryable en croyant qu’il est déjà exécuté
var query = db.Orders.Where(o => o.IsPaid);
var total = await query.CountAsync(); // requête 1
var items = await query.ToListAsync(); // requête 2 : la requête est rejouée
Un IQueryable est une requête différée : chaque matérialisation repart en base.
Résumé
| Pratique | SQL généré | Gain |
|---|---|---|
| Filtrer avant matérialisation | WHERE côté serveur |
Moins de lignes transférées |
Projection Select |
SELECT des seules colonnes utiles |
Moins de colonnes, pas de tracking |
Skip/Take + OrderBy |
OFFSET ... FETCH NEXT |
Pagination déterministe en base |
Include |
INNER/LEFT JOIN |
Évite le N+1 (attention aux collections multiples) |
Any() plutôt que Count() > 0 |
EXISTS |
Arrêt à la première ligne |
AsNoTracking() |
Identique | Moins de mémoire et de CPU côté .NET |
Méthodes Async |
Identique | Threads libérés pendant l’E/S |
ToQueryString() / LogTo |
— | Vérifier ce qui part réellement en base |