Cadre d'entité principale :50 questions et réponses clés pour l'entretien (2026)

Se préparer à un entretien avec Entity Framework signifie anticiper les questions qui révèlent de réelles capacités. Les questions d'entretien d'Entity Framework révèlent la réflexion, la sensibilisation aux performances et la manière dont les candidats traduisent les concepts en pratique.

La maîtrise d'Entity Framework ouvre des rôles dans le développement moderne, des plates-formes basé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 apprécient la résolution pratique des problèmes, la conception évolutive, le mentorat des jeunes et les parcours de croissance des nouveaux diplômés.

Lire la suite…

👉 Téléchargement PDF gratuit : Questions et réponses pour l'entretien avec Entity Framework

1) Qu'est-ce qu'Entity Framework et pourquoi est-il utilisé ?

Entity Framework (EF) est le framework ORM (Object-Relational Mapping) de Microsoft pour .NET qui simplifie l'interaction avec les bases de données en permettant aux développeurs de travailler avec des données sous forme d'objets .NET fortement typés au lieu de SQL brut . Cette abstraction permet aux développeurs d'effectuer des opérations CRUD (Créer, Lire, Mettre à jour, Supprimer) à l'aide de constructions C# familières, et le framework gère la traduction de ces opérations en requêtes SQL optimisées sous le capot. EF réduit le code standard d'accès aux données, améliore la maintenabilité et contribue à renforcer la sécurité des types au moment de 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 sur la base de données et renverra les résultats sous forme d'objets.

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

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

Approche Quand utiliser Que se passe-t-il Coder d'abord Nouveaux projets ou conception axée sur le domaineVous définissez des classes d'entités. EF génère le schéma de base de données à partir du code.Database First La base de données existante génère des classes d'entités et un contexte à partir d'un schéma existant.Modèle d'abord Lorsque 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 répond à différents scénarios :Code First est populaire dans le développement agile, Database First est préféré avec les bases de données existantes 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 dans 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 DbSet<TEntity> propriétés, qui représentent des collections d'entités et mappent aux tables de 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 des objets et générer des commandes SQL sur SaveChanges() .

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

Migrations sont un mécanisme permettant de suivre et d'appliquer les modifications de schéma à la base de données au fil du temps. À mesure que votre modèle évolue, les migrations permettent de maintenir la synchronisation de la base de données sans modifier manuellement les scripts SQL. Avec Code First, vous utilisez des commandes telles que :

Add-Migration InitialCreate
Update-Database

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

5) Décrire le chargement paresseux, le chargement hâtif et le chargement explicite.

Le chargement efficace des données associées est essentiel dans EF. Voici une comparaison :

Stratégie Quand il s'exécute Utilisation typique Chargement paresseux Données associées chargées lors du premier accèsÀ utiliser lorsque les données associées ne sont pas toujours nécessaires.Chargement hâtif Données associées chargées à l'avance via .Include() À utiliser lorsque vous savez que vous avez besoin de données associées.Chargement explicite Chargé manuellement après la requêteDonne le contrôle sur le moment exact où les données associées sont chargées.

Par exemple :

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

Le chargement différé permet de réduire les requêtes initiales, mais peut entraîner des problèmes de requête N+1. s'il n'est pas utilisé avec précaution.

6) Qu'est-ce que le suivi des modifications dans Entity Framework ?

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

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

Le contrôle de la concurrence garantit que plusieurs utilisateurs mettant à jour les mêmes données n’écrasent pas involontairement les modifications des uns et des autres. EF utilise la concurrence optimiste par défaut. Une approche courante consiste à ajouter un jeton de concurrence (comme un RowVersion horodatage). EF vérifie ce jeton pendant SaveChanges() , et si elle diffère de la version de la base de données, un DbUpdateConcurrencyException est lancé, indiquant un conflit. Les développeurs peuvent ensuite 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 les entités. Ils permettent à EF de naviguer dans les associations (par exemple, un à plusieurs) sans jointures manuelles :

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

