roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for EF Core interviews on what happens between your LINQ and the database: how queries become SQL and how changes get saved. Covers modeling, loading, concurrency, migrations and tuning.
273 of 273 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 273 new. 0 cut, outside your plan.
EF Core seldom gets a round to itself. It turns up inside the data-access part of a .NET backend loop: in a take-home where a small API has to persist something, in a code-review exercise, and in the follow-up questions once the coding is done. The usual move is to put a few lines of LINQ on the screen and ask what SQL they send, how many times, and what the context is holding afterwards. The examples recur: a `Where` written after `AsEnumerable()` that pulls a whole table into memory; two collection `Include` calls whose joined rows multiply until the query is split; a client-edited entity handed to `Update`, which marks every column modified; a retrying execution strategy that refuses a transaction you opened yourself. The defaults are the entry ticket: that `SaveChanges` wraps its statements in a transaction unless one is already open, what `AsNoTracking` gives up, why a `DbContext` must not be used by two threads at once. Past that, the questions arrive as reports from production, and the grade depends on tracing each one to its cause. Two editors overwrite each other without an error: the entity has no concurrency token. A list page sends one query per row: a lazy navigation is being read inside a loop. A migration would drop a column someone only renamed: the generator cannot tell a rename from a drop and an add, so the file has to be edited before it ships.
The plan opens on [LINQ](/topics/lang-csharp-linq) before any EF Core type appears, because the line between `IEnumerable` and `IQueryable` decides whether a filter becomes SQL or runs in memory, and nearly every query question later turns on it. After that, each stretch puts an idea that holds for any object-relational mapper in front of the way EF Core implements it. [Mapping](/topics/be-orm-concepts-mapping) explains how classes, keys and associations become tables and columns; [the EF Core model](/topics/be-ef-core-dbcontext-modeling) then shows the conventions, fluent configuration and inheritance strategies that produce them. The query stretch starts with where queries should live, behind a [repository boundary](/topics/be-orm-concepts-querying-repository-boundary) or inline, moves through projections and hand-written statements, and sets [SQL injection](/topics/found-appsec-sql-injection) directly before [EF Core's query topics](/topics/be-ef-core-linq-queries), where `FromSql` and `FromSqlRaw` differ in exactly that respect. Related data follows because loading is a query problem with a graph attached. The neutral topics on fetch plans and deferred reads, ending with the [row multiplication](/topics/be-orm-concepts-loading-collection-fetch-multiplication) a joined collection causes, prepare for [navigations and `Include`](/topics/be-ef-core-relationships-loading). The write side comes once reads are settled. [Unit of work mechanics](/topics/be-orm-concepts-unit-of-work), optimistic versioning and the rules for retrying a failed unit lead into [change tracking](/topics/be-ef-core-change-tracking), where entity states, `SaveChanges`, transactions and concurrency tokens meet. Schema change is placed late on purpose: [migrations as a practice](/topics/be-orm-concepts-migrations), with the questions of where they run and how a backfill ships, comes before [EF Core's own workflow](/topics/be-ef-core-migrations) from `dotnet ef` to bundles. The plan ends on cost, with [N+1 diagnosis](/topics/be-orm-concepts-n-plus-one) ahead of [tuning and provider differences](/topics/be-ef-core-performance), both of which assume everything above them.
If EF Core is one line in a .NET job description, narrow level to the range the posting hires at, raise importance to must know and drill in the order the page starts with, by frequency; querying and change tracking pay back that time first. If the role owns a data-heavy service, switch study order to by topics and go top to bottom, since every EF Core topic leans on the neutral one placed before it. Developers who already know Hibernate or another mapper can move quickly through the neutral topics and spend their hours on where EF Core differs: nothing is flushed before a query runs, lazy loading stays off until you opt in, and `ExecuteUpdate` writes straight to the database without passing through the change tracker. The plan stops at the context. Registering a `DbContext` per request, the middleware around it and the lifetimes of everything it is injected into belong to the [ASP.NET Core roadmap](/roadmaps/aspnet-core), where EF Core is one module of the framework. Isolation levels, execution plans and the SQL the database actually runs are taught on the [SQL roadmap](/roadmaps/sql).
EF Core seldom gets a round to itself. It turns up inside the data-access part of a .NET backend loop: in a take-home where a small API has to persist something, in a code-review exercise, and in the follow-up questions once the coding is done. The usual move is to put a few lines of LINQ on the screen and ask what SQL they send, how many times, and what the context is holding afterwards. The examples recur: a Where written after AsEnumerable() that pulls a whole table into memory; two collection Include calls whose joined rows multiply until the query is split; a client-edited entity handed to Update, which marks every column modified; a retrying execution strategy that refuses a transaction you opened yourself.
The defaults are the entry ticket: that SaveChanges wraps its statements in a transaction unless one is already open, what AsNoTracking gives up, why a DbContext must not be used by two threads at once. Past that, the questions arrive as reports from production, and the grade depends on tracing each one to its cause. Two editors overwrite each other without an error: the entity has no concurrency token. A list page sends one query per row: a lazy navigation is being read inside a loop. A migration would drop a column someone only renamed: the generator cannot tell a rename from a drop and an add, so the file has to be edited before it ships.
The plan opens on LINQ before any EF Core type appears, because the line between IEnumerable and IQueryable decides whether a filter becomes SQL or runs in memory, and nearly every query question later turns on it.
After that, each stretch puts an idea that holds for any object-relational mapper in front of the way EF Core implements it. Mapping explains how classes, keys and associations become tables and columns; the EF Core model then shows the conventions, fluent configuration and inheritance strategies that produce them. The query stretch starts with where queries should live, behind a repository boundary or inline, moves through projections and hand-written statements, and sets SQL injection directly before EF Core's query topics, where FromSql and FromSqlRaw differ in exactly that respect.
Related data follows because loading is a query problem with a graph attached. The neutral topics on fetch plans and deferred reads, ending with the row multiplication a joined collection causes, prepare for navigations and Include.
The write side comes once reads are settled. Unit of work mechanics, optimistic versioning and the rules for retrying a failed unit lead into change tracking, where entity states, SaveChanges, transactions and concurrency tokens meet. Schema change is placed late on purpose: migrations as a practice, with the questions of where they run and how a backfill ships, comes before EF Core's own workflow from dotnet ef to bundles. The plan ends on cost, with N+1 diagnosis ahead of tuning and provider differences, both of which assume everything above them.
If EF Core is one line in a .NET job description, narrow level to the range the posting hires at, raise importance to must know and drill in the order the page starts with, by frequency; querying and change tracking pay back that time first. If the role owns a data-heavy service, switch study order to by topics and go top to bottom, since every EF Core topic leans on the neutral one placed before it. Developers who already know Hibernate or another mapper can move quickly through the neutral topics and spend their hours on where EF Core differs: nothing is flushed before a query runs, lazy loading stays off until you opt in, and ExecuteUpdate writes straight to the database without passing through the change tracker.
The plan stops at the context. Registering a DbContext per request, the middleware around it and the lifetimes of everything it is injected into belong to the ASP.NET Core roadmap, where EF Core is one module of the framework. Isolation levels, execution plans and the SQL the database actually runs are taught on the SQL roadmap.