Entity Framework meesteren: 50 essentiële interviewvragen & antwoorden (2026)

Zich voorbereiden op een Entity Framework-interview betekent anticiperen op de vragen die echte vaardigheid onthullen. Entity Framework-interviewvragen onthullen denkvermogen, prestatiebewustzijn en hoe kandidaten concepten in de praktijk vertalen.

Entity Framework onder de knie krijgen opent rollen in moderne ontwikkeling, van data-gedreven platforms tot cloud-services. Praktijkervaring bouwt analytisch vermogen, versterkt technische diepgang en ondersteunt teams. Wervingsleiders waarderen hands-on probleemoplossing, schaalbaar ontwerp, mentoring van juniors en groeipaden voor verse afgestudeerden.

👉 Gratis PDF-download: Entity Framework Interviewvragen & Antwoorden

1) Wat is Entity Framework en waarom wordt het gebruikt?

Entity Framework (EF) is Microsoft's ORM (Object-Relational Mapping) framework voor .NET dat database-interactie vereenvoudigt door ontwikkelaars toe te staan met data te werken als sterk getype .NET-objecten in plaats van raw SQL. Deze abstractie stelt ontwikkelaars in staat CRUD-bewerkingen (Create, Read, Update, Delete) uit te voeren met bekende C#-constructs, en het framework vertaalt deze bewerkingen achter de schermen naar geoptimaliseerde SQL-queries. EF vermindert boilerplate data-toegangscode, verbetert onderhoudbaarheid en helpt compile-time type safety af te dwingen.

Bijvoorbeeld, in plaats van SQL te schrijven, kunt u gebruiken:

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

EF vertaalt deze LINQ-query naar SQL, voert het uit tegen de database en retourneert de resultaten als objecten.

2) Leg het verschil uit tussen Code First, Database First en Model First benaderingen.

Entity Framework ondersteunt drie hoofdontwikkelbenaderingen:

Benadering	Wanneer te gebruiken	Wat gebeurt er
Code First	Nieuwe projecten of domain-driven design	U definieert entiteitsklassen. EF genereert het databaseschema vanuit code.
Database First	Bestaande database	EF genereert entiteitsklassen en context vanuit een bestaand schema.
Model First	Wanneer u visueel ontwerp prefereert	U ontwerpt het model in een visuele designer (Entity Designer), en EF genereert zowel klassen als database.

Elke benadering dient verschillende scenario's: Code First is populair in agile ontwikkeling, Database First wordt voorkeur gegeven bij legacy-databases, en Model First past bij gevallen waar visueel modelleren belangrijk is.

3) Wat is DbContext en welke rol speelt het in EF?

DbContext is de primaire klasse die de sessie met de database beheert, entiteitswijzigingen bijhoudt en het opslaan van data naar de database coördineert. Het vertegenwoordigt een brug tussen uw C#-applicatie en de database. Via DbContext definieert u DbSet<TEntity> eigenschappen, die verzamelingen van entiteiten vertegenwoordigen en mappen op tabellen in de database.

Voorbeeld:

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

Hier fungeert Products als een verzameling voor het uitvoeren van CRUD-bewerkingen. EF gebruikt deze context om objectstatussen te tracken en SQL-commando's te genereren bij SaveChanges().

4) Wat zijn migraties in Entity Framework en hoe worden ze gebruikt?

Migraties zijn een mechanisme om schemavergelijkingen in de database over tijd te volgen en toe te passen. Naar gelang uw model evolueert, helpen migraties de database in sync te houden zonder handmatig SQL-scripts te wijzigen. Met Code First gebruikt u commando's als:

Add-Migration InitialCreate
Update-Database

Dit genereert migratieklassen die schemavergelijkingen definiëren en past ze toe op de database. Migraties staan versiebeheer voor het databaseschema toe en faciliteren samenwerkende ontwikkeling.

5) Beschrijf Lazy Loading, Eager Loading en Explicit Loading.

Efficiënt laden van gerelateerde data is cruciaal in EF. Hier is een vergelijking:

Strategie	Wanneer het draait	Typisch gebruik
Lazy Loading	Gerelateerde data geladen bij eerste toegang	Gebruik wanneer gerelateerde data niet altijd nodig is.
Eager Loading	Gerelateerde data vooraf geladen via .Include()	Gebruik wanneer u weet dat u gerelateerde data nodig heeft.
Explicit Loading	Handmatig geladen na query	Geeft controle over precies wanneer gerelateerde data geladen wordt.

Bijvoorbeeld:

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

Lazy loading helpt initiële queries te reduceren, maar kan N+1 query-problemen veroorzaken als niet voorzichtig gebruikt.

6) Wat is change tracking in Entity Framework?

