Maîtriser Entity Framework : 50 questions & réponses clés pour les entretiens (2026)

Se préparer à un entretien Entity Framework signifie anticiper les questions qui révèlent la réelle capacité. Les questions d'entretien Entity Framework exposent la réflexion, la conscience de la performance et la façon dont les candidats traduisent les concepts en pratique.

Maîtriser Entity Framework ouvre des rôles dans le développement moderne, des plateformes axées sur les données aux services cloud. L'exposition pratique développe la capacité analytique, renforce la profondeur technique et soutient les équipes. Les responsables du recrutement valorisent la résolution de problèmes pratique, la conception évolutive, le mentorat des juniors et les parcours de croissance pour les nouveaux diplômés.

👉 Téléchargement gratuit PDF : Questions & Réponses d'entretien Entity Framework

1) Qu'est-ce qu'Entity Framework et pourquoi l'utilise-t-on ?

Entity Framework (EF) est le framework ORM (Object-Relational Mapping) de Microsoft pour .NET qui simplifie l'interaction avec la base de données en permettant aux développeurs de travailler avec les données comme des objets .NET fortement typés au lieu de SQL brut. Cette abstraction permet aux développeurs d'effectuer des opérations CRUD (Create, Read, Update, Delete) en utilisant des constructions C# familières, et le framework gère la traduction de ces opérations en requêtes SQL optimisées en arrière-plan. EF réduit le code boilerplate d'accès aux données, améliore la maintenabilité et aide à appliquer la sécurité de type à la compilation.

Par exemple, au lieu d'écrire du SQL, vous pouvez utiliser :

var customers = context.Customers.Where(c => c.IsActive).ToList();

EF traduira cette requête LINQ en SQL, l'exécutera contre la base de données et renverra les résultats sous forme d'objets.

2) Expliquer la différence entre les approches Code First, Database First et Model First.

Entity Framework prend en charge trois principales approches de développement :

Approche	Quand l'utiliser	Ce qui se passe
Code First	Nouveaux projets ou conception pilotée par le domaine	Vous définissez les classes d'entité. EF génère le schéma de base de données depuis le code.
Database First	Base de données existante	EF génère les classes d'entité et le contexte depuis un schéma existant.
Model First	Quand vous préférez la conception visuelle	Vous concevez le modèle dans un concepteur visuel (Entity Designer), et EF génère à la fois les classes et la base de données.

Chaque approche sert des scénarios différents : Code First est populaire dans le développement agile, Database First est préféré avec les bases de données legacy, et Model First convient aux cas où la modélisation visuelle est importante.

3) Qu'est-ce que DbContext et quel rôle joue-t-il dans EF ?

DbContext est la classe principale qui gère la session avec la base de données, suit les modifications d'entité et coordonne la sauvegarde des données vers la base de données. Il représente un pont entre votre application C# et la base de données. Via DbContext, vous définissez des propriétés DbSet<TEntity>, qui représentent des collections d'entités et correspondent à des tables dans la base de données.

Exemple :

public class AppDbContext : DbContext {
    public DbSet<Product> Products { get; set; }
}

Ici, Products agit comme une collection pour effectuer des opérations CRUD. EF utilise ce contexte pour suivre les états d'objets et générer des commandes SQL sur SaveChanges().

4) Que sont les migrations dans Entity Framework et comment sont-elles utilisées ?

Les migrations sont un mécanisme pour suivre et appliquer les changements de schéma à la base de données au fil du temps. À mesure que votre modèle évolue, les migrations aident à maintenir la base de données synchronisée sans modifier manuellement les scripts SQL. Avec Code First, vous utilisez des commandes comme :

Add-Migration InitialCreate
Update-Database

Cela génère des classes de migration qui définissent les changements de schéma et les applique à la base de données. Les migrations permettent le contrôle de version pour le schéma de base de données et facilitent le développement collaboratif.

5) Décrire le Lazy Loading, Eager Loading et Explicit Loading.

Charger les données liées efficacement est critique dans EF. Voici une comparaison :

Stratégie	Quand elle s'exécute	Usage typique
Lazy Loading	Données liées chargées au premier accès	Utiliser quand les données liées ne sont pas toujours nécessaires.
Eager Loading	Données liées chargées d'emblée via `.Include()`	Utiliser quand vous savez que vous avez besoin des données liées.
Explicit Loading	Chargées manuellement après la requête	Donne le contrôle sur le moment exact où les données liées sont chargées.

Par exemple :

var orders = context.Orders.Include(o => o.Customer).ToList(); // Eager

Le lazy loading aide à réduire les requêtes initiales, mais peut causer des problèmes de requêtes N+1 s'il n'est pas utilisé avec précaution.

6) Qu'est-ce que le change tracking dans Entity Framework ?

Le change tracking est le mécanisme interne d'EF pour surveiller les changements d'état d'entité après l'exécution d'une requête. Quand une entité est récupérée par DbContext, elle est suivie. Toute modification de ses propriétés est notée, et quand SaveChanges() est appelé, EF génère les instructions SQL INSERT, UPDATE ou DELETE appropriées. Pour les scénarios en lecture seule où le suivi est inutile, AsNoTracking() améliore les performances en désactivant le change tracking.

7) Comment Entity Framework gère-t-il les conflits de concurrence ?

