EF Core 11 cheat sheet

A SET statement run once is wiped by DISCARD ALL the moment Npgsql returns the connection to its pool. Put search_path and statement_timeout in the startup packet with the Search Path and Options connection string keywords, fall back to ALTER ROLE or a ConnectionOpened interceptor, and know why UsePhysicalConnectionInitializer silently loses its SET.

EF.Constant inlines a captured value as a SQL literal, EF.Parameter turns a literal into a SQL parameter. Keep EF Core's defaults, use EF.Parameter to stop dynamically built expression trees from recompiling on every call, and use EF.Constant only for a value with a handful of distinct values whose data is skewed enough to need its own plan.

EF Core 8, 9 and 10 fail to translate Contains when the list is a static readonly field typed as IList, ICollection, ISet or IReadOnlySet. Call Enumerable.Contains explicitly, or upgrade to EF Core 11.

HasIndex(...).IsUnique() on a ToJson() member does not enforce uniqueness in EF Core 11 RC 1: SQL Server drops IsUnique and SQLite indexes the whole document. Expose the JSON value as a computed column and put the unique index on that instead.

Loading an entity, calling List.Add, and saving rewrites the whole jsonb document and silently loses concurrent appends. Push the append into one UPDATE with the jsonb || operator, either through ExecuteSqlAsync or a mapped function inside ExecuteUpdateAsync, and make it idempotent with a @> guard.

Map an EF Core key to an Oracle sequence with UseSequence in Oracle.EntityFrameworkCore 10: the DDL and INSERT SQL the provider really emits, how to point at an existing sequence or a legacy trigger, why quoting and HiLo trip people up, and how to move an identity column onto a sequence without ORA-00001.

A table named Gas scaffolds to an entity called Ga. Replace the built-in Humanizer pluralizer with your own IPluralizer, register it through IDesignTimeServices in the startup project, and learn why TryAddSingleton silently does nothing there.

There is no transaction that spans SQL Server and Blob Storage. Upload to a name the database already knows about, commit second, compensate on failure, and let a sweeper clean up the crash window. With the UploadAsync overload that silently turns a conditional create into an overwrite.

The existence check in your handler is not the guard you think it is. Put a unique index on the inbox table, write the marker in the same SaveChanges as the business change, and let the database pick the winner. Plus the ExecuteUpdate trap that quietly undoes all of it.

Rename every PK_, FK_, AK_ and IX_ that EF Core 11 generates with one IModelFinalizingConvention, keep explicit names winning, stay under the identifier length limit, and avoid the clustered-index rebuild the next migration scaffolds on an existing database.

EF Core 11 stops escaping '/', '\', '?' and '#' in generated Cosmos DB id values, so documents written by EF Core 8-10 stop resolving by key. How to find out if you are affected, when to set the EscapeIllegalCosmosIdCharacters switch, and how to rewrite the ids safely with a transactional batch.

EF Core 11 now defaults UseSqlServer to compatibility level 160, which puts LEAST, GREATEST and two-argument LTRIM/RTRIM into your SQL, including every Take(n).FirstOrDefault(). Keep 160 on SQL Server 2022 and later; pin UseCompatibilityLevel(150) if any environment still runs SQL Server 2019.

EF Core's SQL Server existence check retries error 18456 for a full minute, with or without EnableRetryOnFailure. Fail fast, cap RetryTimeout, or wait for EF Core 12.

EF Core 11 is compiled against Microsoft.Data.SqlClient 7.0.0.0, but a 6.x copy won the restore or the deploy. Remove the old SqlClient pin and redeploy the full output.

EF Core throws this when a Select reads a SQL NULL into a non-nullable int, decimal or DateTime. Cast the member to its nullable type and add ?? default, or guard the navigation with a null check.

StartsWith, EndsWith and Contains already escape % and _ for you in EF Core 11, but EF.Functions.Like does not. Here is the SQL EF generates, a reusable escape helper, and the escapeCharacter overload that makes it work on SQL Server, SQLite and PostgreSQL.

Use the native json type on SQL Server 2025 and Azure SQL: EF Core 11 gets JSON_CONTAINS, typed JSON_VALUE, in-place modify() and JSON indexes out of it. Stay on nvarchar(max) for SQL Server 2019/2022, legacy tooling, or a schema you must be able to roll back.