Ici, Customer est une propriété de navigation reliant Order à son Customer associé . EF utilise ces propriétés pour établir des relations et se joint automatiquement lors des 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 modifications pour une requête, ce qui est avantageux pour la lecture seule opérations pour lesquelles 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 de la mémoire et en suivant les frais généraux. Ceci 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 devez-vous les utiliser ?

Les requêtes compilées sont une technique d'optimisation des performances. Lorsqu'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 effectuée une seule fois et le délégué résultant est réutilisé, ce qui réduit la surcharge pour les requêtes complexes ou fréquemment exécutées. Utilisez-les dans des endroits à fort trafic scénarios dans lesquels la même requête s'exécute à plusieurs reprises avec des paramètres différents.

11) Que 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 de l'entité sont :

État Description Opération déclenchée Ajouté Nouvelle entité à insérerINSERT Modifié Entité existante mise à jourUPDATE Supprimé Entité marquée pour suppressionDELETE Inchangé Aucun changement détectéAucunDétaché Non suivi par contexteAucun

Quand vous appelez le SaveChanges() , EF inspecte les états de l'entité et exécute les commandes SQL correspondantes. Par exemple, une nouvelle entité ajoutée à un DbSet sera marqué Ajouté , ce qui donne un INSERT requête.

Exemple :

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

Cela met explicitement à jour l'enregistrement de la base de données 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 les inconvénients de l'utilisation d'Entity Framework ?

Entity Framework offre de nombreux avantages, mais également certains compromis, en fonction de votre cas d'utilisation.

Avantages Inconvénients Simplifie l'accès aux données via LINQ et les modèles d'objet.Surcharge de performances par rapport à ADO.NET brut.Réduit le code SQL passe-partout.Les requêtes complexes peuvent générer du SQL inefficace.Prend en charge plusieurs fournisseurs de bases de données.Plus difficile à déboguer les instructions SQL générées.Fortement typé, améliorant la sécurité au moment de la compilation.Conflits de migration possibles dans les grandes équipes.Permet un prototypage rapide avec Code First.Moins de contrôle sur les requêtes affinées.

Pour les systèmes à grande échelle nécessitant des performances maximales, les développeurs peuvent toujours 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 associations de clés étrangères .

Les types de relations sont :

Type de relation Description Exemple Individuel Chaque instance d'entité possède une entité associée.User ↔ UserProfile Un vers plusieurs Une entité est liée à plusieurs autres.Customer → Orders Plusieurs à plusieurs Plusieurs entités sont liées les unes aux autres.Student ↔ Course

Exemple d'un Un-à-Plusieurs relation :

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

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

Vous pouvez également utiliser l'API Fluent. pour une cartographie des relations plus explicite.

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

Fonctionnalité LINQ vers les entités LINQ to SQL Bases de données prises en chargePlusieurs (SQL Server, Oracle, MySQL, etc.)SQL Server uniquementFramework sous-jacentEntity FrameworkADO.NETModèleConceptual Entity ModelTables de base de données uniquementMappingMappage complexe (héritage, associations)Mappage direct des tablesSupport futurActivement pris en chargeObsolète

LINQ to Entités fait partie d'Entity Framework et est plus polyvalent, tandis que LINQ to SQL est limité à SQL Server et aux cas d'utilisation plus simples.

Par conséquent, LINQ to Entities est recommandé pour le développement au niveau de l'entreprise.

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

Fonctionnalité Contexte d'objet ContexteDb FrameworkVersions EF antérieuresAPI simplifiée dans EF 4.1+ComplexitéPlus détailléLéger et facilePerformancesLégèrement plus rapide mais plus difficile à utiliserSimplifié avec une surcharge minimaleSuivi des modificationsConfiguration manuelle nécessaireSuivi automatiqueUtilisation préféréeSystèmes héritésProjets EF/EF Core modernes

DbContext encapsule en interne ObjectContext 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 :

1. Création – L'entité est instanciée en mémoire (état :Détaché ).
2. Pièce jointe – Ajouté au contexte via DbSet.Add() (indiquer :Ajouté ).
3. Modification – Modifications détectées automatiquement (état :Modifié ).
4. Persistance – SaveChanges() appelé → commandes SQL exécutées.
5. Suppression – Entité marquée comme Supprimé et supprimé de la base de données.