Le contrôle de concurrence garantit que plusieurs utilisateurs mettant à jour les mêmes données n'écrasent pas involontairement les modifications des autres. EF utilise la concurrence optimiste par défaut. Une approche courante consiste à ajouter un jeton de concurrence (comme un RowVersion timestamp). EF vérifie ce jeton pendant SaveChanges(), et s'il diffère de la version en base, une DbUpdateConcurrencyException est levée, indiquant un conflit. Les développeurs peuvent alors gérer cette exception pour réessayer ou résoudre les différences de données.

8) Que sont les propriétés de navigation dans EF ?

Les propriétés de navigation définissent les relations entre entités. Elles permettent à EF de naviguer dans les associations (ex: one-to-many) sans jointures manuelles :

public class Order {
    public int Id { get; set; }
    public Customer Customer { get; set; }
}

Ici, Customer est une propriété de navigation liant Order à son Customer associé. EF utilise ces propriétés pour construire les relations et jointures automatiquement pendant les requêtes. Les propriétés de navigation fonctionnent avec les clés étrangères pour modéliser les relations.

9) Quel est le but de AsNoTracking() ?

AsNoTracking() désactive le suivi des changements pour une requête, ce qui est bénéfique pour les opérations en lecture seule où vous n'avez pas l'intention de mettre à jour les entités récupérées. Cela améliore les performances en réduisant l'utilisation mémoire et la surcharge de suivi. C'est particulièrement utile lors de la récupération de grands ensembles de données sans les modifier.

10) Que sont les requêtes compilées et quand les utiliser ?

Les requêtes compilées sont une technique d'optimisation des performances. Quand une requête LINQ est exécutée, EF la traduit généralement en SQL à chaque fois. Avec les requêtes compilées, cette traduction est faite une fois, et le délégué résultant est réutilisé — réduisant la surcharge pour les requêtes fréquemment exécutées ou complexes. Utilisez-les dans les scénarios à fort trafic où la même requête s'exécute répétitivement avec différents paramètres.

11) Quels sont les états d'entité dans Entity Framework et comment affectent-ils SaveChanges() ?

Entity Framework suit l'état de chaque entité pour déterminer quelle opération de base de données effectuer pendant SaveChanges(). Les principaux états d'entité sont :

État	Description	Opération déclenchée
Added	Nouvelle entité à insérer	`INSERT`
Modified	Entité existante mise à jour	`UPDATE`
Deleted	Entité marquée pour suppression	`DELETE`
Unchanged	Aucun changement détecté	Aucune
Detached	Non suivie par le contexte	Aucune

Quand vous appelez SaveChanges(), EF inspecte les états d'entité et exécute les commandes SQL correspondantes. Par exemple, une nouvelle entité ajoutée à un DbSet sera marquée Added, résultant en une requête INSERT.

Exemple :

context.Entry(product).State = EntityState.Modified;
context.SaveChanges();

Cela met explicitement à jour l'enregistrement en base pour l'entité.

Comprendre les états assure un meilleur contrôle sur la synchronisation des données et les performances.

12) Quels sont les avantages et inconvénients d'Entity Framework ?

Entity Framework offre de forts avantages mais aussi des compromis, selon votre cas d'usage.

Avantages	Inconvénients
Simplifie l'accès aux données via LINQ et modèles objets.	Surcharge de performance comparé à ADO.NET brut.
Réduit le code SQL boilerplate.	Requêtes complexes peuvent générer du SQL inefficace.
Supporte plusieurs fournisseurs de base de données.	Plus difficile de déboguer le SQL généré.
Fortement typé, améliorant la sécurité à la compilation.	Conflits de migration possibles dans les grandes équipes.
Permet le prototypage rapide avec Code First.	Moins de contrôle sur les requêtes finement ajustées.

Pour les systèmes à grande échelle nécessitant une performance maximale, les développeurs peuvent encore mélanger SQL brut avec EF pour l'optimisation.

13) Comment Entity Framework gère-t-il les relations (un-à-un, un-à-plusieurs, plusieurs-à-plusieurs) ?

Entity Framework gère les relations via les propriétés de navigation et les associations de clés étrangères.

Les types de relations sont :

Type de relation	Description	Exemple
Un-à-Un	Chaque instance d'entité a une entité liée.	`User` ↔ `UserProfile`
Un-à-Plusieurs	Une entité est liée à plusieurs autres.	`Customer` → `Orders`
Plusieurs-à-Plusieurs	Plusieurs entités sont liées entre elles.	`Student` ↔ `Course`

Exemple de relation Un-à-Plusieurs :

public class Customer {
    public int CustomerId { get; set; }
    public ICollection<Order> Orders { get; set; }
}

EF génère automatiquement les clés étrangères et gère les règles de suppression en cascade selon la configuration.

Vous pouvez aussi utiliser la Fluent API pour un mapping de relation plus explicite.

14) Quelle est la différence entre LINQ to Entities et LINQ to SQL ?

Fonctionnalité	LINQ to Entities	LINQ to SQL
Bases de données supportées	Multiple (SQL Server, Oracle, MySQL, etc.)	SQL Server uniquement
Framework sous-jacent	Entity Framework	ADO.NET
Modèle conceptuel	Modèle d'entité conceptuel	Tables de base de données uniquement
Mapping	Mapping complexe (héritage, associations)	Mapping direct table
Support futur	Supporté activement	Obsolète

LINQ to Entities fait partie d'Entity Framework et est plus polyvalent, tandis que LINQ to SQL est limité à SQL Server et aux cas d'usage plus simples. Donc, LINQ to Entities est recommandé pour le développement d'entreprise.

