Friday, February 13, 2026

Ricardo Peres highlights a subtle ASP.NET Core pitfall where the Consumes attribute treats Content-Type and charset as an exact match, which can route requests to nowhere and return a 404. Helpful for API authors chasing sneaky 404s tied to content negotiation.

Milan Jovanović follows message ordering from first principles and shows why most systems need per aggregate ordering, not a global sequence. This post moves from domain events and an Outbox for reliability, through the pitfalls of competing consumers, to sagas as the way to model ordered workflows at scale in .NET, with broker features like Service Bus sessions and Kafka partitions helping but not replacing good patterns.

Chris Woodruff distills how Front Controller and MVC keep ASP.NET Core from devolving into a crowd of tiny frameworks pretending to cooperate. In this post he treats the pipeline as a disciplined gateway for auth, logging, and errors, keeps controllers thin, and shows minimal yet clear examples that centralize cross-cutting concerns. You get before and after code, a compact custom middleware router, and practical advice on when the structure pays off versus when to stay simple.

Damien Bowden demonstrates how to make your .NET apps care about how users authenticated by implementing Level of Authentication with ASP.NET Core Identity and Duende. This post clarifies amr vs loa, issues loa and loi claims on passkey sign-in, and uses DPoP with an authorization handler to allow only phishing resistant sessions to reach your API. Expect practical patterns for Blazor OIDC, Duende profile services, and a small fix for the passkey amr quirk.

Bjoern Meyer walks through converting Markdown to PDF in .NET using TX Text Control, powered by the TXTextControl.Markdown.Core package and ServerTextControl. This post explains why PDF still rules for distribution, then shows a quick start and how to programmatically control page layout, headers and footers, and styles for production-worthy output. If you need Markdown in and branded, accessible PDFs out, the examples are ready to plug into APIs or workflows.

Nate Bennett shows a fast, Office-free way to read Excel in C# using Spire.XLS. The payoff is simpler deployments and better performance than COM interop across different environments.

Leomaris Reyes explains marshal methods in .NET MAUI as your app's interpreter between managed C# and native OS APIs, and why that matters when you tap into device features. This post spotlights .NET 10 updates that affect Android: marshal methods enabled by default for faster startup and a new ArtifactFilename metadata to handle quirky Maven AAR/JAR names. If you ship MAUI apps, you will pick up practical tips on diagnosing startup freezes and keeping Java dependencies reliable.

Janindumaleesha kicks off a beginner-friendly C# series with a plain-English tour of what C# is, how it sits on the .NET platform, and why it is a practical choice for building apps and games. If official docs feel overwhelming, this post sets a low-friction path to installing tools next and turning curiosity into working code.

Steven Giesel explores a C# 15+ proposal that lets collection expressions accept arguments, like capacity or comparers, right in the brackets. This post connects the ergonomic C# 12 syntax with practical needs like pre-sizing lists or setting a HashSet comparer, which can reduce allocations and make intent clear.

Round The Code shows how to add tidy file logging to ASP.NET Core with Serilog, from wiring up UseSerilog and a file sink in appsettings.json to logging from a Minimal API with ILogger. If you want clean rolling log files with a readable template and the right signal to noise, this is a quick win.

Bjoern Meyer shows how to turn messy contract redlines into review ready explanations using .NET C#, TX Text Control, and the OpenAI API. This post pairs tracked changes with their related comments, streams the context to an LLM, and enforces a strict JSON schema so every change is justified or flagged with confidence and evidence.

Sparkle Web maps out a practical path to high performance microservices on .NET 10, starting with design choices like single responsibility, stateless services, and a database per service. Ideal if you want to ship services that scale smoothly without trading off reliability or developer sanity.