.NET 11 RC1: C# 15 Union Types Are Production-Ready

.NET 11 Release Candidate 1 landed on September 8 with something most release candidates lack: a go-live support license. That means you can run it in production today, not just in experimental branches. The GA is still on track for November 10, but RC1 is effectively final-quality. More importantly, it sets C# 15 as the default language version, pulling union types out of two years of preview and into the language proper.

Union types are the most-requested C# feature in recent memory, and they are finally production-ready. Here is what changed and what you need to do about it.

Union Types: Native, Compiler-Enforced, and OneOf-Killing

The union keyword lets you declare that a value is exactly one of a fixed set of types. Not a base class, not an interface — a closed set. The compiler generates implicit conversions from each case type, so assignment is straightforward. And when you pattern-match over a union, the switch is exhaustive by default.

// C# 15 native union
public union Result(Success, Failure);

Result result = Compute();
string message = result switch
{
    Success s => $"OK: {s.Value}",
    Failure f => $"Error: {f.Message}"
    // No default needed — compiler verifies exhaustion
};

No _ discard arm. No runtime exception if you forget a case. Add a new type to the union and the compiler immediately flags every switch that is not updated. This is the behavior developers have been approximating with the OneOf NuGet package for years — now it is a language primitive.

The difference matters beyond convenience. OneOf enforces exhaustiveness at runtime, requires an external dependency, and has limited IDE support for switch completeness. C# 15 unions are compiler-enforced, zero-dependency, and fully IDE-aware. For performance-sensitive code with value types, you can opt into a non-boxing pattern via TryGetValue methods — the compiler uses them automatically during pattern matching.

C# lead designer Mads Torgersen’s take: “This is how unions should be.” Years of feature requests, a multi-release preview cycle, and now it ships. The community mostly agrees, though some developers note that closed unions mean extending the type set requires a recompile — a tradeoff inherent to compiler-enforced exhaustiveness.

What “Go-Live” Actually Means

Go-live support is Microsoft’s signal that the release is production-grade. RC1 is not a preview with asterisks — it ships with a supported path to production. Microsoft expects only minor fixes between now and the November GA.

Practically: start new projects on .NET 11 RC1 now. Test existing codebases against it. Visual Studio 2026 Insiders and VS Code with the C# Dev Kit both support it. The switch to C# 15 as the default is automatic for projects targeting .NET 11 — no project property change required.

The EOL Clock Is Running

Here is the upgrade timeline that should get your attention: .NET 8 and .NET 9 both reach end of support on November 10, 2026 — the same day .NET 11 ships GA. If you are on .NET 9, you have weeks, not months.

The recommended path: upgrade to .NET 10 (LTS, released November 2025, supported through November 2028) now, then evaluate .NET 11 after GA. Do not try to jump from .NET 9 directly to a fresh GA release under deadline pressure. .NET 10 is the safe bridge. The .NET 10 vs .NET 11 comparison guide breaks down the decision clearly.

The Rest of C# 15

Union types take the headline, but C# 15 ships a full set of language improvements alongside them.

Closed class hierarchies let you restrict inheritance to the defining assembly using the closed modifier. Combined with union types, this gives you exhaustive pattern matching over class trees without sealing every subtype individually.

Collection expression arguments solve the awkward problem of passing constructor parameters inside collection expression syntax. The new with(...) element forwards arguments to the underlying constructor:

HashSet<string> set = [with(StringComparer.OrdinalIgnoreCase), "Hello", "HELLO"];
List<string> names = [with(capacity: values.Length * 2), .. values];

Extension indexers round out the extension members model introduced in earlier C# 15 previews. You can now add indexing behavior to types you do not own, using the same extension block syntax.

Runtime and SDK: The Quieter Wins

Beyond C# 15, RC1 ships several runtime and SDK changes worth knowing about.

• dotnet test on mobile: The testing platform now supports Android, iOS, macOS, and Mac Catalyst targets with new project templates. If you are building .NET MAUI apps, this closes a significant gap in the testing story.
• Native AOT caching: File-based programs (dotnet run app.cs) can reuse previous build artifacts when nothing has changed, speeding up repeated runs in script-style workflows.
• FP16 hardware acceleration: The JIT uses AVX10.1 and F16C on x64 (or the Arm64 FP16 extension) for System.Half arithmetic. ML inference pipelines using half-precision floats get a measurable speedup with no code changes.
• SignalR auth refresh: Connections can now refresh their access token without disconnecting, even when negotiate redirects to a different server.

How to Get It

Download .NET 11 RC1 from the official .NET blog announcement. The C# 15 reference on Microsoft Learn covers every stabilized feature with examples. The GA is confirmed for November 10, 2026 — .NET Conf 2026 will coincide with the release.