15) Quelle est la différence entre ObjectContext et DbContext ?

Fonctionnalité	ObjectContext	DbContext
Framework	Versions EF antérieures	API simplifiée dans EF 4.1+
Complexité	Plus verbeux	Léger et facile
Performance	Légèrement plus rapide mais plus difficile à utiliser	Simplifiée avec surcharge minimale
Change Tracking	Configuration manuelle nécessaire	Suivi automatique
Usage préféré	Systèmes legacy	Projets EF / EF Core modernes

DbContext enveloppe ObjectContext en interne mais fournit une API plus propre et plus intuitive. La plupart des applications .NET actuelles devraient utiliser DbContext.

16) Expliquer le cycle de vie d'une entité dans Entity Framework.

Le cycle de vie d'une entité décrit ses transitions d'état de la création à la persistance :

Création – L'entité est instanciée en mémoire (état : Detached).
Attachement – Ajoutée au contexte via DbSet.Add() (état : Added).
Modification – Changements détectés automatiquement (état : Modified).
Persistance – SaveChanges() appelé → commandes SQL exécutées.
Suppression – Entité marquée Deleted et retirée de la base de données.

Comprendre ce cycle aide au débogage des problèmes de données et à l'optimisation de la gestion du contexte EF.

17) À quoi sert la Fluent API dans Entity Framework ?

La Fluent API fournit un moyen programmatique de configurer les relations de modèle, contraintes et mappings, souvent utilisée dans la méthode OnModelCreating() de votre DbContext.

Elle donne un contrôle granulaire sur les configurations que les annotations de données ne peuvent pas exprimer.

Exemple :

modelBuilder.Entity<Customer>()
    .HasMany(c => c.Orders)
    .WithOne(o => o.Customer)
    .HasForeignKey(o => o.CustomerId);

La Fluent API est particulièrement puissante pour configurer les clés composites, les relations plusieurs-à-plusieurs et les règles de cascade.

18) Que sont les annotations de données dans Entity Framework ?

Les annotations de données sont des attributs appliqués directement aux classes de modèle ou propriétés pour définir le comportement du schéma. Elles sont plus simples que la Fluent API mais moins flexibles.

Exemple :

public class Product {
    [Key]
    public int ProductId { get; set; }
    [Required]
    [StringLength(50)]
    public string Name { get; set; }
}

Les annotations définissent les clés, longueurs de chaîne, champs requis et relations. Pour les cas avancés, les développeurs combinent généralement annotations de données et Fluent API.

19) Quelle est la différence entre entités suivies et non suivies dans EF Core ?

Type	Description	Cas d'usage
Entités suivies	Surveillées par `DbContext` pour les changements. Comportement par défaut pour les mises à jour.	Opérations d'écriture
Entités non suivies	Non surveillées ; récupérées avec `.AsNoTracking()`.	Idéal pour les opérations en lecture seule.

Les entités suivies consomment plus de mémoire mais permettent à EF de détecter les changements automatiquement. Les entités non suivies améliorent la performance dans les scénarios lecture intensive, écriture faible.

20) Comment exécuter des requêtes SQL brutes dans Entity Framework ?

Entity Framework permet d'exécuter du SQL brut pour des requêtes personnalisées ou critiques en performance.

var result = context.Products
    .FromSqlRaw("SELECT * FROM Products WHERE Price > 100")
    .ToList();

Pour les commandes non-requête :

context.Database.ExecuteSqlRaw("DELETE FROM Products WHERE Discontinued = 1");

Utilisez cette fonctionnalité avec précaution pour éviter l'injection SQL et maintenir la flexibilité agnostique de base de données.

21) Quelle est la différence entre Entity Framework et Entity Framework Core ?

Entity Framework (EF) et Entity Framework Core (EF Core) diffèrent par l'architecture, les capacités et le support multi-plateforme.

Fonctionnalité	Entity Framework 6 (EF6)	Entity Framework Core
Plateforme	.NET Framework uniquement	Multi-plateforme (.NET 5/6/7)
Architecture	Basée sur ObjectContext	Légère et modulaire
Performance	Plus lente sur certaines requêtes	Génération de requêtes optimisée
Support LINQ	Mature mais limité	Traduction améliorée et async
Fournisseurs de BDD	SQL Server, Oracle	Multiple (MySQL, PostgreSQL, SQLite, etc.)
Fonctionnalités	Matures (ex: lazy loading)	Modernes (ex: shadow properties, filtres globaux)

EF Core est la version moderne, activement développée et le choix recommandé pour les nouveaux projets .NET grâce à sa flexibilité et sa performance.

22) Comment fonctionnent les transactions dans Entity Framework ?

Les transactions dans Entity Framework assurent l'intégrité des données quand plusieurs opérations doivent réussir ou échouer ensemble. Par défaut, EF enveloppe SaveChanges() dans une transaction. Pour un contrôle manuel :

using (var transaction = context.Database.BeginTransaction()) {
    try {
        context.Customers.Add(new Customer());
        context.SaveChanges();
        context.Orders.Add(new Order());
        context.SaveChanges();
        transaction.Commit();
    } catch {
        transaction.Rollback();
    }
}

Ceci assure l'atomicité — si une commande échoue, tous les changements sont annulés. EF s'intègre aussi avec System.Transactions pour le support des transactions distribuées.

