Upgrading to .NET 11: performance, Blazor, breaking changes

Deadline

.NET 8 and 9 are out of support. .NET 10 and 11 end on the same day.

Since 10 November 2026, Microsoft no longer ships security patches for .NET 8 and .NET 9. Every new vulnerability in the runtime or in ASP.NET Core stays open in those applications. For systems that handle customer data, that is a compliance question as much as a technical one.

Microsoft now supports STS releases for two years, so .NET 10 (LTS) and .NET 11 (STS) both reach end of support on 14 November 2028. The old rule "production only on LTS" buys you no extra time this round. .NET 11 has a year more improvements, .NET 10 a year more patch history. The next LTS, .NET 12, is expected in November 2027.

Version	Type	End of support
.NET 8	LTS	Out of support since 10 Nov 2026
.NET 9	STS	Out of support since 10 Nov 2026
.NET 10	LTS	Supported until 14 Nov 2028
.NET 11	STS	Supported until 14 Nov 2028

Gains

Faster, mostly without touching the code

Most of the gain comes from recompiling against .NET 11. The JIT removes more bounds checks, devirtualizes more calls and folds more constants. Microsoft's benchmarks and our own measurements show where it adds up:

faster async call chains that complete synchronously, with Runtime Async (Microsoft benchmark). Still an opt-in preview in .NET 11.: 3x
faster in Microsoft's split query benchmark, because EF Core 11 drops joins it does not need. In our own scenario we measured 9%.: 29%
less time for DateTime.Now with a local time zone, from 34.5 ns down to 17.9 ns (our measurement).: 48%
faster Guid parsing with Parse, TryParse and the constructor (our measurement).: 20%

Micro-benchmarks are not your application. Before and after an upgrade we measure the hot paths of your system with BenchmarkDotNet and a realistic load test, so the result is a number and not a promise.

Also on board

Kestrel parses malformed HTTP/1.1 requests without throwing exceptions. Microsoft reports up to 20 to 40% more throughput under that kind of traffic, which is what bots and scanners send.
Zstandard joins System.IO.Compression, and ASP.NET Core response compression supports it out of the box.
ASP.NET Core emits OpenTelemetry HTTP traces natively, without the extra instrumentation package.
C# 15 brings union types and closed hierarchies. A domain model can say "exactly one of these cases", and the compiler checks that every case is handled.

Blazor & SignalR

Blazor and SignalR: fewer workarounds

ASP.NET Core 11 closes several gaps that we used to bridge with custom code in client projects.

Static rendering keeps state

[SupplyParameterFromTempData] and [SupplyParameterFromSession] bring flash messages and POST-redirect-GET to static server-side rendering. Pages stay fast and indexable without switching to interactive mode.

Forms validate in the browser

Statically rendered forms now validate on the client by default, and EditForm waits for async validators, for example to check whether a customer number exists.

Idle circuits pause

Interactive Server apps can pause the circuits of inactive tabs (AddAutoPause) and ask clients to pause before a deployment (RequestCircuitPauseAsync). That frees server memory and makes releases calmer for users.

Sessions survive token renewal

Blazor Server circuits and SignalR hubs receive refreshed credentials without reconnecting (EnableAuthenticationRefresh). Dashboards that stay open all day no longer drop when an access token expires.

SignalR calls can be cancelled

Cancelling the CancellationToken passed to InvokeAsync now cancels the hub method on the server. Until now that only worked for streaming calls.

Long lists and grids

Virtualize handles items of different heights and can jump to a given item. QuickGrid keeps paging and sorting in the URL, so a filtered view can be bookmarked and shared.

More on Blazor development and consulting Read the CancellationToken deep dive

Risks

What can break, and how to catch it before production

Microsoft's list of breaking changes for .NET 11 is long, and most entries concern niche APIs. These are the ones we check first in typical business applications:

Microsoft.Extensions.Hosting

A failed background service now stops the process

If a BackgroundService throws, IHost.RunAsync now fails and the process exits with a non-zero code instead of 0. Monitoring finally sees the failure, but containers can end up in restart loops and job schedulers report errors that used to stay invisible.

EF Core 11

EF Core assumes SQL Server 2022

UseSqlServer now defaults to compatibility level 160. On SQL Server 2019 or older, some generated SQL such as LEAST and GREATEST is no longer supported. Set the level explicitly with UseCompatibilityLevel(150).

Microsoft.Data.SqlClient 7

Entra ID logins to SQL need an extra package

EF Core 11 uses Microsoft.Data.SqlClient 7, which moved Entra ID authentication into Microsoft.Data.SqlClient.Extensions.Azure. Apps that connect to Azure SQL with a managed identity need that package reference.

Microsoft.Extensions.Configuration

Empty configuration values now count