Comprendre ce cycle de vie aide à déboguer les problèmes de données et à optimiser la gestion du contexte EF.

17) À quoi sert l'API Fluent dans Entity Framework ?

L'API Fluent fournit un moyen programmatique de configurer les relations de modèle, les contraintes et les mappages, souvent utilisés dans le OnModelCreating() méthode de votre DbContext .

Il donne un contrôle précis sur les configurations qui annotent les données ne peut pas exprimer.

Exemple :

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

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

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

Les annotations de données sont des attributs appliqué directement aux classes ou propriétés de modèle pour définir le comportement du schéma. Elles sont plus simples que l'API Fluent 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, les longueurs de chaîne, les champs obligatoires et les relations. Pour les cas avancés, les développeurs combinent généralement des Annotations de données et API Fluent .

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

Type Description Cas d'utilisation Entités suivies Surveillé par DbContext pour les modifications. Comportement par défaut pour les mises à jour. Entités non suivies Non surveillé ; récupéré 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 automatiquement les modifications.

Les entités non suivies améliorent les performances dans des scénarios à lecture élevée et à faible mise à jour.

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 termes de performances.

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

Pour les commandes sans requête :

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

Utilisez cette fonctionnalité avec précaution pour éviter l'injection SQL. et maintenir une flexibilité indépendante de la 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 leur architecture, leurs capacités et leur prise en charge multiplateforme.

Fonctionnalité Entity Framework 6 (EF6) Cœur d'Entity Framework Plateforme.NET Framework uniquementMultiplateforme (.NET 5/6/7)ArchitectureBasé sur ObjectContextLéger et modulairePerformancePlus lent dans certaines requêtesGénération de requêtes optimiséeSupport LINQMature mais limitéTraduction améliorée et asyncFournisseurs de bases de donnéesSQL Server, OracleMultiple (MySQL, PostgreSQL, SQLite, etc.)CaractéristiquesMature (par exemple, chargement paresseux)Moderne (par exemple, propriétés shadow, filtres globaux)

EF Core est le système moderne et activement développé version et le choix recommandé pour les nouveaux projets .NET en raison de sa flexibilité et de ses performances.

22) Comment fonctionnent les transactions dans Entity Framework ?

Les transactions dans Entity Framework garantissent l'intégrité des données lorsque plusieurs opérations doivent réussir ou échouer ensemble. Par défaut, EF encapsule SaveChanges() à l'intérieur d'une transaction. Pour le 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();
 }
}

Cela garantit l'atomicité :si une commande échoue, toutes les modifications sont annulées.

EF s'intègre également à System.Transactions pour la prise en charge des transactions distribuées.

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

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

Stratégie Description Exemple Avantages Inconvénients TPH (Table par hiérarchie) Toutes les classes partagent une table ; une colonne de discriminateur identifie le type. Commun dans EF Core. Requêtes simples et rapides. Le tableau peut devenir volumineux et clairsemé.TPT (Table par type) Chaque sous-classe possède sa propre table. Chaque classe dérivée est mappée séparément. Schéma normalisé. Jointures plus lentes sur les grandes hiérarchies. TPC (Table Per Concrete Class) Chaque classe possède sa propre table avec des colonnes en double. Chaque entité est mappée séparément. Lectures hautes performances. Redondance des données.

La plupart des développeurs préfèrent TPH pour sa simplicité, à moins que les besoins de normalisation ou de performances n'en décident autrement.

24) Comment gérez-vous le réglage des performances dans Entity Framework ?

Pour optimiser les performances d'Entity Framework :

1. Utilisez AsNoTracking() pour les requêtes en lecture seule.
2. Charge impatiente uniquement les entités liées nécessaires avec .Include() .
3. Éviter les requêtes N+1 en utilisant des projections ou Select() .
4. Utiliser des requêtes compilées pour les opérations fréquemment exécutées.
5. Grouper plusieurs insertions/mises à jour avec AddRange() et SaveChanges() .
6. Désactiver la détection automatique des modifications pour les opérations groupées :context.Configuration.AutoDetectChangesEnabled = false;
7. Utiliser la mise en cache et la pagination pour les grands ensembles de données.