23) Expliquer les stratégies d'héritage TPH, TPT et TPC dans Entity Framework.

Entity Framework prend en charge trois principales stratégies de mapping d'héritage pour modéliser les hiérarchies de classes.

Stratégie	Description	Exemple	Avantages	Inconvénients
TPH (Table Per Hierarchy)	Toutes les classes partagent une table ; une colonne discriminateur identifie le type.	Commun dans EF Core	Simple, requêtes rapides	Table peut devenir grande et sparse
TPT (Table Per Type)	Chaque sous-classe a sa propre table.	Chaque classe dérivée mappée séparément	Schéma normalisé	Jointures plus lentes sur grandes hiérarchies
TPC (Table Per Concrete Class)	Chaque classe a sa propre table avec colonnes dupliquées.	Chaque entité mappée séparément	Lectures haute performance	Redondance de données

La plupart des développeurs préfèrent TPH pour sa simplicité, sauf si la normalisation ou les besoins de performance dictent autrement.

24) Comment régler les performances dans Entity Framework ?

Pour optimiser les performances d'Entity Framework :

Utiliser AsNoTracking() pour les requêtes en lecture seule.
Charger avidement (Eager load) uniquement les entités liées nécessaires avec .Include().
Éviter les requêtes N+1 en utilisant des projections ou Select().
Utiliser les requêtes compilées pour les opérations fréquemment exécutées.
Regrouper les insertions/mises à jour multiples avec AddRange() et SaveChanges().
Désactiver AutoDetectChanges pour les opérations en masse : context.Configuration.AutoDetectChangesEnabled = false;
Utiliser la mise en cache et la pagination pour les grands ensembles de données.

Une implémentation EF bien réglée peut approcher la performance d'ADO.NET tout en conservant la productivité du développeur.

25) Qu'est-ce qu'une propriété shadow dans Entity Framework Core ?

Une propriété shadow existe dans le modèle EF mais pas dans la classe d'entité. Elle est maintenue par EF dans le change tracker et stockée en base de données.

Exemple :

modelBuilder.Entity<Order>()
    .Property<DateTime>("LastUpdated");

Cela permet à EF de stocker des métadonnées supplémentaires (ex: timestamps, infos d'audit) sans modifier la classe d'entité.

Vous pouvez accéder aux propriétés shadow via :

var value = context.Entry(order).Property("LastUpdated").CurrentValue;

Les propriétés shadow sont idéales pour les scénarios de journalisation ou d'audit.

26) Que sont les convertisseurs de valeurs dans EF Core ?

Les convertisseurs de valeurs dans EF Core permettent la transformation des valeurs de propriété lors de la lecture ou l'écriture en base de données.

Par exemple, pour stocker un enum comme une chaîne :

modelBuilder.Entity<Employee>()
    .Property(e => e.Status)
    .HasConversion(
        v => v.ToString(),
        v => (EmployeeStatus)Enum.Parse(typeof(EmployeeStatus), v));

Cela améliore la flexibilité pour les types de données personnalisés comme enum, bool ou DateTimeOffset. Les convertisseurs de valeurs sont aussi utilisés pour le chiffrement, la compression ou le masquage de données sensibles.

27) Que sont les filtres de requête globaux et comment fonctionnent-ils ?

Les filtres de requête globaux permettent d'appliquer automatiquement des conditions à toutes les requêtes pour une entité.

C'est particulièrement utile pour les suppressions douces (soft deletes) ou la multi-location (multi-tenancy).

Exemple :

modelBuilder.Entity<Employee>()
    .HasQueryFilter(e => !e.IsDeleted);

Toute requête exécutée contre Employee exclut automatiquement les enregistrements soft-deleted, sauf si explicitement outrepassé. Les filtres globaux améliorent la maintenabilité et la sécurité des données.

28) Comment tester du code Entity Framework avec des tests unitaires ?

Pour tester la logique EF sans toucher une vraie base de données, utilisez des bases de données en mémoire ou le mocking :

Option 1 : Fournisseur InMemory

var options = new DbContextOptionsBuilder<AppDbContext>()
    .UseInMemoryDatabase("TestDb")
    .Options;

Option 2 : Mock DbContext
Mock DbSet en utilisant des bibliothèques comme Moq pour des tests isolés.

Les tests unitaires doivent valider :

Correction des requêtes (via LINQ)
Cohérence des données après SaveChanges()
Logique du repository

Les tests avec EF Core InMemory assurent rapidité et évitent les dépendances à SQL Server.

29) Expliquer les patterns Repository et Unit of Work dans EF.

Ces deux patterns architecturaux aident à abstraire l'accès aux données et maintenir la cohérence transactionnelle.

Pattern	But	Exemple d'implémentation
Repository	Encapsule les opérations CRUD pour chaque entité.	Interface `IRepository<T>` avec `Add()`, `GetAll()`, etc.
Unit of Work	Coordonne plusieurs repositories dans une transaction.	`SaveChanges()` agit comme frontière de commit.

Exemple :

public class UnitOfWork : IUnitOfWork {
    private readonly AppDbContext _context;
    public void Commit() => _context.SaveChanges();
}

Ces patterns améliorent la testabilité, la réutilisabilité du code et la séparation des responsabilités dans les grandes applications d'entreprise.

30) Quelle est la différence entre eager loading et projection loading ?