EF Core's build-time model generation re-entered MSBuild until RAM ran out. Upgrade Tasks and Design to 10.0.10+, and on EF Core 11 delete EFOptimizeContext.

EF Core emits [col] json '$.path' AS JSON inside OPENJSON WITH, which Azure SQL rejects with Msg 13618. Upgrade to EF Core 10.0.11+, or drop the provider compatibility level to 160.

Upgrade Microsoft.EntityFrameworkCore to 10.0.10 or later. Before that, growing a nested collection under a second ToJson complex property crashed SaveChanges.

On EF Core 10.0.x, nulling a complex property that holds a two-element collection inside a ToJson complex collection breaks DetectChanges. Fixed in 11.0.0-rc.1.

dotnet ef throws MissingMethodException on ArgumentIsEmpty because Tools 10.0.6 stopped pulling a matching Microsoft.EntityFrameworkCore.Design. Pin Design explicitly to your EF Core version.

EF Core 11 still has no lock API. Here is how to take a real row lock with FromSql: WITH (UPDLOCK, ROWLOCK) on SQL Server, FOR UPDATE on PostgreSQL, the subquery trap that silently widens the lock, NOWAIT and SKIP LOCKED, deadlock retries, and what to do when the row does not exist yet.

EF Core never passes null to a value converter by default. Here is the internal convertsNulls constructor that changes that, the IsRequired(false) call it depends on, why it cannot work at all for enums and other value types, the WHERE col = NULL trap it creates, and the two patterns that do the job without an internal API.

An EF Core interceptor is a class EF calls before and after operations like executing a command or SaveChanges, and it can modify or suppress them, not just observe. Here are the seven interception points in EF Core 11, the registration and lifetime rules, and the cases where a query filter or plain logging is the better answer.

The check-then-insert in your handler is not atomic. Catch PostgresException with SqlState 23505, or collapse the whole thing into one INSERT ... ON CONFLICT statement. EnableRetryOnFailure will not help.

EF Core's Migrate() always checks whether the database exists and creates it if not, from a hardcoded master connection. Grant CREATE ANY DATABASE, fix the login's access to the existing database, or ship an idempotent SQL script instead.

iOS builds set DynamicCodeSupport=false, so EF Core refuses to build the model even though you never enabled NativeAOT. Ship a compiled model plus precompiled queries, or turn the interpreter back on.

A bool helper method throws "could not be translated". An Expression<Func<T, bool>> does not. Here is how to compose, nest, and reuse expression trees in EF Core 11 without LINQKit, with the real SQL for every case.

EF Core throws this when a client-evaluated piece of your query throws while EF evaluates it. Read InnerException, turn on EnableSensitiveDataLogging, and move the null check outside the lambda.

Move a key off IDENTITY and onto a SQL Server sequence in EF Core 11 with UseSequence: the exact SQL EF emits, why explicit key values suddenly work without IDENTITY_INSERT, the bigint sequence feeding an int column, and the gaps you have to design around.

A singleton cannot inject a DbContext, but it can inject IDbContextFactory<T>, because AddDbContextFactory registers the factory as a singleton by default. Create and dispose one context per call, never cache the instance.

Every way dotnet tool install --global dotnet-ef fails on the .NET 10 SDK, with the exact message and exit code for each: already installed, version not found, downgrade blocked, shim conflict, dead NuGet feed, and the runtime mismatch that only breaks after the install succeeds.

Use FromSql on a DbSet when the procedure returns full entity rows, Database.SqlQuery<T> when it returns a projection, and ExecuteSql when it returns nothing. Never chain a LINQ operator onto an EXEC, and never read an output parameter before the reader is disposed.

EF Core scaffolds RenameTable when you change the table name, but DropTable plus CreateTable when you rename the entity class. Here is how to tell the two apart, the ToTable trick that makes a class rename free, and the column-rename bug that silently swaps your data.

They are not alternatives. WebApplicationFactory boots your app, Testcontainers boots your dependencies. Measured on .NET SDK 10.0.201: a container fixture costs 1.7 s per class against 10 ms for SQLite, and a HasMaxLength(16) violation that Postgres rejects with 22001 is silently accepted by SQLite.

