Les 50 questions et réponses les plus fréquentes lors d'un entretien sur Entity Framework (2026)

Par : Benjamin marcheur Benjamin marcheur
Hours Le kit de préparation mis à jour

Questions et réponses principales lors d'un entretien sur Entity Framework

Se préparer à un entretien sur Entity Framework, c'est anticiper les questions qui révèlent les compétences réelles. Ces questions permettent d'évaluer le raisonnement, la conscience de la performance et la capacité des candidats à mettre les concepts en pratique.

La maîtrise d'Entity Framework ouvre des perspectives de carrière dans le développement moderne, des plateformes axées sur les données aux services cloud. L'expérience pratique développe les capacités d'analyse, approfondit les compétences techniques et soutient les équipes. Les recruteurs apprécient la résolution concrète de problèmes, la conception évolutive, le mentorat des développeurs juniors et les perspectives d'évolution pour les jeunes diplômés. Lire la suite...

👉 Téléchargement PDF gratuit : Questions et réponses d’entretien sur Entity Framework

Questions et réponses principales lors d'un entretien sur Entity Framework

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

Entity Framework (EF) est Microsoftle framework ORM (Object-Relational Mapping) de .NET pour .NET qui Simplifie l'interaction avec la base de données en permettant aux développeurs de manipuler les données sous forme d'objets .NET fortement typés plutôt que de requêtes SQL brutes.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, le framework se chargeant de traduire ces opérations en requêtes SQL optimisées en interne. EF réduit le code répétitif d'accès aux données, améliore la maintenabilité et contribue à garantir la sécurité des types à 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 principales approches de développement :

Approche Quand utiliser Commande
Code d'abord Nouveaux projets ou conception axée sur le domaine Vous définissez les classes d'entités. EF génère le schéma de base de données à partir du code.
Base de données d'abord Base de données existante EF 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 le design visuel 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 à des scénarios différents : Code d'abord est populaire dans le développement agile, Base de données d'abord est préférable avec les bases de données héritées, et Modèle d'abord 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éesIl suit les modifications apportées aux entités et coordonne l'enregistrement des données dans la base de données. Il représente un pont entre votre application C# et la base de données. DbContext, vous définissez DbSet<TEntity> propriétés, 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 sert de collection pour effectuer des opérations CRUD. EF utilise ce contexte pour état de l'objet de suivi 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 de suivi et d'application 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 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 modifications de schéma et les appliquent à la base de données. Les migrations permettent le contrôle de version du schéma de la base de données et facilitent le développement collaboratif.

5) Décrivez le chargement paresseux, le chargement immédiat et le chargement explicite.

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

de Marketing Quand ça marche Utilisation typique
Chargement Lazy Données associées chargées lors du premier accès À utiliser lorsque les données connexes ne sont pas toujours nécessaires.
Chargement impatient Données connexes chargées en amont via .Include() À utiliser lorsque vous savez que vous avez besoin de données connexes.
Chargement explicite Chargé manuellement après la requête Permet de contrôler précisément le moment 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 Problèmes de requête N+1 si elle n'est pas utilisée 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 de l'entité après l'exécution d'une requête. Lorsqu'une entité est récupérée par DbContextElle est suivie. Toute modification de ses propriétés est enregistrée, et lorsque SaveChanges() Lorsqu'EF est appelé, il génère le code SQL approprié. INSERT, UPDATE, ou DELETE déclarations. Pour les scénarios en lecture seule où le suivi est inutile, 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 concurrence garantit que plusieurs utilisateurs mettant à jour les mêmes données n'écrasent pas involontairement les modifications des autres. EF utilise 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, une DbUpdateConcurrencyException Une exception est levée, indiquant un conflit. Les développeurs peuvent alors la gérer pour réessayer ou résoudre les différences de données.