Aspect	Eager Loading	Projection Loading
But	Charge les données liées d'emblée	Charge uniquement champs/propriétés spécifiques
Méthode	`.Include()`	`.Select()`
Exemple	`context.Orders.Include(o => o.Customer)`	`context.Orders.Select(o => new { o.Id, o.Customer.Name })`
Performance	Récupère objets complets	Récupère données minimales
Cas d'usage	Quand entités liées nécessaires pour traitement	Quand données légères spécifiques requises

Le projection loading est une optimisation de performance qui réduit la surcharge mémoire en sélectionnant seulement les colonnes nécessaires.

31) Que sont les intercepteurs dans Entity Framework Core ?

Les intercepteurs dans EF Core permettent aux développeurs d'intercepter et modifier les opérations de base de données comme l'exécution de requête, la création de commande et l'ouverture de connexion.

Ils agissent comme composants middleware entre EF et le fournisseur de base de données.

Exemple : Journaliser toutes les commandes SQL exécutées.

public class CommandInterceptor : DbCommandInterceptor {
    public override void ReaderExecuting(
        DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result) {
        Console.WriteLine($"Executing SQL: {command.CommandText}");
        base.ReaderExecuting(command, eventData, result);
    }
}

Vous l'enregistrez dans le DbContextOptionsBuilder :

optionsBuilder.AddInterceptors(new CommandInterceptor());

Avantages :

Journalisation améliorée
Sécurité (validation de requête)
Audit et suivi de performance

32) Comment EF Core gère-t-il les opérations asynchrones ?

Entity Framework Core prend entièrement en charge la programmation asynchrone via des méthodes comme SaveChangesAsync(), ToListAsync() et FirstOrDefaultAsync().

L'exécution asynchrone aide à améliorer l'évolutivité dans les applications web en libérant les threads en attendant les opérations de base de données I/O-bound.

Exemple :

var customers = await context.Customers
    .Where(c => c.IsActive)
    .ToListAsync();

Les opérations asynchrones sont particulièrement efficaces dans les API ASP.NET Core et microservices à haut débit, réduisant les appels bloquants et améliorant les temps de réponse.

33) Qu'est-ce que la résilience de connexion dans Entity Framework Core ?

La résilience de connexion aide votre application à récupérer automatiquement des défaillances transitoires de base de données, comme les interruptions réseau ou timeouts SQL.

Elle peut être configurée ainsi :

optionsBuilder.UseSqlServer(
    connectionString,
    options => options.EnableRetryOnFailure(5, TimeSpan.FromSeconds(10), null)
);

Ici, EF réessaiera les opérations échouées jusqu'à 5 fois avec des délais. C'est particulièrement utile dans les environnements cloud hébergés comme Azure SQL où les fautes transitoires sont courantes.

34> Que sont les types d'entité possédés (owned entity types) dans EF Core ?

Les entités possédées permettent de modéliser des objets valeur qui dépendent entièrement du cycle de vie d'une autre entité.

Elles partagent la même table que leur propriétaire et ne peuvent pas exister indépendamment.

Exemple :

public class Address {
    public string Street { get; set; }
    public string City { get; set; }
}
public class Customer {
    public int Id { get; set; }
    public Address Address { get; set; }
}

Configuration :

modelBuilder.Entity<Customer>().OwnsOne(c => c.Address);

Cas d'usage : Modéliser des concepts comme Adresse, Argent ou Mesure qui n'ont pas d'identité propre.

35) Comment implémenter les suppressions douces (soft deletes) dans Entity Framework Core ?

Les suppressions douces marquent les enregistrements comme supprimés au lieu de les supprimer physiquement.

Elles sont implémentées avec un drapeau booléen et des filtres de requête globaux.

modelBuilder.Entity<Employee>()
    .HasQueryFilter(e => !e.IsDeleted);

Dans l'opération de suppression :

employee.IsDeleted = true;
context.Update(employee);
context.SaveChanges();

Avantages : Préservation des données historiques, récupération plus facile.

Inconvénients : Tables plus grosses, logique de filtrage prudente requise.

36) Qu'est-ce qu'un modèle compilé (compiled model) dans EF Core et pourquoi l'utiliser ?

Dans EF Core 6+, les modèles compilés permettent la précompilation des métadonnées du modèle EF dans un assembly .NET, réduisant le temps de démarrage et la surcharge d'exécution.

Étapes :

Exécuter la commande : dotnet ef dbcontext optimize
EF génère un fichier de modèle précompilé que l'application charge plus vite à l'exécution.

Avantage : Réduit la latence d'initialisation de 30–40 %, surtout dans les grandes applications avec beaucoup d'entités.

Cas d'usage : Microservices haute performance et environnements serverless.

37) Comment implémenter la mise en cache dans Entity Framework ?

La mise en cache aide à réduire les requêtes de base de données répétitives. Il y a deux niveaux principaux :

Type	Description	Exemple
Cache de premier niveau	Intégré, par instance `DbContext`	Géré automatiquement
Cache de second niveau	Cache externe partagé entre contextes	Utiliser bibliothèques comme `EFCoreSecondLevelCacheInterceptor`

Exemple pour le cache de second niveau :

services.AddEFSecondLevelCache(options => {
    options.UseMemoryCacheProvider().DisableLogging(false);
});

Cela améliore significativement les performances dans les applications lourdes en lecture en évitant les accès redondants à la base de données.

38) Comment EF Core gère-t-il les jetons de concurrence et timestamps ?