Change tracking is EF's interne mechanisme om entiteitsstaatwijzigingen te monitoren na het uitvoeren van een query. Wanneer een entiteit wordt opgehaald door DbContext, wordt het getracked. Elke wijziging in de eigenschappen wordt genoteerd, en wanneer SaveChanges() wordt aangeroepen, genereert EF de passende SQL INSERT, UPDATE of DELETE statements. Voor read-only scenario's waar tracking onnodig is, verbetert AsNoTracking() de prestaties door change tracking uit te schakelen.

7) Hoe gaat Entity Framework om met concurrency-conflicten?

Concurrency-controle zorgt ervoor dat meerdere gebruikers die dezelfde data bijwerken, elkaars wijzigingen niet onbedoeld overschrijven. EF gebruikt standaard optimistische concurrency. Een veelvoorkomende benadering omvat het toevoegen van een concurrency-token (zoals een RowVersion timestamp). EF controleert deze token tijdens SaveChanges(), en als deze afwijkt van de databaseversie, wordt een DbUpdateConcurrencyException gegooid, wat een conflict aangeeft. Ontwikkelaars kunnen deze exception vervolgens afhandelen om te herproberen of data-verschillen op te lossen.

8) Wat zijn navigatie-eigenschappen in EF?

Navigatie-eigenschappen definiëren relaties tussen entiteiten. Ze staan EF toe om associaties te navigeren (bijv. one-to-many) zonder handmatige joins:

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

Hier is Customer een navigatie-eigenschap die Order koppelt aan de gerelateerde Customer. EF gebruikt deze eigenschappen om relaties en joins automatisch te bouwen tijdens queries. Navigatie-eigenschappen werken samen met foreign keys om relaties te modelleren.

9) Wat is het doel van AsNoTracking()?

AsNoTracking() schakelt change tracking uit voor een query, wat gunstig is voor read-only operaties waar u niet van plan bent de opgehaalde entiteiten bij te werken. Dit verbetert prestaties door geheugengebruik en tracking-overhead te reduceren. Het is met name nuttig bij het ophalen van grote datasets zonder ze te wijzigen.

10) Wat zijn gecompileerde queries en wanneer moet u ze gebruiken?

Gecompileerde queries zijn een prestatie-optimalisatietechniek. Wanneer een LINQ-query wordt uitgevoerd, vertaalt EF deze telkens naar SQL. Met gecompileerde queries wordt deze vertaling één keer gedaan, en de resulterende delegate wordt hergebruikt — wat overhead vermindert voor frequente of complexe queries. Gebruik ze in high-traffic scenario's waar dezelfde query herhaaldelijk draait met verschillende parameters.

11) Wat zijn entiteitsstatussen in Entity Framework, en hoe beïnvloeden ze SaveChanges()?

Entity Framework trackt elke entiteit's staat om te bepalen welke databaseoperatie tijdens SaveChanges() moet worden uitgevoerd. De belangrijkste entiteitsstatussen zijn:

Staat	Beschrijving	Getriggerde operatie
Added	Nieuwe entiteit om in te voegen	INSERT
Modified	Bestaande entiteit bijgewerkt	UPDATE
Deleted	Entiteit gemarkeerd voor verwijdering	DELETE
Unchanged	Geen wijzigingen gedetecteerd	Geen
Detached	Niet getracked door context	Geen

Wanneer u SaveChanges() aanroept, inspecteert EF de entiteitsstatussen en voert de corresponderende SQL-commando's uit. Een nieuwe entiteit toegevoegd aan een DbSet wordt gemarkeerd Added, wat resulteert in een INSERT query.

Voorbeeld:

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

Dit werkt de database-record voor de entiteit expliciet bij.

Statussen begrijpen zorgt voor betere controle over datasynchronisatie en prestaties.

12) Wat zijn de voor- en nadelen van het gebruik van Entity Framework?

Entity Framework biedt sterke voordelen maar ook enkele trade-offs, afhankelijk van uw use case.

Voordelen	Nadelen
Vereenvoudigt data-toegang via LINQ en objectmodellen	Prestatie-overhead ten opzichte van raw ADO.NET
Vermindert boilerplate SQL-code	Complexe queries kunnen inefficiënte SQL genereren
Ondersteunt meerdere databaseproviders	Lastiger om gegenereerde SQL te debuggen
Sterk getypeerd, verbetert compile-time safety	Migratieconflicten in grote teams mogelijk
Stelt snelle prototyping toe met Code First	Minder controle over fijnmazige queries

Voor grootschalige systemen die maximale prestaties vereisen, kunnen ontwikkelaars nog steeds raw SQL met EF mengen voor optimalisatie.

13) Hoe gaat Entity Framework om met relaties (one-to-one, one-to-many, many-to-many)?

Entity Framework beheert relaties via navigatie-eigenschappen en foreign key-associaties.

