.NET 11 RC 2: Changes to the Runtime, SDK, and ASP.NET Core

.NET 11 Release Candidate 2 brings improvements across the runtime, SDK, libraries, build system, and web development stack. Rather than introducing one major change that affects every application, this release focuses on several targeted improvements that developers can evaluate individually.

The release includes incremental CBOR reading APIs, configurable initial HTTP/2 concurrency, faster MSBuild wildcard matching, NuGet package-age configuration through the command line, and additional ASP.NET Core improvements. F# developers also receive runtime asynchronous programming support and several compiler and library enhancements.

.NET 11 RC 2 was announced on October 13, 2026, and includes a go-live support license. This makes it possible to evaluate the release in production scenarios under its applicable support terms, although teams should still complete their normal compatibility and deployment checks before upgrading critical applications. <Cite refs={["turn317496search0"]}/>

This article explains the most relevant changes, demonstrates practical usage patterns, and outlines what developers should test before moving an existing application to .NET 11 RC 2.

What's New in .NET 11 RC 2?

The release covers several parts of the .NET development platform. Understanding which component contains a change helps developers determine whether it affects their application directly.

Component	Notable change	Practical benefit
.NET libraries	Incremental CBOR reading	Process binary data without requiring an entire input document at once
HTTP libraries	Initial HTTP/2 concurrency configuration	Control connection-level request concurrency behavior
Runtime	File locking disabled by default on iOS and tvOS	Changes platform-specific file-locking behavior
SDK	MSBuild properties in launch-profile arguments	Improve development-time launch configuration
MSBuild	Faster wildcard matching	Reduce project evaluation overhead in applicable builds
NuGet	Configure minimum package publication age from the CLI	Add a package supply-chain control
F#	Runtime asynchronous support	Expand asynchronous programming capabilities
ASP.NET Core	QuickGrid virtualization APIs are no longer experimental	Use the APIs with a more stable support status

These highlights come from the official RC 2 announcement. Not every change affects every project, and developers should consult the release notes for details about individual APIs and platform limitations. <Cite refs={["turn317496search0"]}/>

Runtime and Library Improvements

Reading CBOR Data Incrementally

CBOR, or Concise Binary Object Representation, is a binary data format used in applications that need compact structured data. It is useful in scenarios such as device communication, protocol implementations, and systems that exchange structured messages.

Traditional processing approaches may require an application to accumulate a complete input document before decoding it. Incremental reading allows supported APIs to process data as it becomes available.

This is useful when working with large messages or network streams because the application can avoid building unnecessary intermediate buffers.

For example, a basic stream-reading pattern in C# looks like this:

using System.Buffers;

public static async Task<byte[]> ReadStreamAsync(
    Stream stream,
    CancellationToken cancellationToken = default)
{
    using var output = new MemoryStream();
    byte[] buffer = new byte[8192];

    while (true)
    {
        int bytesRead = await stream.ReadAsync(
            buffer.AsMemory(),
            cancellationToken);

        if (bytesRead == 0)
        {
            break;
        }

        await output.WriteAsync(
            buffer.AsMemory(0, bytesRead),
            cancellationToken);
    }

    return output.ToArray();
}

This example demonstrates ordinary asynchronous stream reading, not the new CBOR-specific API. It still accumulates the complete input in memory.

The benefit of incremental CBOR processing comes from using the new CBOR reader APIs to parse data progressively rather than treating the entire payload as one document. Applications should select the exact API based on whether their input arrives as a complete buffer, a sequence of bytes, or an incomplete stream.

Configuring Initial HTTP/2 Concurrency

HTTP/2 allows multiple streams to share a single connection. The number of concurrently active streams influences how requests share that connection and how quickly a client can begin sending work.

.NET 11 RC 2 adds configuration for initial HTTP/2 concurrency. This gives developers another option when tuning clients for workloads involving many requests.

The appropriate setting depends on the server's advertised limits, request characteristics, connection reuse, and the application's workload. Increasing concurrency does not automatically improve performance: it may increase contention or expose bottlenecks elsewhere.

Before changing HTTP/2 concurrency in production, test representative request patterns and monitor latency, throughput, connection reuse, and error rates.

SDK and Build-System Changes

Faster MSBuild Wildcard Matching

MSBuild evaluates project files and processes items such as source files, resources, and content. Projects that use wildcard expressions can incur overhead while MSBuild determines which files match those expressions.

.NET 11 RC 2 improves wildcard matching during project evaluation. This can benefit solutions with large file sets or many projects, although the actual improvement depends on project structure and build configuration. <Cite refs={["turn317496search0"]}/>

Consider this common project-file pattern:

<ItemGroup>
  <Compile Include="Features/**/*.cs" />
</ItemGroup>

The wildcard includes matching C# files under the Features directory and its subdirectories.

This example illustrates the kind of project expression involved; it is not a benchmark or a claim that this particular expression becomes faster by a specific amount.

Developers should avoid changing wildcard patterns solely to pursue a theoretical improvement. Instead, compare clean and incremental build times before and after upgrading, using the same machine, SDK configuration, and source tree.

MSBuild Properties in Launch Profiles

The SDK also includes improvements involving MSBuild properties in launch-profile arguments.

Launch profiles help configure how an application starts during development. These settings are especially useful when different developers need consistent environment variables, command-line arguments, or application launch behavior.

When upgrading, inspect the existing launch settings and verify that your IDE and command-line workflow behave as expected. A launch-profile change should not be assumed to affect production deployment settings automatically.

NuGet Package-Age Rules From the CLI

