Escape Analysis in .NET 10: How the JIT Eliminates Heap Allocations Automatically
The .NET 10 JIT compiler can now prove that many objects never leave their parent method and allocate them on the stack instead of the heap, eliminating GC pressure without any code changes.
[PersistentState] in .NET 10: Blazor Finally Solves the Prerendering State Problem
.NET 10 introduces the [PersistentState] attribute, replacing dozens of lines of manual serialisation boilerplate with a single attribute. It also extends state persistence to services, enhanced navigation, and circuit reconnection.
WebSocketStream in .NET 10: Treating WebSockets Like Any Other Stream
The new WebSocketStream class in .NET 10 wraps a WebSocket in a standard System.IO.Stream, eliminating the frame-management boilerplate that has plagued WebSocket code for years and unlocking the entire stream ecosystem for WebSocket transports.
Global Exception Handling in ASP.NET Core with IExceptionHandler
IExceptionHandler gives ASP.NET Core apps a structured, testable, and chainable way to handle exceptions globally — replacing hand-rolled middleware and scattered try-catch blocks with a first-class framework feature.
CVE-2026-40372: The ASP.NET Core Data Protection Flaw That Demands More Than a Patch
A critical HMAC validation bug in Microsoft.AspNetCore.DataProtection lets attackers forge authentication cookies and decrypt protected payloads. Upgrading to 10.0.7 fixes the code, but key rotation and artifact auditing are essential to close the window fully.
Asp.Versioning Meets Built-In OpenAPI: Versioned API Documentation in .NET 10
Asp.Versioning v10.0.0 brings first-class integration with .NET 10's built-in OpenAPI library, replacing the Swashbuckle-era workarounds with a single AddOpenApi call, automatic per-version documents, and RFC 9745 deprecation headers.
.NET 10 on Ubuntu 26.04: One apt install Away from a Clean Linux Setup
Ubuntu 26.04 LTS ships .NET 10 in the default package archive, ending years of package conflicts and multi-feed confusion. Here is what changed, how to set up your environment, and what the new container images and Native AOT tooling look like.
Writing Node.js Native Addons in C# with .NET Native AOT
Microsoft's C# Dev Kit team replaced their C++ Node.js addons with C# and Native AOT, eliminating Python dependencies and simplifying their build pipeline. Here is how N-API, UnmanagedCallersOnly, and a custom DLL import resolver make it work.
CVE-2026-40372: The Data Protection HMAC Bug That Made Cookie Forgery Trivial on Linux
Microsoft's emergency .NET 10.0.7 out-of-band update patches a CVSS 9.1 flaw in the Data Protection managed encryptor. If you run ASP.NET Core on Linux, your HMAC validation was effectively broken since .NET 10 shipped.
Orleans: The Virtual Actor Framework That Makes Distributed .NET Feel Like Local Code
Orleans turns distributed systems into a problem you already know how to solve. Its virtual actor model lets you write single-server C# that the runtime scales across a cluster, handling activation, placement, and fault recovery behind the scenes.
User-Defined Compound Assignment Operators: The C# 14 Feature That Kills Needless Allocations
C# 14 lets you define instance-level +=, -=, ++, and other compound assignment operators that mutate in place instead of allocating new objects. Here's how they work, when they fall back, and where the pitfalls hide.
LeftJoin and RightJoin: The LINQ Operators That Should Have Existed From Day One
.NET 10 adds first-class LeftJoin and RightJoin methods to both System.Linq and EF Core 10, replacing the infamous GroupJoin-SelectMany-DefaultIfEmpty incantation with something you can actually read.
TypedResults: The Minimal API Return Type That Writes Your OpenAPI Spec for You
TypedResults and the Results<T1, T2> union pattern give Minimal API endpoints compile-time safety, automatic OpenAPI metadata, and cleaner unit tests. Here is how to use them properly and why they should be your default.
XenoAtom.Terminal.UI: A Reactive TUI Framework That Treats the Terminal Like a Real UI Platform
XenoAtom.Terminal.UI brings retained-mode rendering, reactive state binding, and 60+ composable controls to .NET terminal applications. Here is why it is worth your attention if you build CLI tools or dashboards.
Keyed Services in .NET: The Built-In DI Feature You're Probably Not Using Yet
Keyed services bring named registrations to .NET's built-in dependency injection container, replacing custom factories and IEnumerable filtering with a clean, attribute-driven approach that works across the entire ASP.NET Core stack.
The .slnx Solution Format: .NET 10's Quiet Revolution in Project Organisation
.NET 10 makes .slnx the default solution format, replacing the decades-old .sln with clean XML, zero GUIDs, and merge-friendly structure. Here is how to migrate and what to watch out for.
First-Class Span Types in C# 14: The End of Overload Sprawl
C# 14 promotes Span<T> and ReadOnlySpan<T> to first-class citizens with implicit conversions, smarter type inference, and new overload resolution rules that eliminate the need for duplicate API overloads across arrays and spans.
Named Query Filters in EF Core 10: The End of the Single-Filter Workaround
EF Core 10 finally lets you attach multiple named query filters to a single entity type and disable them selectively, replacing the awkward && chaining workaround that has haunted multi-concern filtering for years.
Passkeys in ASP.NET Core 10: Phishing-Resistant Auth Without the Third-Party Dependency
ASP.NET Core 10 ships with built-in passkey support in Identity, bringing WebAuthn registration and authentication into the framework. Here's how it works, what the API surface looks like, and where you'll still need a third-party library.
ASP.NET Core 2.3 End of Support: The Clock Is Ticking on .NET Framework's Last Bridge
Microsoft has announced that ASP.NET Core 2.3 on .NET Framework reaches end of support on April 7, 2027. Here is what that means, why the version number is stranger than it looks, and how to plan your migration.
Mapperly: The Source-Generated Mapper That Makes AutoMapper Feel Like Legacy Code
Mapperly generates object mapping code at compile time using Roslyn source generators, delivering hand-written performance with zero reflection. Here is how to use it and why teams are switching.
HybridCache: The .NET Caching API That Should Have Existed Years Ago
HybridCache combines in-process and distributed caching behind a single API, with built-in stampede protection, tag-based invalidation, and zero-allocation reads for immutable types. Here is how to use it and why it replaces most hand-rolled IDistributedCache code.
The field Keyword in C# 14: Backing Fields Without the Boilerplate
C# 14 introduces the field contextual keyword, letting you add validation, lazy initialisation, and change notification to properties without declaring explicit backing fields. Here's how it works, what it compiles to, and where it falls short.
Server-Sent Events in ASP.NET Core: Native Streaming Arrives in .NET 10
.NET 10 adds first-class Server-Sent Events support with TypedResults.ServerSentEvents, SseItem<T>, and a client-side SseParser. No more hand-rolled text/event-stream responses -- here is how the new API works from endpoint to EventSource.
File-Based Apps in .NET 10: Scripts, Prototypes, and the End of Boilerplate
The dotnet run app.cs feature in .NET 10 lets you run C# from a single file with NuGet references, shebang support, and native AOT publishing -- no project file required. Here is how it works, where it shines, and where the edges still bite.