De typen relaties zijn:

Relatietype	Beschrijving	Voorbeeld
One-to-One	Elk entiteitsexemplaar heeft één gerelateerde entiteit.	User ↔ UserProfile
One-to-Many	Eén entiteit relateert tot meerdere anderen.	Customer → Orders
Many-to-Many	Meerdere entiteiten relateren tot elkaar.	Student ↔ Course

Voorbeeld van een One-to-Many relatie:

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

EF genereert automatisch foreign keys en houdt cascade delete rules afhankelijk van configuratie.

U kunt ook Fluent API gebruiken voor explicietere relatiemapping.

14) Wat is het verschil tussen LINQ to Entities en LINQ to SQL?

Kenmerk	LINQ to Entities	LINQ to SQL
Ondersteunde databases	Meerdere (SQL Server, Oracle, MySQL, etc.)	Alleen SQL Server
Onderliggend framework	Entity Framework	ADO.NET
Model	Conceptueel entiteitsmodel	Databasetabellen alleen
Mapping	Complexe mapping (inheritance, associaties)	Directe tabelmapping
Toekomstige ondersteuning	Actief ondersteund	Afgeschaft

LINQ to Entities is onderdeel van Entity Framework en veelzijdiger, terwijl LINQ to SQL beperkt is tot SQL Server en simpelere use cases.

Daarom wordt LINQ to Entities aanbevolen voor enterprise-ontwikkeling.

15) Wat is het verschil tussen ObjectContext en DbContext?

Kenmerk	ObjectContext	DbContext
Framework	Vroegere EF-versies	Vereenvoudigde API in EF 4.1+
Complexiteit	Meer verbose	Lichtgewicht en makkelijk
Prestaties	Lichtjes sneller maar moeilijker te gebruiken	Vereenvoudigd met minimale overhead
Change Tracking	Handmatige configuratie nodig	Automatische tracking
Voorkeursgebruik	Legacy-systemen	Moderne EF / EF Core-projecten

DbContext wikkelt ObjectContext intern in maar biedt een schonere en intuïtievere API. Meeste huidige .NET-applicaties moeten DbContext gebruiken.

16) Leg de levenscyclus van een entiteit in Entity Framework uit.

De levenscyclus van een entiteit beschrijft zijn staatsovergangen van creatie tot persistentie:

1. Creatie – Entiteit wordt in geheugen geïnstantieerd (staat: Detached).
2. Attachment – Toegevoegd aan context via DbSet.Add() (staat: Added).
3. Wijziging – Wijzigingen gedetecteerd automatisch (staat: Modified).
4. Persistentie – SaveChanges() aangeroepen → SQL-commando's uitgevoerd.
5. Verwijdering – Entiteit gemarkeerd als Deleted en uit database verwijderd.

Deze levenscyclus begrijpen helpt bij het debuggen van data-issues en het optimaliseren van EF-contextbeheer.

17) Wat is het gebruik van Fluent API in Entity Framework?

De Fluent API biedt een programmatische manier om modelrelaties, constraints en mappings te configureren, vaak gebruikt in de OnModelCreating() methode van uw DbContext.

Het geeft fijnmazige controle over configuraties die data annotations niet kunnen uitdrukken.

Voorbeeld:

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

Fluent API is bijzonder krachtig voor het configureren van composite keys, many-to-many relaties en cascade rules.

18) Wat zijn Data Annotations in Entity Framework?

Data Annotations zijn attributen die direct op modelklassen of eigenschappen worden toegepast om schemage gedrag te definiëren. Ze zijn simpeler dan Fluent API maar minder flexibel.

Voorbeeld:

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

Annotations definiëren keys, string lengths, verplichte velden en relaties. Voor geavanceerde gevallen combineren ontwikkelaars meestal Data Annotations en Fluent API.

19) Wat is het verschil tussen getrackte en niet-getrackte entiteiten in EF Core?

Type	Beschrijving	Use Case
Getrackte entiteiten	Gemonitored door DbContext voor wijzigingen. Standaardgedrag voor updates.
Niet-getrackte entiteiten	Niet gemonitored; opgehaald met .AsNoTracking(). Ideaal voor read-only operaties.

Getrackte entiteiten consumeren meer geheugen maar staan EF toe wijzigingen automatisch te detecteren.

Niet-getrackte entiteiten verbeteren prestaties in high-read, low-update scenario's.

20) Hoe kunt u raw SQL-queries uitvoeren in Entity Framework?

Entity Framework staat het uitvoeren van raw SQL toe voor custom of prestatie-kritieke queries.

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

Voor non-query commando's:

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

Gebruik deze functie voorzichtig om SQL-injectie te vermijden en database-agnostische flexibiliteit te behouden.

21) Wat is het verschil tussen Entity Framework en Entity Framework Core?

