.NET 11 Preview 5: What's Actually New for C# and MAUI Developers

Three months ago, we covered .NET 11 Preview 1 – and the headline was hard to ignore: Android CoreCLR as the default runtime, promising up to 20% faster app startup. It was bold, ambitious, and came with a fair share of "handle with care" warnings. We said it then: brilliant playground, not production territory.

Preview 5 is a different story.

Released on June 9 2026, this is the last major preview before the Release Candidate. At this point, the .NET team isn't experimenting – they're finishing. And what Preview 5 delivers isn't one headline feature. It's a dense, wide-ranging set of improvements across the language, SDK, runtime, and framework layers that together paint a clear picture of what .NET 11 will look like when it ships in November.

C# 15 gets union types – something the community has been asking for since F# made them look effortless. The SDK ships with a built-in MCP server template, making AI integration a first-class workflow. LINQ finally gets full outer joins. Blazor SSR gets client-side validation. And MAUI gets a substantial reliability rollup that quietly fixes more than it announces.

If you're building with .NET MAUI or planning a migration from .NET 10, this is the preview worth your attention.

C# 15: The Language Updates That Matter

The language changes in Preview 5 are the most visible part of this release. C# 15 isn't chasing a single big idea – it's closing gaps that have existed for years. Some of these were workarounds developers learned to live with. With Preview 5, they don't have to anymore.

Union Types and Closed Classes

Of all the changes in Preview 5, union types are the one developers will actually talk about. C# 15 introduces the union keyword – a way to define a type that can be exactly one of a fixed set of variants, with the compiler enforcing exhaustiveness at every switch expression.

public record class Dog(string Name);
public record class Cat(int Lives);

public union Pet(Dog, Cat);

static string Describe(Pet pet) => pet switch
{
    Dog(string name) => $"dog: {name}",
    Cat(int lives) => $"cat: {lives}"
};

If you've worked in TypeScript or F# and come back to C# feeling the absence of discriminated unions, this is what you've been waiting for. The compiler knows every possible variant inside a union – which means switch expressions are exhaustive by default, and you no longer need a catch-all branch just to satisfy the compiler. For MAUI developers working with domain models, UI states, or result types, this translates directly into cleaner, safer code with fewer runtime surprises.

Alongside union types, C# 15 also introduces closed classes – a way to restrict which types can inherit from a base class within a defined scope. Together, these two features push C# closer to the expressive type system that functional developers have long taken for granted.

Other Language Improvements

Two more additions round out the C# 15 story in this preview. First, LINQ in-memory queries finally support full outer joins via the new FullJoin() method – something SQL developers have had for decades, but LINQ consistently lacked without custom workarounds. The method works both on in-memory collections and through EF Core, translating directly to SQL.

var rows = catalog.FullJoin(
    sales,
    product => product.Sku,
    sale => sale.Sku,
    (product, sale) => new
    {
        Sku = product?.Sku ?? sale!.Sku,
        Name = product?.Name ?? "(not in catalog)",
        Sold = sale?.Quantity ?? 0
    });

Second, System.Text.Json now supports JSON Lines serialization – a format common in log streams and data pipelines where each line is a separate JSON object. Until now, you had to serialize each item manually and write newlines yourself. A single SerializeAsyncEnumerable call with topLevelValues: true handles it cleanly.

SDK and Tooling

Preview 5 doesn't just improve the language – it changes how you interact with the SDK itself. The tooling updates in this release are practical and immediate: less setup, better defaults, and a clear signal that AI-native development is no longer an optional layer on top of .NET, but a built-in part of the workflow.

AI-Ready Out of the Box

The most telling addition in this preview is a single command: dotnet new mcpserver. The Model Context Protocol server template is now bundled directly into the SDK – no extra packages, no manual scaffolding. You describe a task, the agent acts, and your .NET project is already wired to receive it.

This matters beyond the convenience. MCP is rapidly becoming the standard protocol for connecting AI agents to external tools and services. By shipping the template in the SDK, Microsoft is making a clear statement: building AI-integrated applications in .NET should be as straightforward as building a web API. For MAUI teams exploring agentic features or connecting their mobile apps to AI backends, this is the lowest-friction entry point yet.

Security and Developer Workflow

Two quieter additions in Preview 5 address problems that every team eventually runs into. The first is build-time NuGet vulnerability warnings – the SDK now checks your dependencies against known CVEs and end-of-life package versions at build time, without requiring separate tooling. If a package you're using has a known security issue, you'll know before the build completes, not after a security audit.

The second is the #:ref directive for file-based apps. You can now split a file-based application across multiple .cs files without creating a full project structure. For teams writing CLI utilities, automation scripts, or quick prototypes in .NET, this removes one of the last reasons to reach for a heavier setup when a lightweight script would do.

