Performance improvements in .NET 11

Performance improvements in .NET 11
about 4 hours by Stephen Toub

.NET 11 brings hundreds of small performance improvements across the runtime and libraries. The JIT generates faster code by removing unnecessary checks, allocations, and indirections. A major change, runtime async, lets the runtime optimize async/await more effectively, reducing tasks, allocations, and execution time. Other improvements cover memory safety, collections, networking, JSON, I/O, threading, and more.

Webhooks Suck
sponsored by Svix

Consuming webhooks is a giant pain, and yet, every integration relies on their existence. Tom explains why this is the case and how he solved most of those problems in practice. This is likely going to increase in relevance as AI workflows and chains increasingly depend on webhooks to react to events from third-party services.

Scratch a simple data model, find a complex one
14 minutes by Jon Skeet

Modeling Bible text looks simple at first but quickly runs into real world exceptions. Verse ranges, missing verses, out of order chapters, and books like Greek Esther that split and repeat chapters all break basic assumptions. Jon's advice is to decide how much accuracy you actually need, then pick the simplest model that handles it without crashing.

Use C# unions and closed hierarchies in ASP.NET Core
14 minutes by Dmitrii Korolev

C# 15 and .NET 11 introduce native union types, letting a single type hold one of a fixed set of types, such as an int or a string. The compiler enforces exhaustive pattern matching, so adding a new case immediately flags any switch that doesn't handle it. For new APIs where all cases share a common base class, a closed hierarchy with a JSON discriminator is often a better fit. Unions shine when the contract is already discriminator-free or the case types are unrelated primitives or existing types you don't control.

Understanding Device Bound Session Credentials
11 minutes by Andrew Lock

Andrew provides an introduction to Device Bound Session Credentials. He describes the problem they're trying to solve, how the protocol works, and what you need to do to support them.

Optimistic vs pessimistic concurrency in .NET
19 minutes by Anton Martyniuk

Two requests read the same database row, change it, and write it back. The second write silently erases the first. No errors appear, but the data is wrong. Two main fixes exist. Optimistic concurrency adds a version token to each row and fails the write if the token changed since you read it. Pessimistic concurrency locks the row upfront so others wait their turn. For simple counters, one atomic SQL statement removes the gap entirely.

And the most popular article from the last issue was:

• Less known LINQ methods