ARTICLES LIÉS

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. Elles permettent à EF de naviguer les associations (par exemple, une relation 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 à ses liens CustomerEF utilise ces propriétés pour établir automatiquement des relations et des jointures lors des requêtes. Les propriétés de navigation fonctionnent de concert. clés étrangères 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 bénéfique pour en lecture seule Il s'agit d'opérations pour lesquelles vous ne prévoyez pas de modifier les entités récupérées. Cela améliore les performances en réduisant la consommation de mémoire et la charge 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 faut-il les utiliser ?

Les requêtes compilées constituent une technique d'optimisation des performances. Lorsqu'une requête LINQ est exécutée, Entity Framework la traduit généralement en SQL à chaque fois. Avec les requêtes compilées, cette traduction n'est effectuée qu'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 domaines scénarios où la même requête est exécutée de manière répétée avec des paramètres différents.

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

Entity Framework assure le suivi de chaque entité. Etat pour déterminer quelle opération de base de données effectuer pendant SaveChanges()Les principaux états d'entité sont :

État Description Operation déclenchée
Ajouté Nouvelle entité à insérer INSERT
Modifié Entité existante mise à jour UPDATE
Supprimé Entité marquée pour suppression DELETE
Inchangé Aucun changement détecté Aucun
Détaché Non suivi par contexte Aucun

Quand vous appelez SaveChanges()EF examine l'état des entités et exécute les commandes SQL correspondantes. Par exemple, une nouvelle entité ajoutée à un DbSet sera marqué Ajouté, résultant en un INSERT requête.

Exemple : 

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

Cela met explicitement à jour l'enregistrement de l'entité dans la base de données.

États de compréhension assure un meilleur contrôle de la synchronisation et des performances des données.

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

Entity Framework offre des avantages considérables, mais aussi certains compromis, selon votre cas d'utilisation.

Avantages Désavantages
Simplifie l'accès aux données grâce à LINQ et aux modèles objets. Surcharge de performances par rapport à ADO.NET brut.
Réduit le code SQL répétitif. Les requêtes complexes peuvent générer du SQL inefficace.
Compatible avec plusieurs fournisseurs de bases de données. Débogage plus difficile des instructions SQL générées.
Typage fort, améliorant la sécurité à la compilation. Des conflits de migration sont possibles au sein de grandes équipes.
Permet un prototypage rapide avec Code First. Less contrôle sur les requêtes finement paramétrées.

Pour les systèmes à grande échelle exigeant des performances maximales, 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 propriétés de navigation et associations de clés étrangères.

Les types de relations sont :

Type de relation Description Exemple
Un-par-un Chaque instance d'entité possède une entité associé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 Un à plusieurs relation:

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

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

Vous pouvez également utiliser API fluide pour une cartographie des relations plus explicite.

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

Fonctionnalité LINQ aux entités LINQ vers SQL
Bases de données prises en charge Plusieurs (SQL Server, Oracle, MySQL, Etc) Serveur SQL uniquement
Cadre sous-jacent Cadre d'entité ADO.NET
Modèle Modèle d'entité conceptuelle Tables de base de données uniquement
Cartographie Cartographie complexe (héritage, associations) Correspondance directe des tables
Soutien futur Soutien actif Obsolète

LINQ aux entités fait partie d'Entity Framework et est plus polyvalent, tandis que LINQ vers 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 Contexte de base de données
FrameworkTA Versions EF antérieures API simplifiée dans EF 4.1+
Complexité Plus verbeux Léger et facile
Performances Légèrement plus rapide mais plus difficile à utiliser Simplifié avec des frais généraux minimaux
Suivi des modifications Configuration manuelle nécessaire Suivi automatique
Utilisation préférée Systèmes Projets modernes EF / EF Core

DbContext enveloppes intérieures ObjectContext mais offre une API plus claire et plus intuitive. La plupart des applications .NET actuelles devraient l'utiliser. DbContext.

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

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

  1. Création – L'entité est instanciée en mémoire (état : Détaché).
  2. L'attachement – Ajouté au contexte via DbSet.Add() (État: Ajouté).
  3. Modification – Modifications détectées automatiquement (état : Modifié).
  4. Persistence - SaveChanges() Commandes SQL exécutées.
  5. Suppression – Entité marquée comme Supprimé et supprimée 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 ?

Le API fluide offre une méthode de programmation pour configurer les relations, les contraintes et les mappages du modèle, souvent utilisés dans le OnModelCreating() votre méthode DbContext.

Il offre un contrôle précis sur les configurations qui annotation de données je ne peux pas l'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 la configuration clés composites, relations plusieurs-à-plusieursbauen règles en cascade.

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

Les annotations de données sont attributs Appliquées directement aux classes ou propriétés du modèle, elles permettent de définir le comportement du schéma. Plus simples que l'API Fluent, elles sont cependant 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, la longueur des chaînes de caractères, les champs obligatoires et les relations. Dans les cas complexes, les développeurs les combinent généralement. Annotations de données et API fluide.

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

Type Description Case Study
Entités suivies Surveillé par DbContext pour les changements. 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 changements.

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

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

Entity Framework permet d'exécuter du SQL brut pour les 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 autres que les requêtes :

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

Utilisez cette fonctionnalité avec précaution pour éviter Injection SQL et maintenir une flexibilité indépendante de toute 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) Noyau du cadre d'entité
Plateforme complète .NET Framework uniquement Multiplateforme (.NET 5/6/7)
Architecture Basé sur ObjectContext Léger et modulaire
Performances Plus lent pour certaines requêtes Génération de requêtes optimisée
Prise en charge de LINQ Mature mais limité Traduction améliorée et asynchrone
Fournisseurs de bases de données Serveur SQL, Oracle Plusieurs (MySQL, PostgreSQL, SQLite, Etc)
Caractéristiques Mature (par exemple, chargement différé) Moderne (par exemple, propriétés d'ombre, filtres globaux)

EF Core est le moderne, activement développée Cette version est 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 intégrité des données lorsque plusieurs opérations doivent réussir ou échouer simultanément. Par défaut, EF encapsule SaveChanges() Au sein d'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();
    }
}

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

