Entity Framework Core interview questions covering fundamentals, ORM concepts, DbContext, DbSet, configuration, conventions, migrations and basic tracking.
Open a question for the full answer, code and interview guidance.
Entity Framework Core is Microsoft's modern object-relational mapper (ORM) for .NET. It allows .NET applications to work with relational databases primarily through .NET objects, LINQ queries, and a DbContext instead of manually writing all SQL and data-mapping code.
An ORM, or Object-Relational Mapper, maps application objects to relational database structures. It reduces repetitive code for reading rows, converting them into objects, tracking changes, and generating INSERT, UPDATE, DELETE, and SELECT operations.
DbContext is the central EF Core class that represents a session with the database. It exposes entity sets, tracks entity changes, translates LINQ queries, coordinates database operations, and saves changes.
DbSet<TEntity> represents a collection of entities of a particular type that EF Core can query and persist. It is commonly exposed as a property on DbContext.
The usual approach is to register the context with AddDbContext in Program.cs and configure a database provider and connection string.
DbContextOptions contains configuration used to construct a DbContext. It can describe the database provider, connection information, logging behavior, interceptors, query settings, and other EF Core options.
An entity is a .NET object type that EF Core includes in its model and can map to database data. A typical entity has scalar properties, a primary key, and optional navigation properties describing relationships.
By convention, EF Core recognizes a property named Id or <EntityName>Id as the primary key for many common entity types.
Conventions are default rules EF Core uses to build its model when explicit configuration is not provided. They cover areas such as primary keys, relationships, property mapping, and table/entity discovery.
Data annotations are attributes placed on entity classes or properties to configure validation or aspects of EF Core mapping. Common examples include Key, Required, MaxLength, Column, Table, and NotMapped.
The Fluent API configures the EF Core model through ModelBuilder, usually inside OnModelCreating or IEntityTypeConfiguration classes.
OnModelCreating is a DbContext method that can be overridden to configure the EF Core model with ModelBuilder.
IEntityTypeConfiguration<TEntity> allows the mapping for one entity type to be placed in a dedicated configuration class.
A migration is a versioned description of changes needed to move a database schema from one model state to another.
Add-Migration compares the current EF Core model with the previous model snapshot and creates migration code describing the detected schema changes. It does not normally apply those changes to the database.
The model snapshot is a C# representation of the model state associated with the latest migration. EF Core uses it when generating a new migration to determine what changed.
Change tracking is the mechanism EF Core uses to remember entity instances and their states so it can determine what database commands are required when SaveChanges is called.
EntityState describes how a tracked entity relates to the database.
SaveChanges examines tracked entity states and sends the required INSERT, UPDATE, and DELETE commands to the database. If successful, EF Core updates tracking state to reflect the persisted changes.
Add begins tracking an entity as Added, so EF Core normally inserts it when SaveChanges is called.
AsNoTracking tells EF Core not to place query results into the change tracker. It is useful for read-only queries where the returned entities will not be modified and saved through the same context.
LINQ allows developers to express database queries using strongly typed C# expressions. EF Core examines the expression tree and translates supported parts into SQL for the configured relational provider.
Many LINQ operators build an IQueryable expression without immediately sending a query to the database. The SQL is executed when the query is materialized or otherwise enumerated.
IQueryable represents a query expression that a provider such as EF Core can translate and execute against the database. Filtering, projection, ordering, and pagination added while the query remains IQueryable can therefore be translated into SQL.
Keep DbContext short-lived and normally scoped to one request or unit of work. Do not share one context concurrently between threads, and do not store it in a singleton service.