Une implémentation EF bien réglée peut s'approcher des performances d'ADO.NET tout en conservant la productivité des développeurs.

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

Une propriété fantôme existe dans le modèle EF mais pas dans la classe d'entité. Il est maintenu par EF dans le suivi des modifications et stocké dans la base de données.

Exemple :

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

Cela permet à EF de stocker des métadonnées supplémentaires (par exemple, des horodatages, des informations d'audit) sans modifier la classe d'entité.

Vous pouvez accéder aux propriétés de l'ombre 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 de l'écriture dans la base de données.

Par exemple, pour stocker une énumération sous forme de 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 tels que enum , bool , ou DateTimeOffset .

Les convertisseurs de valeurs sont également utilisés pour le cryptage, la compression ou le masquage. de données sensibles.

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

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

Ceci est particulièrement utile pour les suppressions logicielles. ou multilocation .

Exemple :

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

Chaque requête exécutée sur Employee exclut automatiquement les enregistrements supprimés de manière logicielle, à moins qu'ils ne soient explicitement remplacés.

Les filtres globaux améliorent la maintenabilité et la sécurité des données.

28) Comment tester le code d'Entity Framework à l'aide de tests unitaires ?

Pour tester unitairement la logique EF sans toucher à une base de données réelle, utilisez des bases de données en mémoire. ou moqueur :

• Option 1 :fournisseur InMemory

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

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

Les tests unitaires doivent valider :

• Exactité de la requête (via LINQ)
• Cohérence des données après SaveChanges()
• Logique du référentiel

Les tests avec EF Core InMemory garantissent la rapidité et évitent les dépendances sur SQL Server.

29) Expliquez les modèles de référentiel et d'unité de travail dans EF.

Ces deux modèles architecturaux facilitent l'accès abstrait aux données. et maintenir la cohérence transactionnelle .

Modèle Objectif Exemple de mise en œuvre Dépôt Encapsule les opérations CRUD pour chaque entité.IRepository<T> interface avec Add() , GetAll() , etc.Unité de travail Coordonne plusieurs référentiels au sein d'une transaction.SaveChanges() agit comme une limite de validation.

Exemple :

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

Ces modèles améliorent la testabilité , réutilisation du code , et séparation des préoccupations dans les applications de grande entreprise.

30) Quelle est la différence entre le chargement rapide et le chargement par projection ?

Aspect Chargement impatient Chargement de la projection ObjectifCharge les données associées à l'avanceCharge uniquement des champs ou des propriétés spécifiquesMéthode.Include() .Select() Exemplecontext.Orders.Include(o => o.Customer) context.Orders.Select(o => new { o.Id, o.Customer.Name }) PerformanceRécupère des objets completsRécupère un minimum de donnéesCas d'utilisationLorsque des entités associées sont nécessaires pour le traitementLorsque vous avez besoin de données légères spécifiques

Le chargement de la projection est une optimisation des performances qui réduit la surcharge de mémoire en sélectionnant uniquement 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 de modifier les opérations de base de données telles que l'exécution de requêtes, la création de commandes et l'ouverture de connexion. .

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

Exemple : Journalisation de 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 des requêtes)
• Audit et suivi des performances

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 telles que SaveChangesAsync() , ToListAsync() , et FirstOrDefaultAsync() .

L'exécution asynchrone permet d'améliorer l'évolutivité dans les applications Web en libérant des threads en attendant les opérations de base de données liées aux E/S.

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 à haut débit. et microservices, 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 des connexions aide votre application à récupérer automatiquement suite à des pannes passagères de bases de données , comme des interruptions de réseau ou des délais d'attente SQL.

Il peut être configuré comme suit :

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

Ici, EF réessayera les opérations ayant échoué jusqu'à 5 fois avec des retards.

Ceci est particulièrement utile dans les environnements hébergés dans le cloud. comme Azure SQL où les erreurs transitoires sont courantes.