// main.cs
#:ref helpers.cs

var result = Greet("World");
Console.WriteLine(result);

// helpers.cs
string Greet(string name) => $"Hello, {name}!";

Runtime, Blazor, and EF Core

Not every improvement in Preview 5 comes with a new keyword or a new command. Some of the most valuable changes in this release are the ones that make existing code faster, safer, and less surprising – without requiring you to change how you work.

Async Performance Gains

Runtime Async was introduced in Preview 1 as a promising but experimental feature. Preview 5 takes it significantly further. Suspension and resumption of async methods are now measurably faster, with the biggest gains coming from methods optimized by on-stack replacement (OSR) – the JIT feature that lets a long-running method switch to optimized code while still executing.

The numbers speak for themselves. A suspension-heavy benchmark that previously completed in 6,357ms now finishes in 457ms – a roughly 13x improvement. For MAUI applications with complex async workflows, background sync, or real-time data processing, this isn't a micro-optimization. It's the kind of gain that changes how you think about what's acceptable on a mobile device.

Alongside async improvements, the JIT compiler in Preview 5 also delivers bounds check elimination, switch expression folding, and redundant branch elimination – incremental gains that compound across a real application.

Blazor SSR and EF Core

Blazor Server-Side Rendering gets one of its most requested fixes in Preview 5: client-side validation now works without enabling full interactivity. Previously, form validation in Blazor SSR only ran on the server – meaning users had to wait for a round trip to find out their input was invalid. That friction is gone. For teams building hybrid MAUI + Blazor applications, this makes the web layer feel significantly more polished without adding architectural complexity.

On the EF Core side, Preview 5 delivers cleaner SQL query translation – fewer unnecessary subqueries, more direct mapping between LINQ expressions and the SQL that actually runs. It's a subtle change, but anyone who has ever opened a profiler and facepalmed at the query EF Core generated will appreciate the direction. Combined with the new FullJoin() support from Chapter 1, EF Core in .NET 11 is shaping up to be the most capable version yet.

What's New for MAUI Developers

Every preview release carries something for MAUI, but Preview 5 takes a different approach than usual. Instead of shipping new controls or APIs, the team focused on stability – and for production teams, that's often exactly the right call.

Reliability Rollup

Preview 5 includes a large MAUI reliability rollup – a concentrated package of bug fixes addressing issues that real teams have been hitting in real projects. No single fix is headline-worthy on its own, but the cumulative effect matters. Crashes that were hard to reproduce, layout inconsistencies across platforms, edge cases in control behavior – these are the kinds of problems that don't make it into keynotes but quietly drain engineering time every sprint.

For teams already running MAUI in production on .NET 10, this rollup is a preview of the stability improvements coming in the final release. It's also a signal that the MAUI team is listening – the fixes in this rollup largely reflect issues reported by the community over the past several months.

Preparing for .NET 11

.NET 11 is an LTS release, supported until November 2028. That makes the migration decision straightforward for most teams – the question isn't whether to move, but when. Preview 5 is the right moment to start finding out.

The practical recommendation is simple: spin up a branch, point it at the .NET 11 SDK, and build. You're not looking to ship anything yet – you're looking for friction. Which packages need updating? Which platform-specific behaviors changed? Where does the new CoreCLR runtime (introduced in Preview 1) interact with your existing JNI bindings or native integrations?

The teams that start testing now will have a smooth migration in November. The teams that wait will be doing it under deadline pressure. .NET 10 reaches end of support in May 2027 – that window is shorter than it looks.

Conclusion

Preview 5 doesn't have one headline feature. It has a dozen smaller ones – and that's precisely what makes it interesting. C# 15 closes language gaps that developers have been working around for years. The SDK ships with AI integration built in. LINQ and EF Core get improvements that quietly make data access cleaner and more capable. Blazor SSR stops punishing developers for choosing server-side rendering. And MAUI gets the stability work that production teams actually need.

Taken together, Preview 5 paints a clear picture of what .NET 11 will be: a mature, production-oriented release that doesn't chase headlines – it closes gaps, improves defaults, and makes the platform easier to build on. For teams working with MAUI, Blazor, or any part of the .NET ecosystem, the message is straightforward: November is closer than it looks, and the time to start testing is now.

We covered Preview 1 back in February – the ambition was clear even then. Preview 5 confirms that the ambition is being delivered.

Ready to future-proof your mobile stack?

The November release window is closer than it looks – and the teams that prepare early ship smoother. Let's talk about what .NET 11 means for your project. Get in touch and we'll take it from there.