In configuration chained with AddConfiguration, an empty string now overrides values from earlier providers, and binding it to a number throws. There is no switch to restore the old behavior.

Runtime / JIT

Very old CPUs no longer start

.NET 11 requires the x86-64-v2 instruction set (SSE4.2, POPCNT) on x86 and x64. Processors that left vendor support around 2013 fail at startup. Check old on-premises servers and virtual machines configured with a generic CPU model.

Kestrel

Kestrel is stricter about HTTP

Kestrel now rejects connection-specific headers in HTTP/2 and HTTP/3 and closes HTTP/1.1 connections after requests that send both Content-Length and Transfer-Encoding. Older proxies and embedded devices can see new errors.

OpenAPI

OpenAPI documents switch to 3.2

Generated API descriptions now target OpenAPI 3.2. Client generators that do not support it yet will fail. OpenApiVersion = OpenApiSpecVersion.OpenApi3_1 keeps the previous format.

Blazor

Blazor details

Obsolete Blazor APIs are removed, antiforgery validation moves into middleware, QuickGrid renders links instead of buttons (check your CSS selectors), and Virtualize renders 15 extra items by default instead of 3.

Program.cs

// SQL Server 2019: keep EF Core on compatibility level 150
builder.Services.AddDbContext<ShopContext>(options =>
    options.UseSqlServer(connectionString, sql => sql.UseCompatibilityLevel(150)));

// API clients generated from OpenAPI 3.1 documents
builder.Services.AddOpenApi(options =>
    options.OpenApiVersion = OpenApiSpecVersion.OpenApi3_1);

var app = builder.Build();

try
{
    await app.RunAsync();
}
catch (Exception ex)
{
    // .NET 11 surfaces a failed BackgroundService here instead of exiting with code 0
    app.Logger.LogCritical(ex, "Host stopped because a background service failed");
    throw;
}

The three adjustments we make most often. The try/catch logs the new failure clearly instead of hiding it.

Approach

How we move a production system to .NET 11

Inventory

Target frameworks, NuGet packages, hosting images, SQL Server versions and the CPUs of on-premises servers. A single package without .NET 11 support often sets the timeline more than your own code.
Retarget

Pin the SDK in global.json, switch to net11.0 and update the packages. Installing the new SDK alone changes nothing. GitHub Copilot app modernization helps with the mechanical part; the .NET Upgrade Assistant is no longer developed.
Check breaking changes

Go through the list above against your code and configuration: exit codes, SQL compatibility level, package references, API clients. If you come from .NET 8, include the changes of .NET 9 and 10.
Test and measure

Automated tests first, then the same load test before and after. Benchmarks on the hot paths show what the upgrade really brings.
Roll out in stages

Staging first, then production with the previous image ready for rollback. In the first days we watch exit codes, health probes and error rates.

Make it a yearly routine

A new .NET version ships every November. Teams that upgrade every year deal with a handful of changes at a time. Teams that wait three years get all of them at once, usually under deadline pressure. We plan the upgrade as a fixed part of the year, aligned with Microsoft's release cycle.

FAQ

Frequently asked questions about the .NET 11 upgrade

Is .NET 8 still supported?

No. Support for .NET 8 (LTS) and .NET 9 (STS) ended on 10 November 2026. Since then Microsoft no longer publishes security patches for either version.

Should we move to .NET 10 or .NET 11?

Both are supported until 14 November 2028. .NET 11 has a year more improvements, .NET 10 a year more patch history. If all your dependencies support .NET 11, we usually recommend it. The next LTS, .NET 12, is expected in November 2027.

Can we go from .NET 8 straight to .NET 11?

Yes. There is no need to install .NET 9 or 10 in between. You do need to review the breaking changes of all three versions together.

Is Runtime Async switched on automatically?

No. In .NET 11 it is an opt-in preview feature, enabled per project with runtime-async=on in the Features property. We wait until it becomes the default before using it in production.

Do Blazor apps need changes?

Usually small ones: obsolete APIs are gone, QuickGrid renders links, and antiforgery validation moves into middleware. New features such as circuit pause or session parameters are opt-in.

What drives the effort of an upgrade?

Mostly dependencies and test coverage, much less the size of the code base. A short inventory of packages, hosting and database versions gives a reliable estimate before any code changes.

Sources

Sources and further reading

Your software

Still on .NET 8 or 9?

We check your dependencies, hosting and the relevant breaking changes, and tell you what the upgrade involves before anything is changed. The same senior team then carries it out.

Plan the .NET 11 upgrade with us

More services

More .NET services

The migration guide

From .NET Framework 4.8 to modern .NET: the terminology, a six-step roadmap and the traps from real projects.

Read the .NET migration guide

Development

ASP.NET Core, Blazor, Angular and React. From the first line to the application in production.

Upgrading to .NET 11: what you gain, and what can break