C# Digest
C# Digest
A fruit fly's brain has 166,700 neurons, and someone ran all of them in C# on a laptop — 11x faster than JS. Separately, EF Core can persist rich domain models without public setters or anemic shortcuts — the ORM was never the real excuse.
ASP.NET Core's new CSRF protection in .NET 11 drops traditional tokens for Fetch Metadata headers — but won't help MVC or Razor Pages users. Also: version 7 GUIDs cause SQL Server index fragmentation due to byte ordering quirks.
Memory dumps can reveal what plain logs miss. A thread pool timing trick can trigger one automatically when your app slows down. Also worth reading: how a brokerage handles 1,900 stock price messages per second using Kafka, Redis, and SSE.
.NET 11 brings massive performance gains — faster JIT, smarter async, and wins across networking, JSON, and threading. Elsewhere, modeling Bible verses reveals how quickly "simple" data gets messy, and C# 15 union types make exhaustive pattern matching a compiler-enforced reality.
LINQ has methods most devs never reach for — Chunk, CountBy, LeftJoin, ToLookup — each replacing messy manual code. Also worth reading: .NET 11 quietly improves Linux containers, crash reporting, and CI/CD performance over flashy features.
AI code gets more reliable when you enforce standards through build rules and static analyzers rather than prompts. Plus: Signal Shingle pre-renders dashboard widgets as cached fragments, so heavy traffic makes the system do less work, not more.
.NET 11's Runtime Async shifts state machine generation from the compiler to the JIT, unlocking new optimizations. Meanwhile, a deep dive into eventual consistency shows why stale data in distributed systems is a design choice, not a flaw — and why ignoring it is the real danger.
Copying blobs between Azure storage accounts? Splitting into blocks and copying in parallel within Azure cuts a 10GB transfer from over an hour to under 10 seconds. Also: Postie simplifies CQRS in ASP.NET Core by mapping commands to routes in one line.
.NET 10 brings built-in passkey support to ASP.NET Core Identity. Separately, a solid rundown of 18 REST API security habits covers HTTPS, JWT validation, and input handling. Cache invalidation patterns and TTL strategies round out the practical picks.
.NET 11 brings some solid speed wins: enum comparisons are 7x faster with zero allocations, timezone conversions doubled in speed, and GUID parsing got 20% quicker. Separately, Anton covers 20 practical ways to fix slow SQL queries — measure first, then act.
.NET interviews now test real scenarios over definitions — like why injecting a scoped service into a singleton corrupts data. Also: BenchmarkDotNet paired with AI turned a branchy encoder into a branchless design, cutting latency from 8.5 ns to 1.6 ns.
.NET 8's `TimeProvider` finally standardizes clock control for tests — pin time, call `Advance()`, and test cache expiry or retries without waiting. Separately, async code won't protect shared data: 20 parallel file writes cause crashes without explicit locks like `SemaphoreSlim`.
Cache stampedes hit when cache misses pile up and flood your database at once. A per-key lock or ASP.NET Core's built-in HybridCache keeps only one request rebuilding while others wait. C# 15 finally adds native union types with exhaustive pattern matching enforced by the compiler.
Frequent GC cycles quietly hurt .NET performance as short-lived objects get promoted to expensive memory tiers. Using Span, ArrayPool, and ValueTask keeps allocations low. Also, strong types can replace repeated validation across API layers, reducing duplicate code and making inputs self-validating from the start.
ASP.NET cookies breaking after IIS restarts? Rick Strahl explains why encryption keys regenerate and how to fix it. Also: .NET 8 and 9 both hit end of support November 2026 — time to move to .NET 10.
EF Core's missing upsert finally gets a proper fix — raw T-SQL MERGE or BulkMerge both work, but always set a business key or records silently duplicate. Also: a version mismatch made dotnet publish deploy an empty package while showing green.
The Outbox Pattern saves messages to your database in the same transaction as business data, then a background job publishes them — no lost events on crash. Also: .NET 10 now prunes redundant NuGet packages, cutting false vulnerability warnings by 70% and restore times by half.
.NET 11 brings the biggest update to `System.Diagnostics.Process` in years, adding deadlock-free output capture and `KillOnParentExit`. EF Core 11 trims split queries, cutting execution time by ~9% and memory use by ~10%.
.NET's messy naming history is actually a survival story — Microsoft rebuilt it from scratch to stay relevant in a Linux and cloud world. Also: HybridCache in .NET 9 quietly solves cache stampedes and multi-server consistency with one simple API.
C# 16 is redesigning the `unsafe` keyword so every unsafe operation must appear in an explicit block with documented caller obligations — making risky code visible instead of hidden. Also worth reading: why factory patterns in ASP.NET often just shuffle complexity around, and how state machines can manage real-world workflows like Uber's trip lifecycle.