.NET 11 vs .NET 10: the new features and whether you should upgrade

.NET 11 ships at .NET Conf on 10 November 2026, and Release Candidate 2 already carries a go-live licence. If your team runs on .NET 10, the long-term support release, the real question is .NET 11 vs .NET 10: what do you actually gain, and is it worth leaving an LTS for a standard-term release? This guide covers the features that matter and gives a straight answer.

Key takeaways

• C# 15 is the headline. Union types and closed hierarchies bring compiler-checked, exhaustive pattern matching to C#, with no preview flag needed.
• Runtime Async moves async/await into the runtime itself. You get cleaner stack traces and lower overhead without changing a line of code.
• EF Core 11 writes leaner SQL. Microsoft measured 29% and 22% gains on common include queries, and up to 22x on vector-heavy entities.
• Support no longer penalises you for upgrading. .NET 11 (STS, 24 months) and .NET 10 (LTS) both reach end of support in November 2028.
• On .NET 8 or .NET 9? Both lose support on 10 November 2026, so you need to move now either way.

.NET 11 release status and support timeline

.NET 11 went through the usual cadence: monthly previews from early 2026, RC1 in September (which made C# 15 the default language version), and RC2 on 13 October 2026 with a go-live licence for production use. General availability is planned for .NET Conf, starting 10 November.

The support picture is the part most teams get wrong. .NET 11 is a Standard Term Support release. STS used to mean 18 months, but Microsoft extended STS to 24 months, so .NET 11 is supported until November 2028. According to the official .NET support policy, .NET 10 LTS ends on 14 November 2028.

In practice, choosing .NET 11 over .NET 10 no longer shortens your runway. Both versions retire in the same month. The next LTS, .NET 12, is expected in November 2027, giving you a full year to plan the following hop.

C# 15: the language features worth upgrading for

C# 15 is the default for projects targeting net11.0. Apart from the memory-safety work, none of its features need <LangVersion>preview</LangVersion>.

Union types

This is the feature C# developers have asked for for years. A union is a value that is exactly one of several case types, and the compiler makes sure every switch handles all of them:

public record class Cat(string Name);
public record class Dog(string Name);
public record class Bird(string Name);

public union Pet(Cat, Dog, Bird);

Pet pet = new Dog("Rex");

string name = pet switch
{
    Dog d => d.Name,
    Cat c => c.Name,
    Bird b => b.Name,
};

Each case type converts implicitly to the union, so no wrapper boilerplate is needed. Unions also work beyond the language: System.Text.Json serialises them, ASP.NET Core accepts them in JSON bodies and SignalR messages, and OpenAPI describes them with anyOf. Result types, API responses with several shapes, and state machines all get simpler.

Closed hierarchies

If you prefer class hierarchies to unions, the new closed modifier gives you the same exhaustiveness checking. A closed class can only be derived from inside its own assembly, so the compiler knows every direct descendant:

public closed record class GateState;
public record class Closed : GateState;
public record class Open(float Percent) : GateState;

string Describe(GateState state) => state switch
{
    Closed => "closed",
    Open(var percent) => $"{percent}% open",
    // No default arm needed: every case is handled.
};

A closed class is implicitly abstract. One caveat: it doesn't configure polymorphic JSON serialisation on its own.

Smaller quality-of-life wins

• Collection expression arguments let you pass constructor arguments with with(...), for example List<string> names = [with(capacity: 100), .. values]; or HashSet<string> set = [with(StringComparer.OrdinalIgnoreCase), "a", "A"];.
• Extension indexers let an extension block add this[...] to a type you don't own.
• Labeled break and continue (continue outer;) replace the Boolean-flag and goto workarounds for nested loops. The new IDE0410 analyser points out where to use them.
• Memory safety (preview) begins a multi-release redesign of unsafe, tying it to the operations that actually touch unmanaged memory rather than to pointer types.

Runtime Async and the JIT: faster code without code changes

In .NET 10, every async method is still compiled into a compiler-generated state machine. Runtime Async in .NET 11 moves that machinery into the runtime itself. It no longer needs EnablePreviewFeatures for net11.0 projects, and the .NET libraries themselves are now compiled with it switched on. According to the .NET 11 runtime notes, this brings:

• Cleaner stack traces, without layers of MoveNext() frames.
• Lower overhead on common await paths, fewer warm-up allocations, and smaller generated code thanks to tail-merged suspension points.
• Continuations that skip ExecutionContext capture when no ambient state is in use.

The JIT also improved again. It removes more bounds checks and redundant branches, devirtualises more calls, folds switch expressions, and emits a single MUL instruction for Math.BigMul on x64. NativeAOT gets faster interface dispatch with smaller binaries. Arm SVE2, AVX-VNNI-512 and hardware FP16 support help numeric and AI workloads.

One thing to check before upgrading: .NET 11 raises the minimum hardware requirements for x86/x64 and Arm64 to more modern instruction sets. Very old build agents or servers may need replacing.

Libraries: the new APIs you'll actually use

The .NET 11 libraries add a long list of APIs. These are the ones that will show up in everyday code:

• LINQ FullJoin, plus tuple-returning Join and GroupJoin overloads, across Enumerable, Queryable and AsyncEnumerable.
• System.Text.Json gains union support, JSON Lines (JSONL) output, broader polymorphism and source generation, and new naming and ignore controls.
• Process helpers for run-and-capture and fire-and-forget launches, plus Process.TryGetProcessById, StartSuspended and Process.Signal. No more hand-rolled output capturing.
• Zstandard compression in System.IO.Compression, with CRC32 validation when reading ZIP entries.
• Async validation via AsyncValidationAttribute, IAsyncValidatableObject and Validator.ValidateObjectAsync, so you can check things like "email already registered" against a database.
• EqualityComparer<T>.Create builds a comparer from a key selector.
• Zero-copy streams (ReadOnlyMemoryStream, StringStream and others) and IEEE 754 decimal types (Decimal32, Decimal64, Decimal128).
• Security: an X25519DiffieHellman class, AES key wrap, TLS hardening and experimental post-quantum ML-KEM and HPKE APIs.

ASP.NET Core 11 and Blazor

ASP.NET Core 11 is an evolution rather than a revolution, but several changes remove real friction:

• Client-side validation in static SSR Blazor forms, on by default and with no server round-trip.
• Async validation in Minimal APIs and Blazor, with built-in localisation of validation messages.
• [ShortCircuit] endpoints skip the rest of the middleware pipeline, which suits health checks and robots.txt.
• QuickGrid stores paging and sorting state in the URL, and Virtualize handles variable item heights better.
• CacheView caches rendered component subtrees in static SSR.
• Blazor Server circuit pausing frees server resources when tabs sit idle.
• SignalR can refresh bearer tokens without disconnecting, and invocations can be cancelled.
• OpenAPI 3.2 output is supported. The upgraded Microsoft.OpenApi dependency is a breaking change to plan for.

EF Core 11: cleaner SQL and real speed-ups

EF Core 11 is where many teams will feel the upgrade most, because the gains come automatically:

• Leaner SQL for includes. Split queries no longer add needless joins to reference navigations, and redundant ORDER BY keys are gone. Microsoft's benchmarks showed 29% faster split queries and 22% faster single queries.
• Vector columns are no longer loaded by default. SqlVector<T> columns are skipped when entities are materialised. One benchmark showed about 9x faster queries locally and roughly 22x against remote Azure SQL.
• Vector search with VectorSearch(), HasVectorIndex() and approximate nearest-neighbour search on SQL Server 2025. Combined with the new full-text FreeTextTable()/ContainsTable() and FullJoin, this gives you hybrid search written entirely in LINQ.
• Complex types now work with TPT/TPC inheritance and in Cosmos DB, and can carry keys and indexes.
• Migrations: dotnet ef database update --add creates and applies a migration in one step, and a .config/dotnet-ef.json file stores your defaults. The latest migration ID in the model snapshot now surfaces branch conflicts in source control.
• MaxBy/MinBy, JsonPathExists, JSON_CONTAINS and DATETRUNC translations round out the query improvements.

Watch for two breaking changes. UseSqlServer now defaults to compatibility level 160 (SQL Server 2022). The Cosmos DB provider has dropped Newtonsoft.Json, so unmapped JSON properties are no longer preserved on round-trip.

SDK and tooling

The .NET 11 SDK is faster to install and use. Linux and macOS installers are smaller, and a NativeAOT-compiled CLI entry point with the MSBuild server on by default speeds up everyday commands. Other changes:

• File-based apps gain #:include, which splits a script across files.
• dotnet watch recovers from crashes automatically and integrates with Aspire.
• dotnet test gains run-level timeouts, a maximum-failures limit, and support for mobile test projects.
• Container publishing produces reproducible image digests and builds multi-architecture images with Podman.
• --min-publish-age-hours for NuGet sources protects against freshly published malicious packages, a small but welcome supply-chain safeguard.

.NET 11 vs .NET 10 at a glance

Area	.NET 10 (LTS)	.NET 11 (STS)
Release / end of support	Nov 2025 / 14 Nov 2028	Nov 2026 / Nov 2028
C# version	C# 14	C# 15: unions, closed hierarchies, extension indexers
Async model	Compiler state machines	Runtime Async, on by default for net11.0
EF Core	Exact vector distance	Vector indexes and search, hybrid search, leaner include SQL
LINQ	Left/right joins	Adds FullJoin and tuple-returning joins
JSON	Polymorphism via attributes	Union support, JSONL output
Validation	Synchronous	Async validation across DataAnnotations, Minimal APIs, Blazor
Hardware baseline	Broader legacy CPU support	Requires more modern x64/Arm64 instruction sets

Should you upgrade from .NET 10 to .NET 11?

Upgrade if:

• You're starting a new service, or your team wants union types and closed hierarchies to model domain states.
• Your workloads are async-heavy or database-heavy and could benefit from Runtime Async and EF Core 11's SQL improvements.
• You use SQL Server 2025 vector or full-text search, or plan to build retrieval features for AI.
• You run on .NET 8 or .NET 9. Both reach end of support on 10 November 2026, so you must move to either .NET 10 or .NET 11 now. Going straight to 11 avoids a second migration within a year.

Stay on .NET 10 for now if:

• You ship long-lived products to customers whose policy requires an LTS runtime.
• Your build or production hardware is old enough to fall below .NET 11's new instruction-set baseline.
• You depend on third-party libraries that haven't yet published .NET 11-compatible versions. Check them before you start.

How to do it safely: branch, change TargetFramework to net11.0, and update the Microsoft.* packages. Then work through the breaking-change notes for EF Core, the OpenAPI package and the hardware baseline. Run the full test suite under the new runtime before enabling new language features, and ship the upgrade before you refactor towards unions. Get a working version live quickly, then improve it in small, safe steps. For more practical guides like this one, browse the rest of the blog.

Frequently asked questions

When is .NET 11 released?

.NET 11 reaches general availability at .NET Conf, which starts on 10 November 2026. Release Candidate 2 was published on 13 October 2026 with a go-live licence, so Microsoft supports it in production before final release. If you install RC2 now, you only need to update to the GA build when it ships.

Is .NET 11 an LTS release?

No. .NET 11 is a Standard Term Support (STS) release. Microsoft now supports STS releases for 24 months instead of 18, so .NET 11 is supported until November 2028, the same month that .NET 10 LTS support ends. The next LTS release is expected to be .NET 12 in November 2027.

What is the biggest new feature in .NET 11?

For most developers it's C# 15 union types. A union holds exactly one of several declared case types, and the compiler checks that every switch handles each case. System.Text.Json, ASP.NET Core and OpenAPI support unions too. Runtime Async is the biggest under-the-hood change: it speeds up async code with no rewrites.

Is upgrading from .NET 10 to .NET 11 difficult?

For most applications it's a small change: retarget to net11.0, update packages, and fix any breaking changes. The main things to check are the higher minimum CPU instruction sets, EF Core's new SQL Server compatibility-level default, the Cosmos DB provider's switch to System.Text.Json, and the upgraded OpenAPI dependency in ASP.NET Core.

Should I upgrade from .NET 8 directly to .NET 11?

Yes, if you can test properly. .NET 8 support ends on 10 November 2026, and .NET 11 is supported just as long as .NET 10. Jumping straight to .NET 11 gets you C# 15, Runtime Async and EF Core 11 while saving you a second migration. Read the breaking-change notes for .NET 9, 10 and 11 before you start.