.NET 11 Finally Fixes the Process API

Emiliano Montesdeoca — Tue, 26 May 2026 00:00:00 +0000

Every .NET developer who has ever needed to spawn a process and capture its output has written some variation of the same dangerous boilerplate: async read from stdout, async read from stderr, WaitForExitAsync, don’t forget to drain both streams or you’ll deadlock. It’s a well-known trap that’s been there for years.

.NET 11 finally fixes this properly.

RunAndCaptureTextAsync

The headline addition: a single static method that starts a process, captures stdout and stderr, and waits for exit without deadlocking.

var result = await Process.RunAndCaptureTextAsync("dotnet", "--version");
Console.WriteLine(result.StandardOutput);

One call. No manual stream draining. No carefully positioned WaitForExit. If you just need to run something and get its output, this is the API you want.

There’s also Process.RunAsync for the case where you want to wait for exit without capturing output.

KillOnParentExit

A common problem with spawned processes: if the parent crashes or is killed, child processes keep running as orphans. KillOnParentExit lets you declare at process start time that the child process should be terminated when the parent process exits.

This is a feature that’s existed in platform-specific ways (job objects on Windows, prctl on Linux) but required p/invoke or third-party libraries to use from .NET. Now it’s a first-class property on ProcessStartInfo.

SafeProcessHandle-Based APIs

The new lightweight API surface is built around SafeProcessHandle rather than the full Process class. The full Process class carries a lot of state and is difficult to trim — the SafeProcessHandle path is more trimmer-friendly for applications that need to minimize output size (WASM, native AOT).

Full Control Over Handle Inheritance

The update also adds fine-grained control over which handles a child process inherits and how standard handles are redirected. Previously you could redirect stdin/stdout/stderr but couldn’t specify exactly which handles to inherit at the OS level. The new APIs expose that control.

Why This Matters

The Process class is used in tooling, build systems, test runners, and any application that shells out to other executables. The old API surface dated back to .NET Framework and was showing its age. This isn’t a breaking change — the old APIs still work — but new code should prefer the new surface.

For trimmed applications or AOT compilation scenarios, the SafeProcessHandle path is particularly welcome. The old Process class brought in a lot of reflection-heavy code that complicated trimming.

Original post: Process API Improvements in .NET 11

.NET 11 Preview 4: MCP Server Template, Runtime-Async Libraries, Process API

Emiliano Montesdeoca — Mon, 25 May 2026 00:00:00 +0000

.NET 11 Preview 4 is available. Every release of a major .NET preview adds a long list of items across the runtime, SDK, libraries, ASP.NET Core, MAUI, C#, and Entity Framework. Rather than repeat the full list, here are the things that stand out to me.

MCP Server Template Ships in the .NET SDK

The single most interesting item: an MCP Server project template is now included in the SDK. That means dotnet new mcp-server (or whatever the command ends up being) works out of the box. For anyone building MCP tooling in .NET, this removes the bootstrapping friction considerably. MCP integration in the platform toolchain signals the direction the ecosystem is heading.

Runtime Libraries Compiled with Runtime-Async

The runtime itself now compiles its standard libraries using the runtime-async feature. This is an internal change that affects performance — async state machines in the runtime become more efficient. The significance here isn’t user-visible API changes; it’s that runtime-async is mature enough to be used for the BCL itself, which is a meaningful signal about the feature’s readiness.

JIT Optimizations and Hardware Intrinsics

Preview 4 continues the JIT work. Hardware intrinsics and code generation improvements ship here — details are in the runtime release notes. These are typically the kind of changes that improve throughput on tight computation loops without any code changes on your part.

Process API Expansion

A major update to System.Diagnostics.Process ships in Preview 4:

Process.RunAndCaptureTextAsync — start a process, capture stdout/stderr, wait for exit, all in one call without deadlock risk
KillOnParentExit — lightweight lifetime coupling between parent and child processes
SafeProcessHandle-based APIs that are more trimmer-friendly

If you’ve ever written boilerplate to capture process output without hitting deadlocks (async read from stdout and stderr simultaneously), RunAndCaptureTextAsync is the API you were missing.

dotnet watch for Android and iOS

dotnet watch now supports device selection for .NET MAUI Android and iOS projects. Faster iteration on mobile without manually managing device connections in the build loop.

Span-based Compression APIs

New span-based Deflate, ZLib, and GZip encoder/decoder APIs ship in the libraries. Less allocation when dealing with compressed data — relevant if you’re doing high-throughput data processing.

Try It

Download .NET 11 Preview 4 — it’s a preview, not production-ready, but worth running against your projects to catch any issues early before the RC cycle.

Original post: .NET 11 Preview 4 is now available!

.NET 11 | The .NET Blog