Entity Framework (EF) en Entity Framework Core (EF Core) verschillen in architectuur, mogelijkheden en cross-platform ondersteuning.

Kenmerk	Entity Framework 6 (EF6)	Entity Framework Core
Platform	.NET Framework only	Cross-platform (.NET 5/6/7)
Architectuur	Gebaseerd op ObjectContext	Lichtgewicht en modulair
Prestaties	Trager in sommige queries	Geoptimaliseerde querygeneratie
LINQ-ondersteuning	Rijp maar beperkt	Verbeterde vertaling en async
Databaseproviders	SQL Server, Oracle	Meerdere (MySQL, PostgreSQL, SQLite, etc.)
Functies	Rijp (bijv. lazy loading)	Modern (bijv. shadow properties, global filters)

EF Core is de moderne, actief ontwikkelde versie en de aanbevolen keuze voor nieuwe .NET-projecten vanwege zijn flexibiliteit en prestaties.

22) Hoe werken transacties in Entity Framework?

Transacties in Entity Framework waarborgen dataintegriteit wanneer meerdere operaties samen slagen of falen. Standaard wikkelt EF SaveChanges() in een transactie. Voor handmatige controle:

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

Dit waarborgt atomiciteit — als een commando faalt, worden alle wijzigingen teruggedraaid.

EF integreert ook met System.Transactions voor gedistribueerde transactieondersteuning.

23) Leg TPH, TPT en TPC overervingsstrategieën in Entity Framework uit.

Entity Framework ondersteunt drie hoofdoverervingsmappingstrategieën voor het modelleren van klassehiërarchieën.

Strategie	Beschrijving	Voorbeeld	Voordelen	Nadelen
TPH (Table Per Hierarchy)	Alle klassen delen één tabel; een discriminator-kolom identificeert type.	Algemeen in EF Core	Simpel, snelle queries	Tabel kan groot en sparse worden
TPT (Table Per Type)	Elke subklasse heeft een eigen tabel.	Elke afgeleide klasse apart gemapt	Genormaliseerd schema	Langzamere joins bij grote hiërarchieën
TPC (Table Per Concrete Class)	Elke klasse heeft een eigen tabel met gedupliceerde kolommen.	Elke entiteit apart gemapt	Hoge leesprestaties	Data-redundantie

Meeste ontwikkelaars prefereren TPH om de eenvoud, tenzij normalisatie of prestatiebehoefte anders dicteert.

24) Hoe kunt u prestaties tunen in Entity Framework?

Om Entity Framework-prestaties te optimaliseren:

1. Gebruik AsNoTracking() voor read-only queries.
2. Eager load alleen noodzakelijke gerelateerde entiteiten met .Include().
3. Vermijd N+1 queries door projecties of Select() te gebruiken.
4. Gebruik gecompileerde queries voor frequente operaties.
5. Batch meerdere inserts/updates met AddRange() en SaveChanges().
6. Schakel AutoDetectChanges uit voor bulkoperaties: context.Configuration.AutoDetectChangesEnabled = false;
7. Gebruik caching en paginering voor grote datasets.

25) Wat is een shadow property in Entity Framework Core?

Een shadow property bestaat in het EF-model maar niet in de entiteitsklasse. Het wordt beheerd door EF in de change tracker en opgeslagen in de database.

Voorbeeld:

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

Dit stelt EF in staat extra metadata op te slaan (bijv. timestamps, audit-info) zonder de entiteitsklasse te wijzigen.

U kunt shadow properties benaderen via:

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

Shadow properties zijn ideaal voor logging- of audit-scenario's.

26) Wat zijn value converters in EF Core?

Value converters in EF Core staan transformatie van eigenschapswaarden toe bij het lezen van of schrijven naar de database.

Bijvoorbeeld, om een enum als string op te slaan:

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

Dit verbetert flexibiliteit voor custom datatypes zoals enum, bool of DateTimeOffset.

Value converters worden ook gebruikt voor encryptie, compressie of masking van gevoelige data.

27) Wat zijn globale queryfilters en hoe werken ze?

Globale queryfilters staan toe om voorwaarden automatisch toe te passen op alle queries voor een entiteit.

Dit is met name nuttig voor soft deletes of multi-tenancy.

Voorbeeld:

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

Elke query die uitgevoerd wordt tegen Employee, sluit soft-deleted records automatisch uit, tenzij expliciet overschreven.

Globale filters verbeteren onderhoudbaarheid en databeveiliging.

28) Hoe kunt u Entity Framework-code testen met unit tests?

Om EF-logica te unit testen zonder een echte database te raken, gebruik in-memory databases of mocking:

• Optie 1: InMemory Provider

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

• Optie 2: Mock DbContext
  Mock DbSet met bibliotheken als Moq voor geïsoleerde testing.

