.NET 11 Ships: C# 15 Union Types, Runtime Async

.NET 8 and .NET 9 both hit end-of-support on November 10 — the same day .NET 11 shipped. If your team is running either version, you are now on unsupported software with no security patches in the pipeline. That double expiration is easy to miss, and Microsoft did not exactly advertise it loudly. The good news is that .NET 11 is a genuinely strong release: C# 15 ships with union types (the most-requested C# feature in years), async/await moves into the JIT with zero code changes required, and the SDK now includes a first-class AI agent stack. Here is what changed and what you need to decide before the week is out.

First, the Version Math #

The expiration stacking here is unusual. .NET 8 was LTS with a three-year window from November 2023 — that runs out November 2026. .NET 9 was STS with two years from November 2024 — same end date. They both expired yesterday.

.NET 11 is also STS, giving you 24 months of support. If your organization needs a longer runway, Microsoft’s EOL post recommends .NET 10 LTS, which is supported through November 2028. The upgrade path from .NET 8 to .NET 10 is a project file edit plus a read through both the .NET 9 and .NET 10 breaking-change lists. For most applications it is a few days, not a rewrite.

C# 15: Union Types Land #

Union types have been the top community request for C# for the better part of a decade. They are here now. The new contextual union keyword does not break existing code that uses “union” as an identifier. You declare a type that is exactly one of a closed set of cases, and the compiler knows all of them:

public union Pet(Cat, Dog, Bird);

// Implicit conversions from each case type
Pet pet = new Dog("Rex");

// Exhaustive switch — no discard arm needed
var label = pet switch {
    Cat c => $"Cat: {c.Name}",
    Dog d => $"Dog: {d.Name}",
    Bird b => $"Bird: {b.Name}"
};

Generic unions make result modeling clean without a library dependency:

public union Result<TSuccess, TError>(TSuccess, TError);

The community reaction has been positive, with one notable caveat worth knowing before you ship: union types do not round-trip through System.Text.Json. The serialized output carries no type discriminator, so deserialization cannot reconstruct the original case. If you are sending unions across a network boundary today, you need a custom converter. The official C# 15 union types post covers the current limitations. This is a known gap and will likely be addressed in a patch, but it is not fixed at launch.

Runtime Async: The JIT Takes Over #

Previously, the C# compiler transformed every async method into a heap-allocated state machine. That transformation is now the JIT’s job. The compiler emits a smaller contract and the runtime handles the heavy lifting at execution time.

The practical benefits are real: stack traces no longer show the MoveNext noise that made debugging async code tedious, generated code is smaller because the JIT tail-merges suspension points, and you get this for free — no code changes required. In .NET 11, Runtime Async no longer requires the EnablePreviewFeatures flag. It is on by default for projects targeting net11.0.

One breaking change to know: .NET 11 raises the minimum CPU requirements. The runtime will not start on older hardware. Check the full what’s new overview for the complete breaking-change list before upgrading production.

The AI Stack: MEAI, MCP, and MAF Are Now First-Class #

Microsoft has been building toward this for two preview cycles. .NET 11 ships three AI-focused components in the SDK:

• Microsoft.Extensions.AI (MEAI) — unifiedIChatClient andIEmbeddingGenerator abstractions that work with any LLM provider, local or cloud.
• Model Context Protocol (MCP) — the SDK includes an MCP server template, giving .NET apps a standard way to expose and consume tool servers.
• Microsoft Agent Framework (MAF) — open-source SDK for building, orchestrating, and deploying multi-agent workflows in .NET.

Experimental Blazor AI components that integrate with the Agent User Interaction Protocol (AG-UI) are also included, though they are prerelease and subject to breaking changes throughout the .NET 11 lifecycle. Do not build production features on them yet.

The Rest of the Release #

EF Core 11 adds a FullJoin operator, approximate nearest-neighbor vector search for SQL Server 2025, and extends JSON column support to table-per-type inheritance. ASP.NET Core gains async validation for Minimal APIs, generates OpenAPI 3.2 by default, and adds a CacheView component for caching server-side rendered subtrees. .NET MAUI now runs on CoreCLR by default across all platforms — it was opt-in before — which should close the performance gap that was making MAUI apps feel sluggish on Android and iOS.

The Verdict #

If you are on .NET 8 or .NET 9, you have no good reason to stay. Both versions are past end-of-support as of yesterday. The official .NET 11 announcement has the full migration guidance. The upgrade path is straightforward for most applications. Union types and free async improvements are worth it. The only real decision is whether to target .NET 11 STS or hold at .NET 10 LTS — if your organization ships on a cadence that can absorb an upgrade every two years, .NET 11 is the right call. If you need three years of guaranteed support, go to .NET 10 and schedule a move to .NET 12 LTS in 2027.