EF s'intègre également avec Système.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 la modélisation des hiérarchies de classes.

de Marketing Description Exemple Avantages Désavantages
TPH (Tableau par hiérarchie) Toutes les classes partagent une même table ; une colonne discriminante identifie le type. Courant dans EF Core. Requêtes simples et rapides. Le tableau peut devenir grand et clairsemé.
TPT (Tableau 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 (Tableau par classe de béton) Chaque classe possède sa propre table avec des colonnes dupliquées. Chaque entité est cartographiée séparément. Lectures haute performance. Redondance des données.

La plupart des développeurs préfèrent TPH pour sa simplicité, sauf si les exigences de normalisation ou de performance imposent une autre solution.

24) Comment gérez-vous l'optimisation des performances dans Entity Framework ?

Pour optimiser les performances d'Entity Framework :

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

Une implémentation EF bien optimisée peut approcher les performances d'ADO.NET tout en préservant la productivité des développeurs.

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

A propriété de l'ombre Elle existe dans le modèle EF mais pas dans la classe d'entité. Elle est gérée par EF dans le système de suivi des modifications et stockée 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 fantômes 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 valeur dans EF Core ?

Les convertisseurs de valeurs d'EF Core permettent la transformation des valeurs de propriétés 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 de caractères :

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 chiffrement, compression ou masquage de données sensibles.

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

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

Ceci est particulièrement utile pour suppression logicielle or locations multiples.

Exemple : 

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

Chaque requête exécutée contre Employee Exclut automatiquement les enregistrements supprimés de manière réversible, sauf si cette option est explicitement désactivée.

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

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

Pour tester unitairement la logique d'EF sans accéder à une base de données réelle, utilisez bases de données en mémoire or railleur:

  • Option 1 : Fournisseur en mémoire 
    var options = new DbContextOptionsBuilder<AppDbContext>()
    .UseInMemoryDatabase("TestDb")
    .Options;
  • Option 2 : DbContext simulé
    Moquer DbSet en utilisant des bibliothèques comme Moq pour des tests isolés.

Les tests unitaires doivent valider :

  • Exactitude des requêtes (via LINQ)
  • Cohérence des données après SaveChanges()
  • Logique de dépôt

Les tests effectués avec EF Core InMemory garantissent la rapidité et évitent les dépendances vis-à-vis de SQL Server.

29) Expliquez les modèles de dépôt et d'unité de travail dans EF.

Ces deux modèles architecturaux aident accès aux données abstraites et maintenir la cohérence transactionnelle.

Patron de Couture Interet 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 s'améliorent testabilité, réutilisation du codebauen séparation des préoccupations dans les applications d'entreprise de grande envergure.

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

Aspect Chargement impatient Chargement de la projection
Interet Charge les données connexes en amont Charge uniquement certains champs ou propriétés
Méthode .Include() .Select()
Exemple context.Orders.Include(o => o.Customer) context.Orders.Select(o => new { o.Id, o.Customer.Name })
Performances Récupère des objets complets Récupère les données minimales
Case Study Lorsque des entités liées sont nécessaires au traitement Lorsque vous avez besoin de données légères spécifiques

Le chargement par projection est un Optimisation des performances cela réduit la consommation de mémoire en ne sélectionnant que les colonnes nécessaires.

31) Que sont les intercepteurs dans Entity Framework Core ?