Les jetons de concurrence empêchent les mises à jour conflictuelles dans les environnements multi-utilisateurs.

Vous pouvez marquer une propriété comme jeton de concurrence avec l'attribut [ConcurrencyCheck] ou [Timestamp].

Exemple :

public class Product {
    public int Id { get; set; }
    [Timestamp]
    public byte[] RowVersion { get; set; }
}

Lors d'une mise à jour, EF inclut cette colonne dans la clause WHERE. Si la valeur diffère, une DbUpdateConcurrencyException est levée — assurant le contrôle de concurrence optimiste.

39) Comment implémenter l'audit (suivi création, modification, suppression) dans EF Core ?

L'audit suit les métadonnées comme qui a créé, modifié ou supprimé les enregistrements.

Vous pouvez surcharger SaveChanges() :

public override int SaveChanges() {
    var entries = ChangeTracker.Entries()
        .Where(e => e.Entity is IAuditable && (e.State == EntityState.Added || e.State == EntityState.Modified));
    foreach (var entry in entries) {
        var auditable = (IAuditable)entry.Entity;
        auditable.LastModified = DateTime.UtcNow;
    }
    return base.SaveChanges();
}

Interface :

public interface IAuditable {
    DateTime Created { get; set; }
    DateTime LastModified { get; set; }
}

Cette méthode centralise la logique d'audit, assurant une gouvernance des données cohérente.

40) Quelles sont les meilleures pratiques pour utiliser Entity Framework dans les applications d'entreprise ?

Catégorie	Meilleure pratique	Bénéfice
Performance	Utiliser `AsNoTracking()` et projections pour requêtes lecture seule.	Réduit la surcharge.
Conception	Implémenter les patterns Repository et Unit of Work.	Améliore la maintenabilité.
Sécurité	Utiliser requêtes paramétrées pour éviter injection SQL.	Protection des données.
Évolutivité	Utiliser connection pooling et méthodes async.	Gère la charge élevée.
Migrations	Utiliser migrations automatisées avec contrôle de version.	Simplifie la gestion du schéma.
Configuration	Externaliser chaînes de connexion et secrets.	Meilleure isolation d'environnement.
Tests	Utiliser fournisseur InMemory pour tests unitaires.	Exécution tests plus rapide.
Journalisation	Activer la journalisation EF pour insights performance.	Débogage plus facile.

Ces pratiques assurent des applications robustes, évolutives et maintenables bâties sur Entity Framework.

41) Comment optimiser les requêtes LINQ pour une meilleure traduction SQL dans Entity Framework ?

Entity Framework convertit automatiquement les requêtes LINQ en SQL, mais des patterns inefficaces peuvent produire du SQL lent ou redondant. Optimiser LINQ assure que l'ORM génère des requêtes de base de données performantes.

Techniques d'optimisation :

Utiliser les projections :

Sélectionner seulement les colonnes requises au lieu d'entités entières.

var customers = context.Customers
    .Select(c => new { c.Id, c.Name })
    .ToList();

Éviter l'évaluation côté client :
Toujours assurer que le filtrage se passe en SQL, pas en mémoire. EF Core avertit quand l'évaluation est côté client.

Utiliser AsNoTracking() pour les données en lecture seule.

var orders = context.Orders.AsNoTracking().ToList();

Tirer parti des requêtes compilées pour les opérations LINQ répétées.

Éviter les appels .Include() inutiles — n'inclure les données liées que quand nécessaire.

Exemple :

Inefficace :

context.Customers.ToList().Where(c => c.IsActive);

Efficace :

context.Customers.Where(c => c.IsActive).ToList();

42) Quelles sont les différentes façons d'amorcer (seed) des données initiales dans EF Core ?

L'amorçage de données assure que la base de données a des données par défaut ou de référence à sa création.

Approche 1 : Utiliser ModelBuilder

modelBuilder.Entity<Role>().HasData(
    new Role { Id = 1, Name = "Admin" },
    new Role { Id = 2, Name = "User" }
);

Cela insère les données automatiquement pendant Update-Database.

Approche 2 : Méthode d'amorçage personnalisée

Exécuter du code manuellement au démarrage :

context.Database.Migrate();
if (!context.Users.Any()) {
    context.Users.Add(new User { Name = "Admin" });
    context.SaveChanges();
}

Approche 3 : Scripts SQL

Utiliser du SQL brut dans les migrations :

migrationBuilder.Sql("INSERT INTO Roles (Name) VALUES ('Admin')");

Recommandation : Utiliser HasData() pour les données de référence statiques et l'amorçage programmatique pour les données de démarrage dynamiques.

43) Comment EF Core gère-t-il les fournisseurs de base de données en interne ?

EF Core est agnostique au fournisseur, ce qui signifie qu'il peut cibler plusieurs moteurs de base de données via des packages de fournisseurs de base de données séparés.

Fournisseurs courants :

Fournisseur	Package NuGet	Base de données
SQL Server	`Microsoft.EntityFrameworkCore.SqlServer`	MSSQL
SQLite	`Microsoft.EntityFrameworkCore.Sqlite`	Mobile/Desktop
PostgreSQL	`Npgsql.EntityFrameworkCore.PostgreSQL`	PostgreSQL
MySQL	`Pomelo.EntityFrameworkCore.MySql`	MySQL
Cosmos DB	`Microsoft.EntityFrameworkCore.Cosmos`	NoSQL