34) Que sont les types d’entités détenues dans EF Core ?

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

Ils partagent la même table que leur propriétaire et ne peuvent 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'utilisation :

Concepts de modélisation tels que Adresse , Argent , ou Mesure qui n'ont pas d'identité propre.

35) Comment pouvez-vous implémenter des suppressions logicielles dans Entity Framework Core ?

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

Ils sont implémentés à l'aide d'un drapeau booléen et des filtres de requêtes globaux .

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

Dans l'opération de suppression :

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

Avantages :

• Conservation des données historiques
• Récupération plus facile

Inconvénients :

• Tables de base de données plus grandes
• Nécessite une logique de filtrage minutieuse

36) Qu'est-ce qu'un modèle compilé dans EF Core et pourquoi est-il utilisé ?

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

Étapes :

1. Exécutez la commande :dotnet ef dbcontext optimize
2. EF génère un fichier de modèle précompilé que l'application charge plus rapidement au moment de l'exécution.

Avantage : Réduit la latence d'initialisation de 30 à 40 %, en particulier dans les grandes applications comportant de nombreuses entités.

Cas d'utilisation : Microservices hautes performances et environnements sans serveur.

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

La mise en cache permet de réduire les requêtes répétitives sur la base de données. Il existe deux niveaux principaux :

Type Description Exemple Cache de premier niveau Intégré, selon DbContext instanceGéré automatiquementCache de deuxième niveau Cache externe partagé entre les contextesUtilisez des bibliothèques comme EFCoreSecondLevelCacheInterceptor

Exemple de mise en cache de deuxième niveau :

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

Cela améliore considérablement les performances dans les applications gourmandes en lecture. en évitant les accès redondants aux bases de données.

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

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

Vous pouvez marquer une propriété comme jeton de concurrence en utilisant le [ConcurrencyCheck] ou [Timestamp] attribut.

Exemple :

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

Lorsqu'une mise à jour se produit, EF inclut cette colonne dans le WHERE clause.

Si la valeur ne correspond pas, un DbUpdateConcurrencyException est lancé - garantissant un contrôle de concurrence optimiste .

39) Comment implémentez-vous l'audit (suivi créé, modifié, supprimé) dans EF Core ?

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

Vous pouvez remplacer 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, garantissant une gouvernance cohérente des données .

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

Catégorie Bonnes pratiques Avantage Performances Utilisez AsNoTracking() et des projections pour les requêtes en lecture seule. Réduit les frais généraux.Conception Implémenter des modèles de référentiel et d'unité de travail. Améliore la maintenabilité.Sécurité Utilisez des requêtes paramétrées pour éviter l'injection SQL. Protection des données.Évolutivité Utilisez le regroupement de connexions et les méthodes asynchrones. Gère une charge élevée. Migrations Utilisez des migrations automatisées avec contrôle de version. Simplifie la gestion des schémas.Configuration Externalisez les chaînes de connexion et les secrets. Meilleure isolation de l'environnement.Tests Utilisez le fournisseur InMemory pour les tests unitaires. Exécutions de tests plus rapides.Journalisation Activez la journalisation EF pour obtenir des informations sur les performances. Débogage plus facile.

Ces pratiques garantissent une solution robuste, évolutive et maintenable applications construites sur Entity Framework.

41) Comment pouvez-vous 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 modèles inefficaces peuvent produire du SQL lent ou redondant. L'optimisation de LINQ garantit que l'ORM génère des requêtes de base de données performantes.

Techniques d'optimisation :

Utiliser les projections :

1. Sélectionnez uniquement les colonnes requises au lieu d'entités entières.

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

Évitez l'évaluation côté client :
Assurez-vous toujours que le filtrage s'effectue dans SQL , pas en mémoire. EF Core vous avertit lorsque l'évaluation est côté client.Utilisez AsNoTracking() pour les données en lecture seule.

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

Exploiter les requêtes compilées pour les opérations LINQ répétées.Évitez les .Include() inutiles appels - n'incluez les données associées que lorsque cela est 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 manières de générer des données initiales dans EF Core ?

