DEV Community

Cover image for What's New in ASP.NET Core (.NET 11): Zstandard, HTTP/3, Virtualize & More
Vikrant Bagal
Vikrant Bagal

Posted on

What's New in ASP.NET Core (.NET 11): Zstandard, HTTP/3, Virtualize & More

#dotnet #react #javascript #webdev

Published: April 2026 | Reading time: ~8 min

.NET 11 Preview 3 dropped last week, and ASP.NET Core is shipping some of the most impactful improvements we've seen in a while. Whether you're building APIs, real-time apps, or distributed systems with Aspire, there's something here that'll make your life easier.

Let's dive into the highlights.

1. Zstandard Compression — Finally Native in ASP.NET Core

Facebook's Zstandard algorithm has been making waves in the compression world for years. Now it's finally in the ASP.NET Core box.

Why Zstandard?

  • 20-30% better compression than Gzip at equivalent speeds
  • ~2x faster compression than Gzip at equivalent ratios
  • Lower bandwidth → lower cloud bills
  • Already used in production at Facebook, Cloudflare, and more

Setting it up is dead simple:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true;
    options.Providers.Add<ZstandardCompressionProvider>();
});

var app = builder.Build();
app.UseResponseCompression();
Enter fullscreen mode Exit fullscreen mode

The best part? It works seamlessly with existing middleware. Your JSON APIs, static files, and SignalR responses can all benefit without touching a single line of business logic.

When to use it: API responses, JSON payloads, any content that isn't already compressed. Be careful with content that's already highly compressed (images, videos) — Zstandard can actually increase CPU usage with minimal gain.

2. HTTP/3 — Lower Latency, Starting Now

HTTP/3 has been in preview for a while, but .NET 11 ships a meaningful improvement: the server starts processing requests earlier in the connection lifecycle.

The technical win here is reduced TTFB (Time To First Byte), especially on:

  • Mobile networks with variable latency
  • Connections with packet loss (QUIC handles this better than TCP)
  • Situations where TLS handshake overhead matters 
builder.WebHost.ConfigureKestrel(options =>
{
    options.Listen(IPAddress.Any, 443, listenOptions =>
    {
        listenOptions.Protocol(HttpProtocolType.Http3);
    });
});
Enter fullscreen mode Exit fullscreen mode

What changed: Previously, the server waited for the full QUIC handshake acknowledgment before dispatching the request. Now it starts processing as soon as the client's first request bytes arrive — overlapping the handshake with request processing.

Requirements:

  • TLS 1.3 certificate (Let's Encrypt works great)
  • Client support (modern browsers all support HTTP/3)
  • UDP open on port 443 (check your firewall!)

3. Virtualize Adapts to Variable-Height Items

List virtualization is crucial for performance in data-heavy apps — chat threads, social feeds, admin grids. But the classic challenge? Items with variable heights.

In .NET 11, the <Virtualize> component now adapts to variable-height items at runtime:

<ListView ItemsProvider="LoadMessages">
    <ItemSizeProvider>
        @(context => context.IsLoaded 
            ? CalculateMessageHeight(context) 
            : 50) @* placeholder *@
    </ItemSizeProvider>
</ListView>
Enter fullscreen mode Exit fullscreen mode

This means:

  • No more pre-measuring everything before rendering
  • O(1) virtualization overhead regardless of content variance
  • Smooth scrolling even when message lengths vary wildly

For apps like Teams, Slack, or any chat-like interface, this is a genuine quality-of-life improvement.

4. dotnet watch + Aspire — Dev Loop Gets Smart

If you're using Aspire for distributed cloud-native apps, dotnet watch just got significantly smarter.

dotnet watch --project MyApp.AppHost
Enter fullscreen mode Exit fullscreen mode

In .NET 11, dotnet watch now:

  • Monitors Aspire project dependencies — changes to any service in your app graph trigger appropriate rebuilds
  • Crash recovery — if a service goes down during development, it restarts without killing your debug session
  • Selective rebuilds — only the changed project recompiles, not the whole solution

This is especially welcome for microservices developers who were manually restarting multiple services on every code change.

5. System.Text.Json — More Control, Fewer Workarounds

System.Text.Json has matured significantly. .NET 11 adds finer control over naming policies and property ignore defaults:

var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    PropertyNameCaseInsensitive = true
};
Enter fullscreen mode Exit fullscreen mode

The new additions in .NET 11 give you:

  • More flexible custom naming policies
  • Better control over which properties serialize in inheritance scenarios
  • Improved source generator support for AOT scenarios

If you've been maintaining custom JsonConverter workarounds for these scenarios, it's worth revisiting in .NET 11.

6. Entity Framework Core — Smarter Migrations & SQL Generation

EF Core continues to close the gap with raw SQL performance:

ChangeTracker.GetEntriesForState()

// New API avoids extra change detection passes
var modified = context.ChangeTracker
    .GetEntriesForState(EntityState.Modified)
    .ToList();
Enter fullscreen mode Exit fullscreen mode

Migrations got more control:

  • Better feedback when a migration is invalid
  • Ability to generate idempotent scripts more easily
  • Improved handling of pending model changes

SQL Server JSON APIs:
EF Core now generates native JSON_VALUE and JSON_QUERY calls instead of string manipulation on the client — meaningful performance gains for JSON column queries.

Quick Comparison Table

Feature .NET 9 .NET 11 Impact
Compression Gzip/Brotli + Zstandard -30% bandwidth
HTTP/3 Supported Earlier processing -30-50% TTFB
Virtualize Fixed height Variable height Chat/feed UX
dotnet watch Basic + Aspire, crash recovery Dev speed
JSON Flexible Even more flexible Less boilerplate

Should You Upgrade Now?

Preview 3 is stable enough to test in dev, but wait for GA (November 2026) for production workloads. The migration from .NET 9 should be smooth — these are additive features.

Test specifically:

  1. HTTP/3 compatibility with your TLS setup
  2. Zstandard CPU usage on high-traffic endpoints
  3. Virtualize behavior with your actual dynamic content

What's NOT in This Release (But Worth Noting)

  • Blazor in .NET 11 focuses on stability and perf, not big new features
  • SignalR improvements are subtle — concurrent connection handling
  • Minimal APIs get minor ergonomic improvements

If you're hungry for the big language feature, check out C# 15 Union Types — a separate post, but a game-changer for domain modeling.

What feature are you most excited about? Drop a comment below!

Found this useful? Follow me for more .NET content. I write about ASP.NET Core, C#, and cloud-native development every week.

Lets connect on LinkedIn!

Top comments (0)