Friday, January 16, 2026

C# 14 widens the "partial" bridge by letting you split instance constructors and events into defining and implementing declarations. The post unpacks the strict one-and-one pairing, why partial events are deliberately not field-like (custom add/remove only), and the real win for source generators clean separation of API surface from generated plumbing for weak events, interop, and bindings plus gotchas around lookup/metadata, signature matching, attributes, and docs.

Azure Cosmos DB's Linux-based vNext emulator gets a serious tune-up: a more capable query engine (nested/cross JOINs, string/array operators, cleaner subdocument handling) and first-class OpenTelemetry so you can trace, log, and grab metrics locally like production. The post shows practical queries, Docker Compose wiring for Jaeger/Prometheus, and health probes that pair nicely with Testcontainers handy for .NET devs validating complex data access patterns and CI pipelines without touching the cloud.

Chris Woodruff demystifies the Identity Map for ASP.NET Core Minimal APIs with the rule of thumb: one database row, one in-memory object. He shows how EF Core's DbContext already provides this behavior, why multiple DbContexts and AsNoTracking can cause subtle lost-update bugs, and walks through a before/after refactor that aligns Identity Map with a Unit of Work. For non-tracking data access, he includes a lightweight C# identity map and a Dapper-friendly unit of work to keep your customer from turning into three people during a single request.

This practical series makes backend dev feel less like framework wizardry and more like solid C#: it starts by contrasting .NET Framework vs .NET Core, then digs into production-grade fundamentals OOP in the real world, delegates/events/lambdas, extension methods, generics, and LINQ. Part 1 lays out the roadmap with bite-size explainers and tees up performance-minded topics next (EF Core + LINQ, async/await, GC) so your services behave predictably when traffic and data grow.

This guide demystifies Redis for .NET devs covering its in-memory speed, data structures, persistence, pub/sub, TTLs, and clustering with practical StackExchange.Redis snippets. The real value is architectural: wire Redis into Clean Architecture by putting it in Infrastructure behind an ICacheService and keeping controllers blissfully unaware. Round it out with production-minded tips like TTLs, payload limits, a singleton ConnectionMultiplexer, and Azure Redis to shave load off your database and keep things snappy.

By replacing string.Split with ReadOnlySpan slicing and a small ref struct, this log parser goes 3x faster while allocating just 470 bytes on 100k lines GC basically takes a coffee break. It's a practical tour of zero-allocation string processing in .NET, showing how spans and stack-friendly types tame memory churn in real-world workloads.

A tour of ASP.NET Core in .NET 10 that focuses on production-ready refinements: passwordless Identity with passkeys, richer built-in OpenTelemetry metrics, smarter memory behavior for long-running services, and thoughtful polish across Minimal APIs, OpenAPI, and Blazor. With concrete snippets (passkey setup, SSE streaming, YAML OpenAPI, reusable validation), it leans into "simple by default, extensible when needed" ergonomics while tightening security and observability. If your APIs hum 24/7 or your Blazor app has grown up, this is less yak‑shaving and more shipping.

Time zones look easy until your nightly job runs an hour early and users see "future" timestamps. This .NET explainer shows why offsets, DST, and historical rule changes make date-time tricky, and lays down the golden rule: store and transmit UTC, convert to local time only at the edges (like the UI). A practical primer to keep data consistent across systems and your users' clocks sane.

Recep Serit breaks down why mixing SQL Server and NoSQL in a single TransactionScope doesn't fly in .NET NoSQL drivers skip MSDTC/2PC, turning dual-writes into a consistency trap. He demonstrates the Transactional Outbox pattern with EF Core: commit your change and an Outbox row atomically, then let a background worker forward to NoSQL or a broker for at-least-once, eventual consistency. A practical, beard-friendly blueprint for polyglot persistence without distributed transaction drama.

Empty collections sneaking into your business logic? This explainer introduces NonEmptyList for .NET 6/8 a type-safe collection that guarantees at least one element then walks through head/tail deconstruction, Map/FlatMap, seedless Reduce, async/parallel helpers, an immutable variant, and serialization/EF Core integration. A realistic order-processing pipeline shows how moving "non-empty" into your types shifts failures to the compiler and keeps your LINQ honest.

Ajay Kumar shows how TDD makes refactoring in .NET feel safe, turning 300-line if-fests into small, testable pieces. Through clear C# examples extracting a DiscountCalculator, introducing shipping strategies, and writing characterization tests he leans on Red-Green-Refactor, practical patterns, and tools like Stryker.NET to prevent regressions. A friendly, test-first playbook for trimming duplication and fixing bugs once across your codebase.

EF Core 10 adds LeftJoin and RightJoin LINQ operators, letting you express joins with far less ceremony than the old GroupJoin + DefaultIfEmpty + SelectMany pattern. The post shows the before-and-after code along with the SQL EF generates, making the readability and correctness gains crystal clear. A tidy quality-of-life upgrade for anyone tired of re-remembering left-join gymnastics in LINQ.