Les intercepteurs d'EF Core permettent aux développeurs d'intercepter et de modifier les opérations de base de données telles que : Exécution de requêtes, création de commandes et ouverture de connexions.

Ils servent de composants intermédiaires entre EF et le fournisseur de base de données.

Exemple : Enregistrement 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 programmation asynchrone par des méthodes telles que SaveChangesAsync(), ToListAsync()bauen FirstOrDefaultAsync().

L'exécution asynchrone aide améliorer l'évolutivité dans les applications web en libérant les threads pendant l'attente des 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 à haut débit API ASP.NET Core et les microservices, réduisant ainsi 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 la connexion aide votre application récupération automatique suite à des pannes de base de données temporaires, comme des interruptions 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 tentera de relancer les opérations ayant échoué jusqu'à 5 fois, avec des délais.

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

34) Quels sont les types d'entités détenues dans EF Core ?

Les entités détenues permettent la modélisation objets de 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 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:

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

35) Comment implémenter des suppressions logiques dans Entity Framework Core ?

La suppression logique marque les enregistrements comme supprimés au lieu de les supprimer physiquement.

Ils sont mis en œuvre à l'aide d'un indicateur booléen et Filtres de requête globale.

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

Lors de 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 de base de données plus grandes
  • Nécessite une logique de filtrage rigoureuse

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.

Étape:

  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 lors de l'exécution.

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

Cas d'utilisation: Microservices haute performance 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 à la base de données. Il existe deux niveaux principaux :

Type Description Exemple
Cache de premier niveau Intégré, par DbContext instance Gestion automatique
Cache de second niveau Cache externe partagé entre les contextes Utilisez des bibliothèques comme EFCoreSecondLevelCacheInterceptor

Exemple de mise en cache de second niveau :

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

Cela améliore considérablement les performances dans applications à forte intensité de lecture en évitant les requêtes redondantes à la base de données.

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

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

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

Exemple : 

public class Product
{
    public int Id { get; set; }

    [Timestamp]
    public byte[] RowVersion { get; set; }
}

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

Si la valeur ne correspond pas, un DbUpdateConcurrencyException est jeté — assurant contrôle de concurrence optimiste.

39) Comment implémentez-vous l'audit (suivi des créations, modifications et suppressions) dans EF Core ?

L'audit permet de suivre les métadonnées telles que qui a créé, modifié ou supprimé Records.

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 gouvernance des données cohérente.

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

Catégorie Meilleure pratique Bénéfice
Performances Utilisez le AsNoTracking() et des projections pour les requêtes en lecture seule. Réduit les frais généraux.
Design Mettre en œuvre les modèles de référentiel et d'unité de travail. Améliore la maintenabilité.
Sûreté Utilisez des requêtes paramétrées pour éviter les injections SQL. Protection des données.
Évolutivité Utilisez le regroupement de connexions et les méthodes asynchrones. Supporte les charges élevées.
Migrations Utilisez les migrations automatisées avec le contrôle de version. Simplifie la gestion des schémas.
Configuration Externalisez les chaînes de connexion et les secrets. Meilleure isolation environnementale.
Tests Utilisez le fournisseur InMemory pour les tests unitaires. Exécution des tests plus rapide.
Journal Activez la journalisation EF pour obtenir des informations sur les performances. Débogage simplifié.

Ces pratiques garantissent robuste, évolutif et maintenable applications construites 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 modèles inefficaces peuvent générer des requêtes SQL lentes ou redondantes. L'optimisation des requêtes LINQ garantit que l'ORM génère des requêtes de base de données performantes.

Techniques d'optimisation :

Utiliser des projections :

  1. Sélectionnez uniquement les colonnes requises au lieu des entités entières.
    2. var customers = context.Customers
    .Select(c => new { c.Id, c.Name })
    .ToList();
  2. Évitez l'évaluation côté client :
    Assurez-vous toujours que le filtrage a lieu en SQL, pas en mémoire. EF Core émet un avertissement lorsque l'évaluation est effectuée côté client.
  3. Utilisez le AsNoTracking() pour les données en lecture seule.
    4. var orders = context.Orders.AsNoTracking().ToList();
  4. Exploiter les requêtes compilées pour les opérations LINQ répétées.
  5. Éviter inutile .Include() en cours — N’inclure que les données pertinentes 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 d'initialiser les données dans EF Core ?