Unit tests moeten valideren:

• Query-correctheid (via LINQ)
• Dataconsistentie na SaveChanges()
• Repository-logica

Testen met EF Core InMemory zorgt voor snelheid en vermijdt afhankelijkheden van SQL Server.

29) Leg de Repository- en Unit of Work-patronen in EF uit.

Deze twee architecturale patronen helpen data-toegang te abstracteren en transactionele consistentie te behouden.

Patroon	Doel	Implementatievoorbeeld
Repository	Inkapselt CRUD-operaties per entiteit.	IRepository<T> interface met Add(), GetAll(), etc.
Unit of Work	Coördineert meerdere repositories binnen een transactie.	SaveChanges() fungeert als commit-grens.

Voorbeeld:

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

Deze patronen verbeteren testbaarheid, herbruikbaarheid en scheiding van verantwoordelijkheden in grote enterprise-applicaties.

30) Wat is het verschil tussen eager loading en projection loading?

Aspect	Eager Loading	Projection Loading
Doel	Laadt gerelateerde data vooraf	Laadt alleen specifieke velden of eigenschappen
Methode	.Include()	.Select()
Voorbeeld	context.Orders.Include(o => o.Customer)	context.Orders.Select(o => new { o.Id, o.Customer.Name })
Prestaties	Haalt volledige objecten op	Haalt minimale data op
Use Case	Wanneer gerelateerde entiteiten nodig zijn voor verwerking	Wanneer u specifieke lightweight data nodig hebt

Projection loading is een prestatie-optimalisatie die geheugenoverhead vermindert door alleen benodigde kolommen te selecteren.

31) Wat zijn interceptors in Entity Framework Core?

Interceptors in EF Core staan ontwikkelaars toe om databaseoperaties zoals query-uitvoering, commando-creatie en verbindingsopenen af te vangen en te wijzigen.

Ze fungeren als middleware-componenten tussen EF en de databaseprovider.

Voorbeeld: Loggen van alle uitgevoerde SQL-commando's.

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

U registreert het in de DbContextOptionsBuilder:

optionsBuilder.AddInterceptors(new CommandInterceptor());

Voordelen:

• Verbeterde logging
• Beveiliging (query-validatie)
• Audit en prestatietracking

32) Hoe gaat EF Core om met asynchrone operaties?

Entity Framework Core ondersteunt asynchrone programmering volledig via methoden zoals SaveChangesAsync(), ToListAsync() en FirstOrDefaultAsync().

Asynchrone uitvoering helpt schaalbaarheid te verbeteren in webapplicaties door threads vrij te maken tijdens het wachten op I/O-gebonden databaseoperaties.

Voorbeeld:

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

Async-operaties zijn met name effectief in high-throughput ASP.NET Core APIs en microservices, wat blokkerende calls vermindert en responstijden verbetert.

33) Wat is connection resiliency in Entity Framework Core?

Connection resiliency helpt uw applicatie automatisch te herstellen van tranziente databasefouten, zoals netwerkintrusies of SQL-timeouts.

Het kan als volgt geconfigureerd worden:

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

Hier zal EF gefaalde operaties maximaal 5 keer herproberen met vertragingen.

Dit is met name nuttig in cloud-gehoste omgevingen zoals Azure SQL waar tranziente fouten gemeen zijn.

34) Wat zijn owned entity types in EF Core?

Owned entiteiten staan het modelleren van value objects toe die volledig afhankelijk zijn van een andere entiteit's levenscyclus.

Ze delen dezelfde tabel als hun owner en kunnen niet onafhankelijk bestaan.

Voorbeeld:

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

Configuratie:

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

Use Case:

Concepten modelleren als Address, Money of Measurement die geen eigen identiteit hebben.

35) Hoe kunt u soft deletes implementeren in Entity Framework Core?

Soft deletes markeren records als verwijderd in plaats van ze fysiek te verwijderen.

Ze worden geïmplementeerd met een boolean flag en globale queryfilters.

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

In de delete-operatie:

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

Voordelen:

• Historische databehoud
• Makkelijkere herstel

Nadelen:

• Grotere databasetabellen
• Vereist voorzichtige filterlogica

36) Wat is een gecompileerd model in EF Core en waarom wordt het gebruikt?

In EF Core 6+ staan gecompileerde modellen pre-compilatie van de EF-modelmetadata toe in een .NET-assembly, wat opstarttijd en runtime-overhead reduceert.

Stappen:

1. Voer het commando uit: dotnet ef dbcontext optimize
2. EF genereert een pre-compiled modelbestand dat de applicatie sneller laadt bij runtime.

Voordeel: Vermindert initialisatielatentie met 30–40%, met name in grote applicaties met veel entiteiten.

Use Case: High-performance microservices en serverless-omgevingen.