L'amorçage des données garantit que la base de données contient des données par défaut ou de référence. une fois créé.

Approche 1 :utilisation de ModelBuilder

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

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

Approche 2 :méthode de départ personnalisée

Exécuter le 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 :
Utilisez 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 bases de données en interne ?

EF Core est indépendant du fournisseur , ce qui signifie qu'il peut cibler plusieurs moteurs de base de données via des packages de fournisseurs de bases de données distincts. .

Fournisseurs courants :

Fournisseur Package NuGet Base de données SQL ServerMicrosoft.EntityFrameworkCore.SqlServer MSSQLSQLiteMicrosoft.EntityFrameworkCore.Sqlite Mobile/BureauPostgreSQLNpgsql.EntityFrameworkCore.PostgreSQL PostgreSQLMySQLPomelo.EntityFrameworkCore.MySql Base de données MySQLCosmosMicrosoft.EntityFrameworkCore.Cosmos NoSQL

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

• Traduction de requête
• Génération de commandes SQL
• Mappage des types de données

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

44) Qu'est-ce qu'une « requête fractionnée » et quand devez-vous l'utiliser ?

Les requêtes fractionnées empêchent EF d'effectuer des jointures volumineuses et complexes en exécutant plusieurs requêtes SQL au lieu d'une.

Exemple :

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

Cela exécute :

1. Requête 1 → Obtenir des clients
2. Requête 2 → Obtenir les commandes liées à ces clients

Avantages :

• Empêche les produits cartésiens volumineux.
• Améliore les performances avec de grands ensembles de données associés.

Inconvénient :

Plusieurs allers-retours vers la base de données.

Utiliser des requêtes fractionnées lors du chargement impatient de données associées volumineuses pouvant entraîner des problèmes de mémoire.

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

La surveillance de SQL aide à déboguer les requêtes lentes et à optimiser le comportement ORM.

Méthodes de journalisation SQL :

1. Journalisation de la 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 les commandes et les timings.Outils de profilage Utilisez des outils tels que :

• MiniProfiler
• Profileur SQL Server
• EFCorePowerTools

La journalisation doit être activée de manière sélective en production pour éviter une surcharge de performances.

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

Fonctionnalité DetectChanges() AutoDetectChangesEnabled TypeMethodPropertyPurposeForce EF à analyser les entités suivies et à détecter les modificationsActive/désactive la détection automatique des modificationsDefaultManualTrueUsageAppelle explicitement pour l'optimisation des performancesDésactive les mises à jour groupées

Exemple :

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

La désactivation de la détection automatique dans les boucles améliore les performances jusqu'à 40 % dans les opérations en vrac.

47) Comment utiliser les tables temporelles avec EF Core ?

Les tables temporelles (introduites dans SQL Server 2016) vous permettent de suivre les données historiques automatiquement.

Étapes :

1. Activer la prise en charge temporelle lors de 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 intégré de l'historique des données
• Audit et conformité
• Aucun déclencheur manuel requis

EF Core 6+ prend en charge les requêtes temporelles complètes.

48) Comment EF Core prend-il en charge les requêtes compilées et les modèles pré-générés ?

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

Fonctionnalité Objectif Requêtes compiléesRésultats de traduction des requêtes en cacheModèles compilésMétadonnées du modèle précompilé

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 les coûts de démarrage , tandis que les requêtes compilées réduisent la surcharge des requêtes d'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 de microservices ?

Erreurs courantes :

1. DbContext partagé entre les services
   → Viole l'isolement des microservices.
   → Chaque microservice doit avoir son propre DbContext et son propre schéma.
2. Communication bavarde (requêtes N+1)
   → Minimisez les requêtes EF par appel d'API.
3. Chargement excessif excessif
   → Chargez uniquement ce qui est requis via les DTO.
4. Migrations centralisées
   → Chaque service doit gérer ses propres migrations de manière indépendante.
