Editor's note
I put together a deliberately mixed issue this time: architecture, platform updates, and a few deep technical walk-throughs. The NuGet Restore rewrite in .NET 9 is a great look at how the platform team tackles performance at scale, and the keyed DI piece is a practical one for anyone cleaning up service registration. There’s also some useful ASP.NET Core guidance on forwarded headers, which still trips people up in real deployments.
ASP.NET Core middleware, DI, and perf tips
Jasen Fici
April 14, 2025
Rise and shine, code warriors! This Monday, we're shifting into high gear, like a trusty classic car, polished and ready to tackle the road ahead. As you sip your coffee and get ready to navigate the bustling lanes of .NET development, remember that each article in today's lineup is a turbo-charged engine waiting to speed up your coding prowess. So, fasten your seatbelt and let's breeze through some top-tier insights to kick off a productive week!
Today's Articles
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Jasen's take on today's picks
Return Streams Better in .NET: A Senior Engineer’s Perspective
Great practical advice on streaming APIs and where returning streams can make your code better or worse.
Design Patterns in C#: Advanced Examples and Real-World Use Cases
Solid pattern examples with enough real-world framing to be worth a skim even if you know the classics.
Interesting idea for tamper-evident logging, though the real-world tradeoffs will matter a lot here.
Announcing Hybrid Search with Semantic Kernel for .NET
Semantic Kernel keeps growing into a more useful app layer for retrieval and search scenarios.
If you’ve spent enough time in .NET
A good reminder that long-time .NET habits can become invisible until they bite you.
Understanding the Dependency Inversion Principle (DIP) in SOLID Design
DIP is one of those principles worth revisiting when code starts getting hard to swap or test.
.NET 8 - System.Linq.Dynamic.Core – using SQL LIKE
The SQL LIKE angle with Dynamic LINQ is niche, but it’s the kind of thing people actually need.
Configuring ASP.NET Core Forwarded Headers Middleware
Forwarded headers are simple on paper and easy to misconfigure in front of proxies and load balancers.
Stop Overwriting Your Services: The Case for Keyed DI in .NET 8
Keyed DI is a nice addition when multiple implementations start crowding the same service contract.
Still Using Async Like This? 5 Mistakes That Hurt Performance
Async mistakes still show up in production code, and performance costs add up fast.
Software Architect’s Vision on .NET 9
Worth reading for the platform perspective alone, especially if you care where .NET 9 is headed.
How we ended up rewriting NuGet Restore in .NET 9
The NuGet Restore rewrite is a rare behind-the-scenes look at a high-impact engineering effort.
A basic algorithm refresher, but sometimes that’s exactly the right thing in a varied lineup.
The Dark Side of C#: Common Pitfalls Even Senior Developers Fall Into
Senior developers still fall into the same traps; the difference is usually scale, not awareness.
Real-Time Video Chat with .NET & Blazor: A Full-Stack Developer’s Guide
Blazor plus real-time video chat is a good example of how far the stack can stretch.
Unlock C# Performance: Deep Dive into Ref Structs with Detailed Examples
Ref structs are powerful, but this is the kind of performance topic you want to approach carefully.