37) Hoe kunt u caching implementeren in Entity Framework?

Caching helpt herhalende databasequeries te verminderen. Er zijn twee hoofdniveaus:

Type	Beschrijving	Voorbeeld
First-level cache	Ingebouwd, per DbContext instantie	Automatisch beheerd
Second-level cache	Externe cache gedeeld over contexts	Bibliotheken als EFCoreSecondLevelCacheInterceptor

Voorbeeld voor second-level caching:

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

Dit verbetert prestaties aanzienlijk in read-heavy applicaties door redundante database-hits te vermijden.

38) Hoe beheert EF Core concurrency tokens en timestamps?

Concurrency tokens voorkomen conflicterende updates in multi-user-omgevingen.

U kunt een eigenschap markeren als concurrency-token met het [ConcurrencyCheck] of [Timestamp] attribuut.

Voorbeeld:

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

Bij een update voegt EF deze kolom toe aan de WHERE-clausule.

Als de waarde afwijkt, wordt een DbUpdateConcurrencyException gegooid — wat optimistische concurrency-controle waarborgt.

39) Hoe implementeert u auditing (created, modified, deleted tracking) in EF Core?

Auditing trackt metadata zoals wie aangemaakt, gewijzigd of verwijderd heeft.

U kunt SaveChanges() overschrijven:

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

Deze methode centraliseert audit-logica, wat consistente datagovernance waarborgt.

40) Wat zijn de best practices voor het gebruik van Entity Framework in enterprise-applicaties?

Categorie	Best Practice	Voordeel
Prestaties	Gebruik AsNoTracking() en projecties voor read-only queries.	Vermindert overhead.
Ontwerp	Implementeer Repository- en Unit of Work-patronen.	Verbetert onderhoudbaarheid.
Beveiliging	Gebruik geparameteriseerde queries om SQL-injectie te voorkomen.	Databescherming.
Schaalbaarheid	Gebruik connection pooling en async-methoden.	Handelt hoge load af.
Migraties	Gebruik geautomatiseerde migraties met versiebeheer.	Vereenvoudigt schemabeheer.
Configuratie	Externaliseer connection strings en secrets.	Betere omgevingsisolatie.
Testen	Gebruik InMemory-provider voor unit tests.	Snellere testruns.
Logging	Schakel EF-logging in voor prestatie-inzichten.	Makkelijker debuggen.

Deze praktijken waarborgen robuuste, schaalbare en onderhoudbare applicaties gebouwd op Entity Framework.

41) Hoe kunt u LINQ-queries optimaliseren voor betere SQL-vertaling in Entity Framework?

Entity Framework converteert LINQ-queries automatisch naar SQL, maar inefficiënte patronen kunnen trage of redundante SQL produceren. LINQ optimaliseren zorgt ervoor dat de ORM performante databasequeries genereert.

Optimalisatietechnieken:

Gebruik Projecties:

1. Selecteer alleen de vereiste kolommen in plaats van volledige entiteiten.

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

Vermijd Client-Side Evaluation:
Zorg er altijd voor dat filtering in SQL gebeurt, niet in het geheugen. EF Core waarschuwt wanneer evaluatie client-side is.

Gebruik AsNoTracking() voor read-only data.

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

Benut Gecompileerde Queries voor herhaalde LINQ-operaties.

Vermijd onnodige .Include() calls — include alleen gerelateerde data wanneer nodig.

Voorbeeld:

Inefficiënt:

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

Efficiënt:

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

42) Wat zijn de verschillende manieren om initiële data te seeden in EF Core?

Data seeding zorgt ervoor dat de database standaard- of referentiedata heeft wanneer aangemaakt.

Aanpak 1: ModelBuilder gebruiken

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

Dit voegt data automatisch toe tijdens Update-Database.

Aanpak 2: Custom Seed-methode

Voer code handmatig uit bij opstart:

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

Aanpak 3: SQL-scripts

Gebruik raw SQL in migraties:

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

Aanbeveling:
Gebruik HasData() voor statische referentiedata en programmatische seeding voor dynamische opstartdata.

43) Hoe beheert EF Core databaseproviders intern?

EF Core is provider-agnostisch, wat betekent dat het meerdere database-engines kan targeten via afzonderlijke databaseprovider-pakketten.

Veelvoorkomende Providers:

Provider	NuGet-pakket	Database
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

Intern gebruikt EF Core abstractielaag voor:

• Query-vertaling
• SQL-commando-generatie
• Datatype-mapping

Elke provider implementeert zijn eigen klassen die overerven van EF Core's basisabstracties (bijv. RelationalDatabaseProvider, QuerySqlGenerator).

44) Wat is een "split query" en wanneer moet u het gebruiken?

Split queries voorkomen dat EF grote, complexe joins uitvoert door meerdere SQL-queries uit te voeren in plaats van één.