Add a rowversion concurrency token in EF Core 11: the [Timestamp] and IsRowVersion setup, the SQL EF actually emits, catching DbUpdateConcurrencyException, store-wins vs client-wins vs merge, disconnected APIs with ETags, and the five traps that silently disable the whole thing.

Store C# enums as readable strings instead of ints in EF Core 11: HasConversion, bulk configuration for every enum, the nvarchar(max) trap, the ordering gotcha, and how to migrate an existing int column.

Add Microsoft.EntityFrameworkCore.Design to the startup project that dotnet ef builds, not the project holding your DbContext, and pass -s in layered solutions.

EF Core throws PendingModelChangesWarning when your model no longer matches the last migration snapshot. Add the migration, or fix the false positive behind it.

A complete guide to deploying EF Core 11 schema changes with migration bundles: building efbundle in CI, the appsettings.json trap with named connection strings, self-contained bundles and the Alpine musl RID, migration locking since EF Core 9, rolling back with a target migration, and why per-migration transactions do not save you on MySQL.

On EF Core 11, default to complex types for value objects and drop to owned entities only when you need a separate table or a collection mapped to its own rows.

On EF Core 11, default to TPH for almost every hierarchy, reach for TPC only when you mostly query one leaf type and a benchmark proves it wins, and use TPT only when an external constraint forces you to.

This exception means you called .First() or .Single() on an empty sequence. Use FirstOrDefault/SingleOrDefault and null-check, or guard the query, or fix why the source is empty.

See the exact SQL Entity Framework Core 11 sends to your database, with parameter values, using LogTo, Microsoft.Extensions.Logging, and ToQueryString.

EF Core hit a property it does not know how to store. Map it as a complex type, convert it with HasConversion, give it a key, or ignore it with [NotMapped].

TPH is EF Core's default inheritance strategy: one table, one discriminator column. Here is how to configure the discriminator, share columns, handle nullable derived properties, and the gotchas on EF Core 11.

Owned entities carry a hidden key and reference identity that fights value objects. Here is how to map a value object as a complex type in EF Core 11, when to switch, and the gotchas.

A step-by-step guide to moving seed data off HasData and onto UseSeeding and UseAsyncSeeding in EF Core 11, including the DeleteData migration trap that wipes your existing rows if you skip it.

Both produce the same SQL. Reach for named filters only when you need to disable one predicate independently; a single combined filter is simpler for one concern in EF Core 11.

EF Core 11 throws this when a Where or OrderBy calls a method it cannot turn into SQL. Rewrite the predicate into translatable operators, or pull the data client-side with AsEnumerable first.

EF Core throws this when your raw SQL does not return every column the entity maps to, or the column names do not match. Return all mapped columns with matching names, or query a scalar/keyless type instead.

Apply two independent global query filters to the same entity in EF Core 11: a soft-delete filter and a tenant filter, each named so you can disable one without the other via IgnoreQueryFilters.

Use HasData only for fixed, model-owned reference data. Use UseSeeding and UseAsyncSeeding for everything else in EF Core 11. A side-by-side comparison with the rules that force the decision.

EF Core throws FOREIGN KEY constraint failed because the parent still has dependents the database refuses to orphan. Load the children, make the relationship optional, or configure OnDelete.

EF Core throws this when AddDbContext never ran, ran after Build, or your context's constructor takes the wrong DbContextOptions. Register before Build and use DbContextOptions<YourContext>.

HasData seeds an entity with a store-generated key but no explicit value. Give every seed row a stable non-zero Id, or switch to UseSeeding for generated keys.

Replace Skip/Take with a WHERE clause that seeks past the last row you saw. Order by a fully unique key, carry the last row's values as a cursor, and EF Core 11 turns the next page into an index seek instead of an OFFSET scan.

Map a nested type to a single JSON column with ComplexProperty(...).ToJson(), let EF Core 11 store it in the native SQL Server 2025 json type, then query into it with LINQ that translates to JSON_VALUE, JSON_CONTAINS, and JSON_PATH_EXISTS.

Seed the join table of a many-to-many relationship in EF Core 11: the implicit shadow keys you must name yourself, the UsingEntity HasData pattern, and the runtime UseSeeding alternative that works with skip navigations.

