Editor's note
I kept this issue deliberately mixed: fundamentals, tooling, data access, and a few forward-looking .NET 10 pieces. The async articles and the middleware explainer stand out because they tackle bugs and concepts that still trip up experienced teams. I also like seeing practical pieces on configuration and DI alongside the C# 14 and source generators coverage.
ASP.NET Core, async traps, and .NET 10 updates
Jasen Fici
June 10, 2025
Tuesday is here, fellow code wizards, where we peel back the layers and scrutinize the world of .NET with the precision of a master chef perfecting a classic dish. While yesterday's echoes fade, today we delve deeper into the intricacies that transform base code into a work of art. As you sip your coffee and ready your tools, prepare to explore curated gems that promise not just to inform, but perhaps to inspire a gentle 'aha' moment or two. Here's to making every line count, like a well-composed jazz solo, in our quest for .NET mastery.
Today's Articles
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Jasen's take on today's picks
Middleware in ASP.NET Core — Explained Like You’re Coding Daily but Still Unsure What It Does
A solid middleware refresher for anyone who knows the pipeline exists but still wants the mental model to click.
99% of C# Devs Miss This Async Bug — It Crashes Real Apps Silently
Good warning shot on async mistakes; these are the sort of bugs that look harmless in code review and hurt in production.
️ Using CSharpier Per-Solution in JetBrains Rider
Rider + CSharpier is the kind of practical tooling note I like: small setup, big consistency payoff.
Building an Inventory-Management System with ASP.NET 9
Inventory system example is a nice applied ASP.NET 9 walkthrough, not just another toy CRUD demo.
️ Authentication vs Authorization in ASP.NET Core
The auth vs authorization piece earns its place because teams still mix those up in real designs.
From EF Core to Dapper — Is Raw SQL Worth the Hype?
EF Core versus Dapper is always a useful tradeoff discussion when performance or SQL control matters.
Logging in ASP.NET Core Web API Using MongoDB
Logging to MongoDB is unusual enough to be interesting, especially for teams already on the stack.
Stop Misusing async/await: 9 Hidden C# Pitfalls That Slow You Down
Another async article, but from a different angle; the reminder is that async/await still has sharp edges.
Which .NET Mapping Library Should You Use?
Mapping library choices matter more than people admit once teams start standardizing DTO layers.
Don't reinvent the wheel - configuration
Configuration is one of those fundamentals worth re-reading before you build your own helpers.
Run C# File Instantly with .NET 10
Running a C# file instantly with .NET 10 is exactly the sort of quality-of-life feature developers notice fast.
Professional Code and Best Practices with C# 14 and .NET 10
C# 14 and .NET 10 best practices should be a handy checkpoint for what’s current and what’s already stale.
Why Most .NET Developers Miss Out on Azure’s Best Features (And How Not to Be One of Them)
The Azure piece looks aimed at people who use the cloud services only at the surface level.
Guide to Add Custom Modules in ABP.IO App
ABP.IO module extension guidance is useful for teams building on a real application framework.
WebSocket vs REST in .NET: Key Differences and Use Cases
WebSocket versus REST is a practical decision article, not an abstract protocol debate.
On .NET Live - On .NET Live - Source Generators in Jinget
Source generators on .NET Live should be worth watching if you care about compile-time tooling.
Flight Ticketing System with Decorator and Factory Patterns in C#
Decorator and Factory patterns together make a good case study when the example stays concrete.
“Why Is My UI Slow?!” — 7 Killer Techniques to Supercharge .NET App Performance
UI performance tuning is always welcome; slow apps get blamed on everything except the real bottlenecks.
AppSettings & Configuration in ASP.NET Core — What’s Going On?
AppSettings and configuration deserve the deeper treatment because many bugs start there.
Modern C# in 2025: What You Should Be Using (and What to Retire)
Modern C# guidance is helpful when it separates genuinely useful features from the shiny stuff to skip.
Understanding Dependency Injection in .NET
Dependency injection is foundational, and it’s good to see another clear explanation in the mix.
The Cleanest Way to Generate HTML from C#
HTML generation from C# sounds niche, but it’s the kind of utility problem that shows up everywhere.
The Working of .NET Garbage Collection: Heap, Stack, Generations Explained
GC internals are still worth learning; heap and generation knowledge pays off when diagnosing memory behavior.