Dependency management is an important part of application security. A newly published package may be legitimate, but allowing every new version into a production build immediately can increase exposure to supply-chain risks.

.NET 11 RC 2 allows developers to configure a minimum package publication age from the .NET CLI. The purpose is to provide another control over when newly published packages are considered eligible for use. <Cite refs={["turn317496search0"]}/>

For teams adopting this feature, a practical policy might require packages to have been published for a defined period before they can be accepted into the dependency workflow.

The exact CLI syntax and supported configuration options should be taken from the RC 2 NuGet release notes rather than guessed. Before enabling the policy, verify how it interacts with existing package sources, lock files, dependency updates, and CI pipelines.

A package-age rule also has limitations. It cannot prove that an older package is safe, and an important security fix may be published only recently. Teams should combine package-age controls with vulnerability scanning, dependency review, and a process for handling urgent security updates.

F# and ASP.NET Core Improvements

Runtime Async Support in F#

F# includes language features for asynchronous programming, and .NET 11 RC 2 adds runtime async support that expands the available implementation options.

This is relevant to applications that perform I/O, coordinate concurrent operations, or work with asynchronous workflows.

When evaluating the feature, check the supported syntax, runtime requirements, and compatibility with existing libraries. Do not assume that all existing F# asynchronous code will automatically change its execution behavior after upgrading.

Teams should also review cancellation, exception handling, and resource cleanup when testing asynchronous code.

QuickGrid Virtualization APIs

ASP.NET Core RC 2 removes the experimental status from QuickGrid virtualization APIs. QuickGrid is a component used to display tabular data in Blazor applications.

Virtualization can improve rendering efficiency when a grid contains many rows by rendering only the portion needed for the current viewport, subject to the component's configuration.

This is particularly relevant to administrative dashboards and data-heavy applications.

Before adopting the APIs, test scrolling behavior, data loading, filtering, sorting, and accessibility. Virtualization does not eliminate database costs or guarantee that every large dataset will perform well; the data-access strategy remains important.

How to Evaluate .NET 11 RC 2 in an Existing Project

Step 1: Install the Matching SDK

Install the .NET 11 RC 2 SDK in a development environment or isolated build agent. Confirm the installed SDK with:

dotnet --info
dotnet --list-sdks

These commands help identify the SDK and runtime installations available to the current environment.

Step 2: Update the Target Framework

For a project that you intend to test against .NET 11, update the project file:

<PropertyGroup>
  <TargetFramework>net11.0</TargetFramework>
</PropertyGroup>

The TargetFramework property identifies the framework against which the project is built. Update only the projects that are part of the migration, and verify that all required dependencies support the target framework.

Step 3: Restore and Build

Run the standard build commands:

dotnet restore
dotnet build --configuration Release

Resolve package compatibility issues, build errors, and warnings before moving to runtime testing.

Step 4: Run Automated Tests

Execute the existing test suite:

dotnet test --configuration Release

For ASP.NET Core applications, include integration tests that exercise routing, authentication, serialization, database access, and other critical behavior.

Step 5: Validate Deployment

Test the application in an environment that resembles production. Verify container images, hosting configuration, monitoring, logging, and rollback procedures.

Passing a local build is not sufficient evidence that an application is ready for deployment.

Advantages and Disadvantages

Advantages

Broader platform improvements: The release contains changes across libraries, runtime behavior, build tooling, and web development.
Potential build efficiency gains: Faster wildcard matching can benefit projects that spend significant time evaluating project files.
Additional security controls: NuGet package-age configuration offers another option for dependency governance.
More capable APIs: Incremental CBOR reading and configurable HTTP/2 concurrency support specialized application requirements.
Improved development experience: SDK and ASP.NET Core refinements help developers evaluate updated workflows.

Disadvantages

Migration work: Existing projects still require compatibility testing and dependency validation.
Workload-dependent benefits: Performance improvements vary according to application structure and configuration.
Configuration complexity: New tuning options require testing to determine appropriate values.
Release-candidate considerations: Teams must account for the specific RC version, support terms, and final-release migration requirements.

Common Mistakes and Troubleshooting

The .NET 11 SDK Is Not Detected

Run dotnet --info and verify that the expected SDK is installed and available through the current environment's path. Also check whether a global.json file pins the repository to a different SDK version.

Package Restore Fails After Upgrading

Inspect package compatibility, package sources, and any configured package-age rules. Determine whether a dependency is incompatible with the target framework or has been rejected by the package policy.

Build Performance Does Not Improve

Compare equivalent builds and measure project evaluation separately where possible. A solution dominated by compilation, code generation, or external tools may not benefit substantially from faster wildcard matching.

ASP.NET Core Behavior Changes

Run integration tests against the upgraded application and inspect framework-specific migration notes. Pay particular attention to middleware ordering, authentication, serialization, and hosting configuration.

Summary

.NET 11 RC 2 brings targeted improvements across the runtime, SDK, libraries, NuGet, MSBuild, F#, and ASP.NET Core. The most notable changes include incremental CBOR reading, initial HTTP/2 concurrency configuration, faster wildcard matching, package-age configuration through the CLI, runtime async support in F#, and non-experimental QuickGrid virtualization APIs.

The practical value depends on the application. Teams handling binary data may benefit from the CBOR APIs, large solutions may benefit from build-system improvements, and organizations with strict dependency policies may find package-age configuration useful.

The recommended approach is to evaluate RC 2 against representative workloads, run automated tests, verify deployment behavior, and review the relevant component release notes before adopting each feature. This makes it easier to identify useful improvements without introducing unnecessary migration risk.