Seed reference data the right way in EF Core 11 with UseSeeding and UseAsyncSeeding: where to configure them, when they run, the idempotency check you cannot skip, and why you must implement both.

Use AsNoTracking for read-only queries by default. Reach for AsNoTrackingWithIdentityResolution only when the result graph contains the same entity more than once and your code depends on getting a single shared instance back.

EF Core 11 Preview 5 ships the EF1004 analyzer. It flags ToAsyncEnumerable() on an IQueryable so you do not accidentally enumerate a database query synchronously inside an await foreach.

EF Core can't find a key for your type. Either name a property Id or {Type}Id, add [Key], call HasKey, or - if it is a view or raw SQL result - call HasNoKey.

EnableRetryOnFailure conflicts with BeginTransaction. Wrap the whole transaction in db.Database.CreateExecutionStrategy().ExecuteAsync(...) so it retries as one unit.

Stamp CreatedBy/ModifiedOn columns and write a full change-trail with an ISaveChangesInterceptor in EF Core 11, including the DI lifetime, current-user, and ExecuteUpdate gotchas.

A decision guide and real benchmark for EF Core 11: use ExecuteUpdate for set-based writes by a predicate, and the load-then-SaveChanges path only when you need the change tracker, interceptors, or a complex object graph.

A version-pinned migration guide from EF Core 6.0 to EF Core 11.0, walking the breaking changes across EF7, 8, 9, 10, and 11 that break real apps: Encrypt=True, OPENJSON Contains, PendingModelChangesWarning, the native json column, and the SqlClient 7.0 split.

Your fire-and-forget task captured a request-scoped DbContext that the DI scope already disposed. Resolve a fresh context inside the task with IServiceScopeFactory or IDbContextFactory.

EF Core 11 Preview 4 lets the dotnet ef tool read default option values from a .config/dotnet-ef.json file, so split solutions no longer force you to pass --project and --startup-project on every command.

When you Include two sibling collections, EF Core 11 returns the cross product and your row count explodes. Here is how AsSplitQuery fixes it, how to turn it on globally, and the consistency and ordering gotchas to watch for.

A complete guide to ExecuteUpdate and ExecuteDelete in EF Core 11: the SQL they emit, the change-tracker gotcha that silently overwrites your bulk write, transactions, concurrency control with the affected-row count, and the EF Core 10 delegate setters that let you build conditional updates with plain if statements.

A version-pinned migration checklist from .NET 8 LTS to .NET 11 LTS, covering SDK install, csproj target framework, breaking changes in ASP.NET Core, EF Core, System.Text.Json, and the C# 14 overload-resolution shift, with rollback notes.

A version-pinned migration playbook for moving a .NET Framework 4.8 codebase to .NET 11 LTS in 2026, covering the SDK-style csproj rewrite, System.Web to ASP.NET Core, WCF, EF6 to EF Core 11, BinaryFormatter removal, AppDomain replacements, and a realistic rollback plan.

EF Core 11 Preview 4 drops the long-standing shadow-property restriction on SQL Server temporal tables. PeriodStart and PeriodEnd can now be regular CLR properties, configured with strongly-typed HasPeriodStart and HasPeriodEnd lambdas.

For read-heavy paths in .NET 11, plain EF Core with AsNoTracking is within ~5% of Dapper. Reach for compiled queries on a profiled single-row hot path, and Dapper only for the lowest latency or SQL LINQ can't express.

Three sequence interfaces, three execution models. Use IQueryable when a database can translate the query, IAsyncEnumerable when the producer is async and you want to stream, IEnumerable for everything else in memory.

For bulk inserts in .NET 11, neither EF Core nor Dapper wins. SqlBulkCopy does. This is the benchmark, the why, and the seat each tool deserves.

System.Text.Json refuses to serialize graphs with back-references. Set ReferenceHandler.IgnoreCycles, project to a DTO, or mark the back-pointer with [JsonIgnore]. Preserve is a last resort.

Migrations use the design-time DbContext, not your runtime CommandTimeout. Set the timeout via UseSqlServer(o => o.CommandTimeout(...)), the connection string Command Timeout, or Database.SetCommandTimeout before Migrate().