Voorbeeld:

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

Dit voert uit:

1. Query 1 → Haal Customers op
2. Query 2 → Haal Orders op gerelateerd aan die customers

Voordelen:

• Voorkomt grote Cartesische producten.
• Verbetert prestaties bij grote gerelateerde datasets.

Nadeel:

Meerdere round-trips naar de database.

Gebruik split queries bij eager loading van grote gerelateerde data die geheugenproblemen kan veroorzaken.

45) Hoe kunt u EF-gegenereerde SQL-commando's effectief monitoren?

SQL monitoren helpt trage queries debuggen en ORM-gedrag optimaliseren.

Methoden om SQL te loggen:

1. Console Logging

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

ILoggerFactory Integratie

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

Interceptors
Implementeer DbCommandInterceptor om commando's en tijden vast te leggen.

Profiling Tools
Gebruik tools als:

• MiniProfiler
• SQL Server Profiler
• EFCorePowerTools

Logging moet selectief ingeschakeld worden in productie om prestatie-overhead te vermijden.

46) Wat is het verschil tussen ChangeTracker.DetectChanges() en AutoDetectChangesEnabled?

Kenmerk	DetectChanges()	AutoDetectChangesEnabled
Type	Methode	Eigenschap
Doel	Forceert EF getrackte entiteiten te scannen en wijzigingen te detecteren	In/uitschakelen van automatische wijzigingsdetectie
Standaard	Handmatig	True
Gebruik	Expliciet aanroepen voor prestatieoptimalisatie	Uitschakelen voor bulk-updates

Voorbeeld:

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

Automatische detectie uitschakelen in loops verbetert prestaties met tot 40% bij bulkoperaties.

47) Hoe gebruikt u temporale tabellen met EF Core?

Temporale tabellen (geïntroduceerd in SQL Server 2016) staan toe om historische data automatisch te tracken.

Stappen:

1. Temporal support inschakelen in migratie:

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

Historische data opvragen:

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

Voordelen:

• Ingebouwd data-geschiedenistracking
• Audit en compliance
• Geen handmatige triggers nodig

EF Core 6+ ondersteunt volledige temporale querying.

48) Hoe ondersteunt EF Core gecompileerde queries en pre-generated models samen?

Gecompileerde queries en gecompileerde modellen zijn twee prestatiefuncties die elkaar complementeren.

Functie	Doel
Gecompileerde Queries	Cache query-vertalingresultaten
Gecompileerde Modellen	Pre-compileer modelmetadata

Voorbeeld van Gecompileerde Query:

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

Gebruik:

var customer = _getCustomerById(context, 5);

Samen: Gecompileerde modellen verminderen opstartkosten, terwijl gecompileerde queries runtime query-overhead verminderen — ideaal voor high-frequency queries.

49) Wat zijn veelvoorkomende valkuilen bij het gebruik van EF in microservices-architectuur?

Veelvoorkomende Fouten:

1. Gedeelde DbContext Over Services
   → Schendt microservice-isolatie.
   → Elke microservice moet een eigen DbContext en schema hebben.
2. Praterige Communicatie (N+1 Queries)
   → Minimaliseer EF-queries per API-call.
3. Overmatige Eager Loading
   → Laad alleen wat nodig is via DTOs.
4. Gecentraliseerde Migraties
   → Elke service moet eigen migraties onafhankelijk beheren.
5. Gebrek aan Transactionele Grenzen
   → Gebruik gedistribueerde transacties (Outbox-patroon) als cross-service consistentie vereist is.
6. Strakke Koppeling aan SQL-provider
   → Gebruik repository-abstraktie om flexibiliteit in databasekeuze te behouden.

50) Hoe integreert dependency injection met DbContext in ASP.NET Core?

Entity Framework integreert naadloos met ASP.NET Core's ingebouwde Dependency Injection (DI) systeem.

Setup:

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

Injecteer het vervolgens in controllers of services:

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

Lifetimes:

Lifetime	Beschrijving	Aanbevolen voor
Scoped	Eén context per HTTP-request	Standaard
Transient	Nieuwe instantie elke keer	Background jobs
Singleton	Wereldwijd gedeeld	Vermijden (niet thread-safe)

DI gebruik waarborgt testbaarheid, levenscyclusbeheer en resource-efficiëntie over web- en achtergrondprocessen.

🔍 Top Entity Framework-interviewvragen met real-world scenario's & strategische antwoorden

1) Wat is Entity Framework, en waarom wordt het in enterprise-applicaties gebruikt?

Verwacht van kandidaat: De interviewer wil uw fundamentele begrip van Entity Framework en de waarde ervan in real-world applicaties beoordelen.