L'amorçage des données garantit que la base de données possède données par défaut ou de référence lors de sa création.

Approche 1 : Utilisation de ModelBuilder

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

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

Approche 2 : Méthode de graine 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

Utilisez du SQL brut dans les migrations :

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

Recommandation:
Utilisez le HasData() pour les données de référence statiques et l'initialisation programmatique des 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 fournisseurce qui signifie qu'il peut cibler plusieurs moteurs de base de données via des plateformes distinctes. packages de fournisseur de base de données.

Fournisseurs courants :

Provider NuGet Forfait Base de données
SQL Server Microsoft.EntityFrameworkCore.SqlServer MSSQL
SQLite Microsoft.EntityFrameworkCore.Sqlite Mobile/Bureau
PostgreSQL Npgsql.EntityFrameworkCore.PostgreSQL PostgreSQL
MySQL Pomelo.EntityFrameworkCore.MySql MySQL
Base de données Cosmos Microsoft.EntityFrameworkCore.Cosmos NoSQL

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

  • Traduction de requêtes
  • génération de commandes SQL
  • Correspondance 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 faut-il l’utiliser ?

Les requêtes fractionnées empêchent EF de fonctionner correctement. assemblages larges et complexes en exécutant plusieurs requêtes SQL au lieu d'une seule.

Exemple : 

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

Ceci exécute :

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

Avantages:

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

Inconvénient:

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

Utilisez le requêtes fractionnées lors du chargement anticipé de grandes quantités de données connexes pouvant entraîner des problèmes de mémoire.

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

La surveillance des requêtes SQL permet de déboguer les requêtes lentes et d'optimiser le comportement de l'ORM.

Méthodes pour consigner les requêtes SQL :

  1. Journalisation de la console
    2. optionsBuilder
    .UseSqlServer(conn)
    .LogTo(Console.WriteLine, LogLevel.Information);
  2. Intégration d'ILoggerFactory
    3. var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
optionsBuilder.UseLoggerFactory(loggerFactory);
  3. Intercepteurs Mettre en œuvre le DbCommandInterceptor pour capturer les commandes et les durées.
  4. Outils de profilage Utilisez des outils tels que :
    • Miniprofileur
    • Profileur SQL Server
    • Outils électriques EFCore

La journalisation devrait être activé de manière sélective en production afin d'éviter les surcoûts de performance.

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

Fonctionnalité DetectChanges() AutoDetectChangesEnabled
Type Méthode Propriété
Interet Force EF à analyser les entités suivies et à détecter les changements Active/désactive la détection automatique des changements
Réglage par défaut Manuel (Le français commence à la page neuf) Vrai
Utilisation Demande explicite d'optimisation des performances Désactiver pour 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 de grande envergure.

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.

Étape:

  1. Activer la prise en charge temporelle lors de la migration :
    2. builder.Entity<Employee>()
    .ToTable("Employees", b => b.IsTemporal());
  2. Interroger les données historiques :
    3. var history = context.Employees
    .TemporalAsOf(DateTime.UtcNow.AddDays(-7))
    .ToList();

Avantages :

  • Suivi intégré de l'historique des données
  • Audit et conformité
  • Aucune gâchette manuelle requise

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

48) Comment EF Core prend-il en charge à la fois 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 caractéristiques de performances qui se complètent.

Fonctionnalité Interet
Requêtes compilées Résultats de traduction des requêtes du cache
Modèles compilés Métadonnées du modèle précompilées

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));

Usage:

var customer = _getCustomerById(context, 5);

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

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

Erreurs fréquentes:

  1. Contexte de base de données partagé entre les services
    → Viole l'isolation des microservices.
    → Chaque microservice doit avoir son propre DbContext et son propre schéma.
  2. Communication conversationnelle (N+1 requêtes)
    → Minimiser les requêtes EF par appel API.
  3. Chargement excessif et impatient
    → Charger uniquement ce qui est nécessaire 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 Outbox) si une cohérence inter-services est requise.
  6. Couplage étroit avec le fournisseur SQL
    → Utilisez l'abstraction de référentiel pour conserver une certaine flexibilité dans le choix de la base de données.

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

Entity Framework s'intègre parfaitement à Injection de dépendances (DI) intégrée à ASP.NET Core système.

Installer:

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

Ensuite, injectez-le dans les contrôleurs ou les services :

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

Durée de vie :