EF Core's design-time tools could not instantiate your DbContext. Either expose a host via WebApplication.CreateBuilder, point to the right startup project, or implement IDesignTimeDbContextFactory.

EF Core 11 throws when two objects share a primary key inside one DbContext. Detach the old one or update it in place. AsNoTracking on the read prevents the collision.

EF Core throws when two awaits run in parallel on the same DbContext. Await each call sequentially, or get a new DbContext per concurrent unit of work via IDbContextFactory.

If GetConnectionString returns null in .NET 11, your appsettings.json is missing the key, not copied to the build output, or the wrong environment file is being selected. Three checks fix 95% of cases.

Wire an EF Core 10 DbContext into a Model Context Protocol server so Claude Code, Cursor, or any compliant client can run safe, scoped queries against your database. Covers IDbContextFactory lifetime, read-only projections, schema discovery tools, AsNoTracking, parameterised filters, row-level scoping, and the destructive-tool gates you need before letting an agent touch UPDATE.

A practical guide to spotting N+1 queries in EF Core 11: what the pattern looks like in real code, how to surface it via logging, diagnostic interceptors, OpenTelemetry, and a test that fails the build when a hot path regresses.

A practical guide to EF Core 11 compiled queries: when EF.CompileAsyncQuery actually wins, the static-field pattern, the Include and tracking gotchas, and how to benchmark before and after so you can prove it was worth the extra ceremony.

A complete guide to running ASP.NET Core integration tests against a real SQL Server 2022 using Testcontainers 4.11 and EF Core 11: WebApplicationFactory wiring, IAsyncLifetime, swapping the DbContext registration, applying migrations, parallelism, Ryuk cleanup, and CI gotchas.

EF Core builds its conceptual model lazily on the first DbContext access, which is why the first query in a fresh process is several hundred milliseconds slower than every query after it. This guide covers the three real fixes in EF Core 11: a startup IHostedService that touches Model and opens a connection, dotnet ef dbcontext optimize to ship a precompiled model, and the cache-key footguns that silently rebuild the model anyway.

Mocking DbContext directly silently breaks ChangeTracker, which is why Microsoft discourages it. This guide shows the two patterns that actually work in EF Core 11: SQLite in-memory with a kept-open connection so the real ChangeTracker runs, and the repository pattern that lifts EF Core out of the test entirely.

EF Core 11 Preview 3 introduces RemoveDbContext, RemoveExtension, and a parameterless AddPooledDbContextFactory overload, removing the boilerplate around swapping providers in tests and centralizing pooled factory configuration.

EF Core 11 queries implement IAsyncEnumerable<T> directly. Here is how to stream rows with await foreach, when to prefer it over ToListAsync, and the gotchas around connections, tracking, and cancellation.

A practical guide to mixing C# records and EF Core 11. Where records fit, where they break change tracking, and how to model value objects, entities, and projections without fighting the framework.

EF Core 11 auto-translates LINQ Contains over JSON collections to the new SQL Server 2025 JSON_CONTAINS function, and adds EF.Functions.JsonContains for path-scoped and mode-specific queries that can hit a JSON index.

EF Core 11 Preview 3 removes redundant to-one joins from split queries and drops unneeded ORDER BY keys. One reported scenario got 29% faster, another 22%. Here is what the SQL now looks like.

EF Core 11 Preview 3 introduces ChangeTracker.GetEntriesForState, a state-filtered enumerator that avoids an extra DetectChanges pass in hot paths like SaveChanges interceptors and audit hooks.

EF Core 11 groups Cosmos DB writes into transactional batches per container and partition on every SaveChanges, giving best-effort atomicity and fewer roundtrips without any code changes.

The dotnet ef database update command now accepts --add to scaffold and apply a migration in a single step. Here is how it works, why it matters for containers and .NET Aspire, and what to watch for.

EF Core 11 Preview 2 supports SQL Server 2025 VECTOR_SEARCH() and DiskANN vector indexes directly from LINQ. Here is how to set up the index, run approximate queries, and what changes from the EF Core 10 VectorDistance approach.

Fix the 'dotnet-ef does not exist' / 'dotnet ef command not found' error by installing the EF Core CLI as a global or local .NET tool.