Podcast Summaries

← All summaries

ASP.NET Core in 2026 with Daniel Roth

.NET Rocks · Carl Franklin, Richard Campbell — Daniel Roth · April 2, 2026 · Original

Most important take away

ASP.NET Core in .NET 11 is filling critical feature gaps — async validation across the stack, client-side validation for static server-side rendering without interactive modes, Blazor circuit pause/resume from the server, and .NET-based web workers for background processing. The overarching message is that ASP.NET Core is consolidating around Blazor and minimal APIs as the recommended modern stack, while maintaining full support and compatibility for MVC and Razor Pages users.

Chapter Summaries

1996 Year in Review

Carl and Richard walk through historical events of 1996 (tied to episode 1996), covering major news events, technology milestones like the Palm Pilot, USB, Java Development Kit 1.0, ICQ, and space missions. They also cover top albums, movies, and gaming releases from that year.

Better Know a Framework: Delta by Simon Kropp

Simon Kropp’s tool Delta implements HTTP 304 Not Modified responses using database change tracking. It generates ETags from last-updated timestamps, reducing server load when data hasn’t changed.

Listener Comment: NeoVim and Terminal Tools

A listener comment from Moeid Hattot about using NeoVim with .NET via PowerShell and terminal-based tools (Zoxide, PSReadLine, JQ, LazyGit). The hosts note this was prescient given the current shift toward CLI-first development with AI agents.

.NET 10 Recap

Daniel Roth recaps .NET 10 highlights for web development: significant performance and memory improvements, new C# features (extension members, file-based apps), Blazor-specific metrics and tracing, WebAssembly diagnostic tools, and declarative persistent component state. GitHub Copilot app modernization tooling can automate version upgrades.

.NET 11 Roadmap: Addressing Pain Points

The team is tackling top-requested backlog items. The headline feature is async validation coming to minimal APIs, Blazor, and pushed down into System.ComponentModel.DataAnnotations so it becomes first-class across the entire stack. This will work with existing C# async patterns and benefit from runtime async when it lands.

.NET 11: Fundamentals and Performance

Continued performance work, security improvements, expanded passkey support, and more observability/tracing in collaboration with the Aspire team. The modern stack (minimal APIs, Blazor, SignalR) gets primary investment; MVC and Razor Pages remain supported but are not the innovation focus.

.NET 11: Blazor Circuit Pause/Resume from Server

.NET 10 introduced client-side circuit pause/resume. .NET 11 adds server-side policies — for example, persisting all active circuits before a server restart and resuming them when the server comes back. This addresses scaling concerns about Blazor Server by freeing resources for idle users.

.NET 11: Static Server-Side Rendering Improvements

Blazor is filling gaps for developers coming from MVC/Razor Pages: temp data support, session state, tag helper equivalents, and client-side form validation without requiring an interactive render mode — a modern replacement for jQuery unobtrusive validation that will also work with existing MVC and Razor Pages apps.

.NET 11: .NET Web Workers

A new template for running .NET code on browser web workers, allowing CPU-intensive work to be offloaded from the UI thread. Inspired by the Copilot Studio team who built this pattern internally. This serves as a bridge until full Blazor WebAssembly multi-threading ships (blocked by the CoreCLR-based runtime consolidation).

.NET 11: Runtime Async and CoreCLR Consolidation

Runtime async (moving the async state machine from the compiler into the runtime) is a multi-release effort, with much landing in .NET 11. The WebAssembly runtime is being consolidated from mono to CoreCLR, which is also a multi-release effort and a prerequisite for full multi-threading support.

.NET 11: C# 15 Union Types

C# 15 discriminated unions are coming, which will make patterns like returning multiple types from API endpoints more natural and first-class in ASP.NET Core.

.NET 11: Blazor AI Components and AG-UI

The team is building Blazor AI components that implement the AG-UI (Agentic UI) protocol for communication between frontend apps and agentic backends. Built in collaboration with CopilotKit (who wrote the AG-UI spec) and the Microsoft Agent Framework team. Early preview bits are available in the agent framework repo.

Summary

Actionable insights and career advice:

  • Upgrade to .NET 10 now if you haven’t already. You get free performance gains, reduced memory usage, and improved security with minimal code changes. Use GitHub Copilot app modernization tooling to automate upgrades for large solutions.

  • Async validation is finally coming as a first-class feature. If you’re using fluent validation or custom workarounds for async validation (like checking username availability), plan to migrate to the built-in support when .NET 11 ships. It will be available in minimal APIs, Blazor, and the core DataAnnotations layer.

  • Blazor Server scaling is better than you think. Tens of thousands of concurrent users work well on reasonable hardware. With .NET 11’s server-side pause/resume, you can reclaim resources from idle circuits, making the scaling story even stronger. Don’t over-engineer to WebAssembly purely out of scaling anxiety.

  • Static server-side rendering in Blazor is becoming a viable path for MVC/Razor Pages migration. .NET 11 adds client-side validation without interactive modes, temp data, and session state support. If you’re still on MVC or Razor Pages, this is the on-ramp Microsoft is building for you.

  • Learn the AG-UI protocol. Microsoft is betting on it as the standard for frontend-to-agent communication. Blazor AI components implementing AG-UI will ship during the .NET 11 timeframe. If you’re building agentic apps, watch the Microsoft Agent Framework repo for early previews.

  • The CLI-first development trend is accelerating. Terminal-based tools and workflows are becoming more relevant with AI agents. Investing in command-line proficiency (PowerShell, terminal tools like LazyGit, JQ, Zoxide) pays dividends as the industry moves in this direction.

  • Compatibility is a core .NET value. Daniel Roth emphasized that the team takes backward compatibility extremely seriously. You should feel confident investing in the platform — upgrading should accrue value without breaking existing code. The breaking change docs and app modernization tooling help manage the few cases where changes occur.

  • .NET web workers offer a near-term solution for CPU-intensive client-side work. If you need to offload heavy processing from the Blazor WebAssembly UI thread, the new web worker template in .NET 11 provides this capability. Be mindful of memory usage since it spins up a separate runtime instance.