Voorbeeldantwoord: Entity Framework is een Object-Relational Mapping framework voor .NET dat ontwikkelaars toestaat met databases te werken met .NET-objecten in plaats van raw SQL. Het wordt in enterprise-applicaties gebruikt om productiviteit te verbeteren, boilerplate data-toegangs-code te reduceren en een sterke scheiding van verantwoordelijkheden te behouden.

2) Kunt u het verschil uitleggen tussen Code First, Database First en Model First benaderingen?

Verwacht van kandidaat: De interviewer wil uw kennis van verschillende ontwikkelworkflows en wanneer u elk gebruikt evalueren.

Voorbeeldantwoord: Code First begint met domeinklassen en genereert de database vanuit code. Database First begint met een bestaande database en genereert entiteitsklassen. Model First gebruikt een visuele designer om het model te definiëren en creëert dan zowel code als database. Elke benadering wordt gekozen op basis van projectvereisten en bestaande infrastructuur.

3) Hoe gaat Entity Framework om met relaties tussen tabellen?

Verwacht van kandidaat: De interviewer controleert uw begrip van datamodellering en relationele mapping.

Voorbeeldantwoord: Entity Framework handelt relaties af met navigatie-eigenschappen en foreign keys. Het ondersteunt one-to-one, one-to-many en many-to-many relaties, waardoor ontwikkelaars gerelateerde data kunnen doorlopen met objectreferenties in plaats van joins.

4) Beschrijf een situatie waarin u databaseprestaties verbeterde met Entity Framework.

Verwacht van kandidaat: De interviewer wil een praktisch voorbeeld horen dat optimalisatievaardigheden demonstreert.

Voorbeeldantwoord: In mijn vorige rol verbeterde ik prestaties door onnodige eager loading te reduceren en projectiequeries met Select-statements te implementeren. Dit minimaliseerde de hoeveelheid data opgehaald uit de database en verminderde query-uitvoeringstijd aanzienlijk.

5) Hoe beheert u migraties in Entity Framework?

Verwacht van kandidaat: De interviewer beoordeelt uw ervaring met schemavergelijkingen en versiebeheer.

Voorbeeldantwoord: Migraties worden beheerd met de ingebouwde migratietools die modelwijzigingen over tijd tracken. Op een eerdere positie genereerde en reviewde ik regelmatig migratiescripts voordat ik ze toepaste om database-integriteit over omgevingen te waarborgen.

6) Wat is lazy loading, en wanneer zou u het vermijden?

Verwacht van kandidaat: De interviewer wil uw begrip van data-ladingstrategieën en prestatie-afwegingen testen.

Voorbeeldantwoord: Lazy loading laadt gerelateerde data automatisch wanneer deze wordt benaderd. Ik zou het vermijden in prestatie-kritische scenario's of API's omdat het meerdere onbedoelde databasecalls kan veroorzaken, wat leidt tot het N+1 query-probleem.

7) Hoe gaat u om met transacties in Entity Framework?

Verwacht van kandidaat: De interviewer evalueert uw kennis van dataconsistentie en foutafhandeling.

Voorbeeldantwoord: Entity Framework ondersteunt transacties via DbContext en TransactionScope. In mijn vorige baan gebruikte ik expliciete transacties om ervoor te zorgen dat meerdere gerelateerde databaseoperaties of allemaal met succes voltooid werden of teruggedraaid werden bij falen.

8) Leg uit hoe dependency injection gebruikt wordt met Entity Framework.

Verwacht van kandidaat: De interviewer wil zien hoe goed u moderne applicatie-architectuur begrijpt.

Voorbeeldantwoord: Dependency injection wordt gebruikt om de DbContext in services of controllers te injecteren. Dit verbetert testbaarheid en onderhoudbaarheid door de context te laten mocken of vervangen zonder bedrijfslogica te wijzigen.

9) Beschrijf een uitdagende bug die u tegenkwam met Entity Framework en hoe u het oploste.

Verwacht van kandidaat: De interviewer zoekt probleemoplossend vermogen en debug-skills.

Voorbeeldantwoord: In mijn laatste rol liep ik een issue tegen met tracking-conflicten bij het updaten van detached entiteiten. Ik loste het op door entiteitsstatussen expliciet in te stellen en ervoor te zorgen dat slechts één instantie van elke entiteit getracked werd door de context.

10) Hoe besluit u wanneer Entity Framework niet het juiste hulpmiddel is?

Verwacht van kandidaat: De interviewer wil uw oordeelsvorming en vermogen om passende technologieën te kiezen begrijpen.

Voorbeeldantwoord: Ik overweeg alternatieven wanneer applicaties extreem hoge prestaties voor data-toegang vereisen of complexe stored procedure-logica. In dergelijke gevallen kan het gebruik van een micro-ORM of raw ADO.NET meer controle en efficiëntie bieden.