5. Absence de limites transactionnelles
   → Utilisez des transactions distribuées (modèle de boîte d'envoi) si une cohérence interservices est requise.
6. Couplage étroit au fournisseur SQL
   → Utiliser l'abstraction du référentiel pour conserver une flexibilité dans le choix de la base de données.

50) How does dependency injection integrate with DbContext in ASP.NET Core?

Entity Framework integrates seamlessly with ASP.NET Core’s built-in Dependency Injection (DI) system.

Setup:

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

Then inject it into controllers or services:

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

Lifetimes:

Lifetime Description Recommended For ScopedOne context per HTTP requestDefaultTransientNew instance every timeBackground jobsSingletonShared globallyAvoid (not thread-safe)

Using DI ensures testability, lifecycle management , and resource efficiency across web and background processes.

🔍 Top Entity Framework Interview Questions with Real-World Scenarios &Strategic Responses

1) What is Entity Framework, and why is it used in enterprise applications?

Expected from candidate: The interviewer wants to assess your foundational understanding of Entity Framework and its value in real-world applications.

Example answer: Entity Framework is an Object-Relational Mapping framework for .NET that allows developers to work with databases using .NET objects instead of raw SQL. It is used in enterprise applications to improve productivity, reduce boilerplate data access code, and maintain a strong separation of concerns.

2) Can you explain the difference between Code First, Database First, and Model First approaches?

Expected from candidate: The interviewer wants to evaluate your knowledge of different development workflows and when to use each one.

Example answer: Code First starts with domain classes and generates the database from code. Database First begins with an existing database and generates entity classes. Model First uses a visual designer to define the model and then creates both code and database. Each approach is chosen based on project requirements and existing infrastructure.

3) How does Entity Framework handle relationships between tables?

Expected from candidate: The interviewer is checking your understanding of data modeling and relational mapping.

Example answer: Entity Framework handles relationships using navigation properties and foreign keys. It supports one-to-one, one-to-many, and many-to-many relationships, allowing developers to traverse related data using object references rather than joins.

4) Describe a situation where you improved database performance using Entity Framework.

Expected from candidate: The interviewer wants to hear a practical example demonstrating optimization skills.

Example answer: In my previous role, I improved performance by reducing unnecessary eager loading and implementing projection queries with Select statements. This minimized the amount of data retrieved from the database and significantly reduced query execution time.

5) How do you manage migrations in Entity Framework?

Expected from candidate: The interviewer is assessing your experience with schema changes and version control.

Example answer: Migrations are managed using the built-in migration tools that track model changes over time. At a previous position, I regularly generated and reviewed migration scripts before applying them to ensure database integrity across environments.

6) What is lazy loading, and when would you avoid using it?

Expected from candidate: The interviewer wants to test your understanding of data loading strategies and performance trade-offs.

Example answer: Lazy loading automatically loads related data when it is accessed. I would avoid using it in performance-critical scenarios or APIs because it can cause multiple unintended database calls, leading to the N+1 query problem.

7) How do you handle transactions in Entity Framework?

Expected from candidate: The interviewer is evaluating your knowledge of data consistency and error handling.

Example answer: Entity Framework supports transactions through the DbContext and TransactionScope. At my previous job, I used explicit transactions to ensure that multiple related database operations either completed successfully together or were rolled back in case of failure.

8) Explain how dependency injection is used with Entity Framework.

Expected from candidate: The interviewer wants to see how well you understand modern application architecture.

Example answer: Dependency injection is used to inject the DbContext into services or controllers. This improves testability and maintainability by allowing the context to be mocked or replaced without changing business logic.

9) Describe a challenging bug you encountered with Entity Framework and how you resolved it.

Expected from candidate: The interviewer is looking for problem-solving ability and debugging skills.

Example answer: In my last role, I encountered an issue with tracking conflicts when updating detached entities. I resolved it by explicitly setting entity states and ensuring that only one instance of each entity was tracked by the context.

10) How do you decide when Entity Framework is not the right tool?

Expected from candidate: The interviewer wants to understand your judgment and ability to choose appropriate technologies.

Example answer: I consider alternatives when applications require extremely high-performance data access or complex stored procedure logic. In such cases, using a micro-ORM or raw ADO.NET can provide more control and efficiency.