À vie Description Recommandé pour
Portée Un contexte par requête HTTP Réglage par défaut
Transitoire Nouvelle instance à chaque fois Travaux en arrière-plan
Singleton Partagé à l'échelle mondiale À éviter (non compatible avec le filetage)

L'utilisation de DI garantit testabilité, gestion du cycle de viebauen utilisation efficace des ressources sur le Web et les processus en arrière-plan.

🔍 Questions d'entretien les plus fréquentes sur Entity Framework, avec des scénarios concrets et des réponses stratégiques

1) Qu'est-ce qu'Entity Framework et pourquoi est-il utilisé dans les applications d'entreprise ?

Attendu du candidat : L'intervieweur souhaite évaluer votre compréhension fondamentale d'Entity Framework et sa valeur dans les applications concrètes.

Exemple de réponse: Entity Framework est un framework de mappage objet-relationnel pour .NET qui permet aux développeurs d'interagir avec les bases de données à l'aide d'objets .NET plutôt que de requêtes SQL brutes. Il est utilisé dans les applications d'entreprise pour améliorer la productivité, réduire le code répétitif d'accès aux données et maintenir une séparation stricte 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 souhaite évaluer votre connaissance des différents flux de travail de développement et de leur utilisation appropriée.

Exemple de réponse: L'approche Code First part des classes de domaine et génère la base de données à partir du code. L'approche Database First s'appuie sur une base de données existante et génère les classes d'entités. L'approche Model First utilise un concepteur visuel pour définir le modèle, puis crée le code et la base de données. Le choix de chaque approche dépend des exigences du projet et de l'infrastructure existante.

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

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

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

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

Attendu du candidat : L'intervieweur souhaite entendre un exemple concret démontrant des compétences en optimisation.

Exemple de réponse: Dans mon poste précédent, j'ai amélioré les performances en réduisant le chargement anticipé inutile et en implémentant des requêtes de projection avec des instructions SELECT. Cela a permis de minimiser la quantité de données extraites de la base de données et de réduire considérablement 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 en matière de modifications de schémas et de contrôle de version.

Exemple de réponse: Les migrations sont gérées à l'aide des outils de migration intégrés qui suivent les modifications apportées au modèle au fil du temps. Auparavant, je générais et vérifiais régulièrement les scripts de migration avant de les appliquer afin de garantir l'intégrité de la base de données dans tous les environnements.

6) Qu'est-ce que le chargement différé, et quand faut-il éviter de l'utiliser ?

Attendu du candidat : L'intervieweur souhaite tester votre compréhension des stratégies de chargement de données et des compromis en matière de performance.

Exemple de réponse: Le chargement différé charge automatiquement les données associées lors de leur accès. Il est déconseillé de l'utiliser dans les applications ou API critiques en termes de performances, car il peut entraîner de multiples requêtes de base de données non désirées, provoquant le problème des N+1 requêtes.

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

Attendu du candidat : L'intervieweur évalue vos connaissances en matière de cohérence des données et de gestion des erreurs.

Exemple de réponse: Entity Framework prend en charge les transactions via DbContext et TransactionScope. Dans mon précédent emploi, j'utilisais des transactions explicites pour garantir que plusieurs opérations de base de données liées s'exécutent simultanément avec succès ou soient annulées en cas d'échec.

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

Attendu du candidat : Le recruteur souhaite évaluer votre compréhension de l'architecture des applications modernes.

Exemple de réponse: L'injection de dépendances permet d'injecter le DbContext dans les services ou les contrôleurs. Cela améliore la testabilité et la maintenabilité en permettant de simuler ou de remplacer le contexte sans modifier 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 : Le recruteur recherche des compétences en résolution de problèmes et en débogage.

Exemple de réponse: Dans mon poste précédent, j'ai rencontré un problème de gestion des conflits lors de la mise à jour d'entités détachées. Je l'ai résolu en définissant explicitement l'état des entités et en veillant à ce qu'une seule instance de chaque entité soit suivie par le contexte.

10) Comment décider quand Entity Framework n'est pas l'outil approprié ?

Attendu du candidat : Le recruteur souhaite comprendre votre jugement et votre capacité à choisir les technologies appropriées.

Exemple de réponse: J'envisage des solutions alternatives lorsque les applications nécessitent un accès aux données à très haute performance ou une logique de procédure stockée complexe. Dans ce cas, l'utilisation d'un micro-ORM ou d'ADO.NET natif peut offrir un meilleur contrôle et une efficacité accrue.

Résumez cet article avec :