EF Core and SQL Server Articles

Introduction

This page is the article map for EF Core on ASP.NET Core. Open the symptom-specific post for deep answers — this index does not replace them.

You want…	Open
Performance checklist	EF Core SQL performance
N+1 / Include / AsSplitQuery	N+1 guide
Cartesian explosion	Two collection Includes
Relationships 1-1 / 1-n / n-n	EF relationships
AsNoTracking identity	AsNoTracking
Parameter sniffing	Parameter sniffing
Migrations in production	EF Core migrations
Audit log interceptors	SaveChanges interceptors
Value conversions / enums	Value conversions
Bulk update / ExecuteUpdate	Bulk update
Optimistic concurrency	Concurrency tokens
Soft delete / global filters	Global query filters
Specification pattern	Specification pattern
IEnumerable vs IQueryable	IEnumerable vs IQueryable
Deadlocks / RCSI	Deadlocks and snapshot isolation
TempDB contention	TempDB contention
Interview scenarios	EF Core interview questions

Mental model (one minute)

EF Core translates LINQ to SQL, tracks entities in a scoped DbContext, and materializes results. Most production pain falls into three categories:

Query shape problems: Too many round-trips (N+1), too many rows returned (missing filter, no paging), too many columns (SELECT * where a projection suffices). Start with the performance checklist.

Concurrency problems: Two requests updating the same row without a concurrency token cause silent last-write-wins data loss. Reader/writer deadlocks under load are usually fixed by enabling RCSI at the database level. See optimistic concurrency and deadlocks.

Schema evolution problems: Database.Migrate() on startup races when multiple pods boot simultaneously. A non-nullable column with a default can lock a table for minutes. The expand-and-contract pattern avoids downtime. See migrations in production.

The LINQ trap

The most common EF Core mistake is declaring a repository return type as IEnumerable<T> when the underlying query is IQueryable<T>. The caller adds .OrderBy(id).Take(20) — those operators run in memory, after loading every row. The fix is to keep IQueryable<T> until you have applied all filters and paging, then materialize once with ToListAsync.

See IEnumerable vs IQueryable and LINQ interview questions for the full set of patterns interviewers probe.

Key rules

• Change tracker is scoped. Use one DbContext per request. Never share across threads.
• AsNoTracking for read-only queries. Removes change tracking overhead. Does not reduce SQL round-trips.
• ExecuteUpdateAsync bypasses interceptors. If your audit trail uses ISaveChangesInterceptor, bulk updates via ExecuteUpdate will not be stamped — set the audit columns in SetProperty explicitly.
• Migrations are SQL. Review the generated Up() method. Rename = drop + add unless you edit the migration. Non-nullable column with default = potential table lock on large tables.
• TempDB is shared. Sorts, hash joins, RCSI versioning, and temp tables all write to TempDB. One undivided TempDB file under heavy concurrent load produces PAGELATCH_UP waits — the API hangs while CPU looks idle.

What to read next

Diagnosing a slow query? Start with SQL performance. Debugging a deadlock? Read deadlocks and snapshot isolation. Preparing for an interview? Go to EF Core interview questions, then LINQ interview questions.

For the broader .NET architecture picture — where EF Core fits into Clean Architecture and CQRS — see the architecture hub.