Entity Framework Core Interview Questions

🎯 Focus Areas

DbContext lifecycle, migrations, Code First, relationships, N+1 problem, EF Core vs Dapper. Critical for any .NET data access role.

---

Q1: What is Entity Framework Core?

ORM (Object-Relational Mapper) — maps C# classes to database tables.
Write C# objects instead of SQL. EF Core generates the SQL.

DbContext → database connection + unit of work
DbSet<T>  → table representation

builder.Services.AddDbContext<SchoolDb>(o =>
    o.UseSqlServer(connectionString));

Q2: What is Code First approach?

Define C# classes (entities) → EF Core creates database schema.
Opposite: Database First → generate C# classes from existing database.

Code First flow:
  1. Create entity classes (Student, Teacher)
  2. Create DbContext with DbSet properties
  3. dotnet ef migrations add InitialCreate
  4. dotnet ef database update
  → Database and tables created automatically

Q3: What is a Migration?

# Create migration (snapshot of model changes)
dotnet ef migrations add AddStudentEmail

# Apply to database
dotnet ef database update

# Rollback
dotnet ef database update PreviousMigrationName

# Remove last migration (if not applied)
dotnet ef migrations remove

Q4: What is the difference between eager, lazy, and explicit loading?

// Eager loading — load related data immediately with Include
var students = await db.Students
    .Include(s => s.ExamMarks)           // load in same query
    .Include(s => s.FeeAccount)
    .ToListAsync();

// Lazy loading — load related data on demand (requires proxies, virtual nav props)
// student.ExamMarks accessed → triggers another SQL query automatically

// Explicit loading — manually load when needed
var student = await db.Students.FindAsync(id);
await db.Entry(student).Collection(s => s.ExamMarks).LoadAsync();

Q5: What is the N+1 query problem?

// BAD — N+1 problem: 1 query for students + 1 query per student for marks
var students = await db.Students.ToListAsync();
foreach (var student in students)
{
    Console.WriteLine(student.ExamMarks.Count);  // triggers separate query each time!
}
// 1 + N queries for N students

// GOOD — 1 query with Join
var students = await db.Students
    .Include(s => s.ExamMarks)
    .ToListAsync();
// 1-2 queries total

Q6: What is DbContext lifecycle? What is Scoped lifetime?

DbContext should be Scoped (one per HTTP request).
Never Singleton — DbContext is not thread-safe.
Never Transient — too much overhead.

builder.Services.AddDbContext<SchoolDb>(o => ...);
// AddDbContext registers as Scoped automatically

Reason: Each request needs its own unit of work (change tracker, connection).

Q7: What is AsNoTracking?

// Default — EF Core tracks all loaded entities (change tracking overhead)
var students = await db.Students.ToListAsync();

// AsNoTracking — no tracking, faster for read-only queries
var students = await db.Students.AsNoTracking().ToListAsync();

// Use AsNoTracking for:
// - Read-only GET endpoints
// - Reports, exports
// - Any query where you don't need to update the entity

Q8: What is the difference between EF Core and Dapper?

EF Core:
  + Full ORM — handles relationships, migrations, change tracking
  + Less code for CRUD operations
  + Code First — define schema in C#
  - Slower for complex queries
  - Generated SQL sometimes not optimal
  Use for: standard CRUD, relationships, new projects

Dapper:
  + Micro ORM — raw SQL with C# object mapping
  + Very fast (close to raw ADO.NET)
  + Full SQL control
  - No migrations, no change tracking
  - More code for relationships
  Use for: complex reports, performance-critical queries, existing DB

Real-world: Use BOTH in same project — EF Core for CRUD, Dapper for complex queries.

Q9: What is Fluent API vs Data Annotations?

// Data Annotations — attributes on entity class
public class Student
{
    [Key]
    public int Id { get; set; }
    [Required, MaxLength(100)]
    public string Name { get; set; } = "";
    [Column("class_name")]
    public string ClassName { get; set; } = "";
}

// Fluent API — in OnModelCreating (more powerful, separates config from model)
protected override void OnModelCreating(ModelBuilder mb)
{
    mb.Entity<Student>(e => {
        e.HasKey(s => s.Id);
        e.Property(s => s.Name).IsRequired().HasMaxLength(100);
        e.Property(s => s.ClassName).HasColumnName("class_name");
    });
}

Q10: What is SaveChanges and when does it send SQL?

💻 Try It — Console App

💡 Paste into Program.cs and press F5⌥ GitHub

// No SQL sent yet — just tracked in memory
db.Students.Add(new Student { Name = "Ravi" });
db.Students.Add(new Student { Name = "Priya" });
student.Percentage = 90;

// SQL sent NOW — all changes in one transaction
await db.SaveChangesAsync();
// Executes: INSERT, INSERT, UPDATE in one DB call

💡 Top EF Core Interview Topics

1. N+1 problem — explain and fix with Include
2. AsNoTracking — when and why
3. EF Core vs Dapper — honest comparison
4. DbContext lifetime — always Scoped
5. Code First migrations — explain the flow

🤖Use AI to Learn Faster

Use ChatGPT, Claude, or Copilot to go deeper on Entity Framework Core interview questions. Try these prompts:

• "Ask me 10 EF Core interview questions and evaluate my answers"
• "Explain the N+1 query problem in EF Core with a School Management example"
• "When would you use Dapper instead of EF Core? Ask me this interview question"
• "Quiz me on EF Core migrations — ask a scenario-based question"

💡 Tip: After reading this article, paste your own code into AI and ask "What could go wrong here and why?" — fastest way to find edge cases and deepen understanding.