En interne, EF Core utilise des couches d'abstraction pour :

Traduction de requête
Génération de commandes SQL
Mapping de types de données

Chaque fournisseur implémente ses propres classes héritant des abstractions de base d'EF Core (ex: RelationalDatabaseProvider, QuerySqlGenerator).

44) Qu'est-ce qu'une "requête scindée" (split query) et quand l'utiliser ?

Les requêtes scindées empêchent EF d'effectuer de grosses jointures complexes en exécutant plusieurs requêtes SQL au lieu d'une seule.

Exemple :

var customers = context.Customers
    .Include(c => c.Orders)
    .AsSplitQuery()
    .ToList();

Cela exécute :

Requête 1 → Récupérer les Clients
Requête 2 → Récupérer les Commandes liées à ces clients

Avantages :

Empêche les gros produits cartésiens.
Améliore la performance avec de grands ensembles de données liées.

Inconvénient : Allers-retours multiples vers la base de données.

Utilisez les requêtes scindées quand le chargement avide de grandes données liées peut causer des problèmes de mémoire.

45) Comment surveiller efficacement les commandes SQL générées par EF ?

Surveiller le SQL aide à déboguer les requêtes lentes et optimiser le comportement de l'ORM.

Méthodes pour journaliser le SQL :

Journalisation console

optionsBuilder
    .UseSqlServer(conn)
    .LogTo(Console.WriteLine, LogLevel.Information);

Intégration ILoggerFactory

var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
optionsBuilder.UseLoggerFactory(loggerFactory);

Intercepteurs Implémenter DbCommandInterceptor pour capturer commandes et timings.

Outils de profilage Utiliser des outils comme :

MiniProfiler
SQL Server Profiler
EFCorePowerTools

La journalisation doit être activée sélectivement en production pour éviter la surcharge de performance.

46) Quelle est la différence entre ChangeTracker.DetectChanges() et AutoDetectChangesEnabled ?

Fonctionnalité	`DetectChanges()`	`AutoDetectChangesEnabled`
Type	Méthode	Propriété
But	Force EF à scanner les entités suivies et détecter les changements	Active/désactive la détection automatique des changements
Par défaut	Manuel	True
Usage	Appeler explicitement pour optimisation performance	Désactiver pour mises à jour en masse

Exemple :

context.ChangeTracker.AutoDetectChangesEnabled = false;
foreach (var item in list) {
    context.Add(item);
}
context.SaveChanges();

Désactiver la détection automatique dans les boucles améliore la performance jusqu'à 40 % dans les opérations en masse.

47) Comment utiliser les tables temporelles (temporal tables) avec EF Core ?

Les tables temporelles (introduites dans SQL Server 2016) permettent de suivre l'historique des données automatiquement.

Étapes :

Activer le support temporel dans la migration :

builder.Entity<Employee>()
    .ToTable("Employees", b => b.IsTemporal());

Interroger les données historiques :

var history = context.Employees
    .TemporalAsOf(DateTime.UtcNow.AddDays(-7))
    .ToList();

Avantages :

Suivi d'historique de données intégré
Audit et conformité
Aucun trigger manuel requis

EF Core 6+ supporte l'interrogation temporelle complète.

48) Comment EF Core supporte-t-il les requêtes compilées et modèles pré-générés ensemble ?

Les requêtes compilées et modèles compilés sont deux fonctionnalités de performance qui se complètent.

Fonctionnalité	But
Requêtes compilées	Mettre en cache les résultats de traduction de requête
Modèles compilés	Précompiler les métadonnées du modèle

Exemple de requête compilée :

static readonly Func<AppDbContext, int, Customer> _getCustomerById = EF.CompileQuery((AppDbContext ctx, int id) => ctx.Customers.FirstOrDefault(c => c.Id == id));

Utilisation :

var customer = _getCustomerById(context, 5);

Ensemble : Les modèles compilés réduisent le coût de démarrage, tandis que les requêtes compilées réduisent la surcharge de requête à l'exécution — idéal pour les requêtes à haute fréquence.

49) Quels sont les pièges courants lors de l'utilisation d'EF dans une architecture microservices ?

Erreurs courantes :

DbContext partagé entre services
→ Viole l'isolation des microservices.
→ Chaque microservice doit avoir son propre DbContext et schéma.
Communication bavarde (Requêtes N+1)
→ Minimiser les requêtes EF par appel API.
Chargement avide excessif
→ Charger seulement ce qui est requis via DTOs.
Migrations centralisées
→ Chaque service doit gérer ses propres migrations indépendamment.
Absence de frontières transactionnelles
→ Utiliser transactions distribuées (pattern Outbox) si cohérence inter-services requise.
Couplage fort au fournisseur SQL
→ Utiliser l'abstraction repository pour garder la flexibilité du choix de base de données.

50) Comment l'injection de dépendances s'intègre-t-elle avec DbContext dans ASP.NET Core ?

Entity Framework s'intègre parfaitement avec le système d'injection de dépendances (DI) intégré d'ASP.NET Core.

Configuration :

services.AddDbContext<AppDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("Default")));

Puis l'injecter dans les contrôleurs ou services :

public class CustomerService {
    private readonly AppDbContext _context;
    public CustomerService(AppDbContext context) {
        _context = context;
    }
}

Durées de vie :

