Weekly .NET Roundup: .NET 11 Validation and Open-Source Blazor

by TechHub

.NET 11 is ready for serious production validation, while its opt-in Runtime Async preview moves async transformation into the runtime and requires checks for compatibility with reflection-based instrumentation and profiling agents. Infragistics made more than 50 Blazor controls MIT-licensed, and Syncfusion contributed a free MIT-licensed toolkit alongside framework and scaffolding fixes that address rendering, validation, and Identity page behavior. Azure Core 1.63.0 adds mutual TLS proof-of-possession support for .NET authentication, while Visual Studio 2026 adds working-tree comparisons against historical commits, bulk conflict resolution, and opt-in session preservation. Performance benchmarks reinforce the need to test correctness alongside speed, particularly when adopting span iteration or replacing Task with ValueTask.

This Week's Overview

.NET 11 production validation and Runtime Async

.NET 11 is feature complete enough for serious production validation, while Runtime Async remains an opt-in preview. Teams evaluating the release have both application compatibility and runtime behavior to assess.

Production validation readiness

The .NET 11 update points developers toward serious production validation rather than feature exploration alone. For teams preparing an upgrade, that makes testing their applications and dependencies against the release the practical next step.

Runtime-managed async execution

.NET 11 Runtime Async moves async transformation from compiler-generated state machines into the runtime. Projects targeting net11.0 can opt in with runtime-async=on, and the .NET libraries have used it since .NET 11 Preview 4. In one synchronous two-layer benchmark, execution time fell from 21.2 ns to 6.2 ns and allocations dropped from 144 bytes to zero.

Those results describe a specific benchmark, not a general performance guarantee. Runtime-async methods lack AsyncStateMachineAttribute and generated state-machine types, so validation needs to include reflection-based instrumentation and profiling agents that depend on those details.

Blazor gains open-source components and framework fixes

Infragistics and Syncfusion contributed both MIT-licensed components and improvements to the Blazor development experience. Their work spans application UI, framework correctness, scaffolding, and guidance for AI coding assistants.

Infragistics controls and analyzers

Infragistics made more than 50 Blazor controls free and open source under the MIT license for personal and commercial applications. Its contributions extend into ASP.NET Core for .NET 11, where merged analyzers flag unnecessary StateHasChanged() calls and authentication-state usage that can leave stale user information.

Developers adopting Ignite UI in Blazor Web Apps must use an interactive render mode, and Grid Lite requires a separate NuGet package. An Ignite UI skill in the .NET skills repository guides coding assistants through package selection, service registration, theming, and render-mode requirements. A setup scaffolder to automate package installation and application configuration remains under review.

Syncfusion components and validation work

The Syncfusion Toolkit for Blazor provides MIT-licensed UI components that are free for commercial use, without a license key or Community License eligibility. Merged ASP.NET Core fixes address prerendered state on interactive Not Found pages, inherited-model form validation, and QuickGrid diagnostics.

Scaffolding fixes preserve edit-page data when interactivity starts and add configuration needed for scaffolded Blazor Identity pages. Syncfusion also developed and ran more than 60 end-to-end validation scenarios for new .NET 11 Blazor features. Its toolkit setup scaffolder and installation and configuration skill for coding assistants are still under review.

Azure SDK updates authentication and stabilizes Rust database support

The October Azure SDK release adds .NET authentication support alongside identity changes for Python and Java. It also delivers the first stable Cosmos DB release for Rust, with migration requirements for preview users.

.NET certificate authentication

Azure Core 1.63.0 for .NET adds mutual TLS (mTLS) proof-of-possession support for client certificate authentication and the managed identity federated identity flow. This is the release's directly relevant update for .NET applications using those authentication paths.

Python and Java managed identity

Azure Identity 1.26.0 for Python and 1.18.7 for Java add user-assigned managed identity support on Azure Arc-enabled servers. The Python release also fixes a shared-token-cache issue that could return a cached token for another account, making that correction relevant beyond applications adopting the new identity support.

Stable Cosmos DB support for Rust

Cosmos DB 1.0.0 for Rust is the first stable release, alongside the Cosmos DB Client Driver and SDK Macros crates. Projects upgrading from previews must rename three feature flags to their unstable equivalents and replace CosmosCredential::MasterKey with CosmosCredential::AccountKey.