Durée de vie	Description	Recommandé pour
Scoped	Un contexte par requête HTTP	Défaut
Transient	Nouvelle instance à chaque fois	Jobs d'arrière-plan
Singleton	Partagé globalement	À éviter (non thread-safe)

L'utilisation de DI assure la testabilité, la gestion du cycle de vie et l'efficacité des ressources à travers les processus web et d'arrière-plan.

🔍 Top questions d'entretien Entity Framework avec scénarios réels & réponses stratégiques

1) Qu'est-ce qu'Entity Framework, et pourquoi l'utilise-t-on dans les applications d'entreprise ?

Attendu du candidat : L'intervieweur veut évaluer votre compréhension fondamentale d'Entity Framework et sa valeur dans les applications réelles.

Exemple de réponse : Entity Framework est un framework Object-Relational Mapping pour .NET qui permet aux développeurs de travailler avec les bases de données en utilisant des objets .NET au lieu de SQL brut. Il est utilisé dans les applications d'entreprise pour améliorer la productivité, réduire le code boilerplate d'accès aux données et maintenir une forte séparation des responsabilités.

2) Pouvez-vous expliquer la différence entre les approches Code First, Database First et Model First ?

Attendu du candidat : L'intervieweur veut évaluer votre connaissance des différents flux de travail de développement et quand utiliser chacun.

Exemple de réponse : Code First commence avec les classes de domaine et génère la base de données depuis le code. Database First commence avec une base de données existante et génère les classes d'entité. Model First utilise un concepteur visuel pour définir le modèle et crée ensuite à la fois le code et la base de données. Chaque approche est choisie selon les exigences du projet et l'infrastructure existante.

3) Comment Entity Framework gère-t-il les relations entre tables ?

Attendu du candidat : L'intervieweur vérifie votre compréhension de la modélisation de données et du mapping relationnel.

Exemple de réponse : Entity Framework gère les relations en utilisant les propriétés de navigation et les clés étrangères. Il supporte les relations un-à-un, un-à-plusieurs et plusieurs-à-plusieurs, permettant aux développeurs de parcourir les données liées en utilisant des références d'objets plutôt que des jointures.

4) Décrivez une situation où vous avez amélioré les performances de base de données en utilisant Entity Framework.

Attendu du candidat : L'intervieweur veut un exemple pratique démontrant vos compétences d'optimisation.

Exemple de réponse : Dans mon rôle précédent, j'ai amélioré les performances en réduisant le chargement avide inutile et en implémentant des requêtes de projection avec des instructions Select. Cela a minimisé la quantité de données récupérées de la base de données et réduit significativement le temps d'exécution des requêtes.

5) Comment gérez-vous les migrations dans Entity Framework ?

Attendu du candidat : L'intervieweur évalue votre expérience avec les changements de schéma et le contrôle de version.

Exemple de réponse : Les migrations sont gérées en utilisant les outils de migration intégrés qui suivent les changements de modèle dans le temps. À un poste précédent, je générais et révisais régulièrement les scripts de migration avant de les appliquer pour assurer l'intégrité de la base de données à travers les environnements.

6) Qu'est-ce que le lazy loading, et quand l'éviteriez-vous ?

Attendu du candidat : L'intervieweur teste votre compréhension des stratégies de chargement de données et des compromis de performance.

Exemple de réponse : Le lazy loading charge automatiquement les données liées quand elles sont accédées. Je l'éviterais dans les scénarios critiques en performance ou les API car il peut causer des appels base de données multiples non intentionnels, menant au problème de requêtes N+1.

7) Comment gérez-vous les transactions dans Entity Framework ?

Attendu du candidat : L'intervieweur évalue votre connaissance de la cohérence des données et de la gestion d'erreurs.

Exemple de réponse : Entity Framework supporte les transactions via DbContext et TransactionScope. À mon précédent emploi, j'utilisais des transactions explicites pour assurer que plusieurs opérations de base de données liées soit réussissent ensemble, soit étaient annulées en cas d'échec.

8) Expliquer comment l'injection de dépendances est utilisée avec Entity Framework.

Attendu du candidat : L'intervieweur veut voir votre compréhension de l'architecture d'application moderne.

Exemple de réponse : L'injection de dépendances est utilisée pour injecter le DbContext dans les services ou contrôleurs. Cela améliore la testabilité et la maintenabilité en permettant au contexte d'être mocké ou remplacé sans changer la logique métier.

9) Décrivez un bug difficile que vous avez rencontré avec Entity Framework et comment vous l'avez résolu.

Attendu du candidat : L'intervieweur cherche la capacité de résolution de problèmes et les compétences de débogage.

Exemple de réponse : Dans mon dernier rôle, j'ai rencontré un problème de conflits de suivi lors de la mise à jour d'entités détachées. Je l'ai résolu en définissant explicitement les états d'entité et en assurant qu'une seule instance de chaque entité était suivie par le contexte.

10) Comment décidez-vous quand Entity Framework n'est pas le bon outil ?

Attendu du candidat : L'intervieweur veut comprendre votre jugement et capacité à choisir les technologies appropriées.

Exemple de réponse : J'envisage des alternatives quand les applications nécessitent un accès aux données à performance extrême ou une logique de procédure stockée complexe. Dans de tels cas, utiliser un micro-ORM ou ADO.NET brut peut fournir plus de contrôle et d'efficacité.

Comprendre la priorité et l'associativité des opérateurs en C : guide clair Guru99 : Tutoriels en ligne complets & avis logiciels professionnels

Langue C