Measuring .NET performance without overlooking correctness

Benchmarks on collection iteration and asynchronous return types show where performance choices can matter. Both articles pair their measurements with constraints that affect how safely developers can apply the results.

List iteration and mutation

BenchmarkDotNet tests on .NET 10.0.12 and .NET 11 RC 1 used 10, 1,000, and 100,000 items on an Apple M4 Pro. At 1,000 and 100,000 items, for and foreach finished within 2% of each other on both runtimes, while span iteration measured 21% to 26% faster than for.

Correctness still determines which approach fits the operation. Safe removal options include RemoveAll, a backward for loop with RemoveAt, or iteration over a copied list. Passing an async lambda to a list's ForEach produces async void work that the method cannot await.

Task and ValueTask trade-offs

A .NET 10 cache-hit benchmark measured 80 bytes allocated per Task call and zero per ValueTask call. Allocation savings do not necessarily mean faster calls: a cited .NET 6 pooling benchmark reduced allocations from 112 bytes to zero while making calls about 2% slower.

ValueTask callers must consume the result once, avoid concurrent awaits, and avoid blocking before completion. The article recommends raising analyzer CA2012 to error severity in .editorconfig to catch misuse. Changing a public return type from Task to ValueTask is also a binary breaking change and changes the caller contract, so it is not a transparent optimization.

Visual Studio updates Git and editor workflows

The Visual Studio 2026 Stable Channel update changes how developers inspect repository history and resolve conflicts. It also includes an opt-in Copilot Chat experience and controls for preserving work between sessions.

Git comparison and conflict resolution

Developers can compare historical commits with the current working tree, including edits still in progress. Git Changes adds Keep All Current and Take All Incoming for multiple conflicted files, folders, or the repository root, allowing a shared resolution choice to be applied in bulk.

Opt-in Copilot Chat infrastructure

The opt-in Copilot Chat experience extends the Copilot SDK foundation to Ask mode, Agent mode, and the underlying chat infrastructure. Developers can choose to try that experience rather than treating it as a default change.

Session preservation

Hot Exit preserves unsaved documents, edits, tab layouts, and window layouts between sessions. It is disabled by default, so developers who want that behavior need to opt in.

Building a physical AI agent with .NET and Aspire

The StackChan walkthroughs connect a physical desk robot to a .NET backend, then add services and agent behavior. Together, they cover the path from visible robot responses to tool-using interactions.

Robot interaction and backend setup

The initial session programs the M5Stack StackChan's expressions and movements and connects it to a .NET backend and dashboard for an end-to-end interaction. The next walkthrough builds the bot's AI backend with .NET Aspire orchestration, adding services and observability for local development.

Agent behavior and tool use

The agent-focused session uses the GitHub Copilot SDK to build an agentic AI experience connected to the .NET and Aspire backend. It explores behaviors and tool use, with the StackChan responding through its display and movements.

Other .NET News

Microsoft Graph v1.0 channel creation requests that omit layoutType will default to Threads instead of Posts, with rollout expected to begin and finish in late November 2026 across commercial, GCC, GCC High, and DoD environments. Announced in Message Center update MC1530957 on October 29, the change leaves existing Teams channels untouched, but provisioning code should set layoutType to "post" to preserve Posts or "chat" to explicitly select Threads.

The Intune team migrated an enrollment service from .NET Framework 4.7.2 to .NET 8 and moved its hosting to Azure Kubernetes Service, with the first Windows enrollment library migration taking one and a half weeks using GitHub Copilot modernization versus roughly six weeks manually. Engineer-owned plans and context notes preserved migration state and supplied internal dependency mappings the agent lacked, while parity validation and the traffic rollout continue after application-layer modernization.

Randomized obfuscation seeds can produce different protected binaries and rename maps from identical source, while changes to intermediate language (IL) and metadata invalidate strong-name signatures applied before protection. The guidance recommends archiving protected binaries with their maps, source-controlling and reviewing protection configuration, running protection through continuous integration and delivery, and checking signatures, rebuilt outputs, and tests against protected assemblies.

Also relevant this week