Friday, March 6, 2026

Grant Riordan shows how OneOf brings F# like discriminated unions to C#, so your methods can return precise outcomes with compile-time checks instead of sprawling hierarchies or surprise exceptions. In this post you get practical patterns for explicit success or failure, polymorphic return types, and stateful workflows using .Match for exhaustive handling that keeps APIs honest and maintainable.

Sai Nitesh Palamakula walks through adding distributed caching to an ASP.NET Core Web API using Azure Managed Redis and the IDistributedCache abstraction to speed up read-heavy endpoints across instances. This post focuses on when Redis is the right tool, how to implement the cache-aside pattern with absolute and sliding expiration, and the practical knobs like LRU eviction and AddStackExchangeRedisCache that move the performance needle.

The basics of Transient, Scoped, and Singleton .NET dependency injection lifetime scopes. This video covers the basics of each scope, including when it's best to use each, when not to use each, and an important reminder of something you should never do when registering your services.

David Gallivan makes the case for building Blazor forms without third-party component bloat by leaning on the power already built into plain HTML inputs. This post shows how to bind native inputs and constraints to Blazor with a little C#, delivering smaller bundles, built-in validation, and a modern UX without extra dependencies.

Kavathiyakhushali shows how to build durable AI agents in .NET with the Microsoft Agent Framework on Azure Durable Functions so your C# workflows can pause, persist state, and resume. This post highlights the orchestration pattern and minimal setup, and why this approach fits real world automation and multi step processes.

Sneha Kumar shows how to build a gated multi-step registration wizard in .NET MAUI with Syncfusion Tab View, turning tabs into a state-driven workflow that only unlocks after validation. In this post you will pick up patterns that reduce form fatigue like state-controlled tab visibility, real-time validation, and modular views for each step, plus a GitHub sample.

Saurav Kumar explains how threading and parallel programming in .NET can boost responsiveness and throughput, and why modern apps lean on Tasks, the thread pool, and Parallel APIs. This post focuses on choosing the right tool for I/O vs CPU workloads and avoiding gotchas like oversubscription, blocking, and unsafe shared state, so your code stays fast and sane.

Ali Hamza Ansari walks through building a multi-tenant rate limiter in ASP.NET Core 10 using the native throttling middleware in .NET 10 and C# 14, with a tenant resolver and token bucket partitions keyed by X-Tenant-ID. This post shows how the updated AddRateLimiter and UseRateLimiter simplify fair-use controls, reduce third-party dependencies, and keep noisy neighbor problems in check for real-world SaaS APIs.

Cloudmersive shows how to plug AI driven document classification into C# and .NET, turning single type upload portals into smart intakes that handle resumes, cover letters, and more. In this post you install the Cloudmersive Document AI SDK, send an InputFile with category definitions, and read back a classification plus confidence to drive routing in your workflows.

Nick Cosentino walks through the Builder pattern in C#, showing how step by step construction tames telescoping constructors, complex initialization, and immutable models while keeping APIs fluent and readable. This post uses relatable examples from custom pizzas to query builders, calls out pitfalls and best practices, and maps the pattern to real .NET tooling like StringBuilder, EF Core, and configuration so you know when to reach for it and when to keep things simple.

WitShells shows how to keep Unity scenes smooth by offloading heavy work to background threads with ThreadManager, a lightweight C# package for jobs and progress reporting. This post focuses on a reusable pattern using a small worker pool, typed ThreadJob, QuickThreadJobs one-liners, and safe main-thread callbacks to keep gameplay and UI responsive.

The C# Alchemist walks through applying Clean Architecture to .NET MAUI so you can dodge the Massive ViewModel trap and keep business rules clear of UI concerns. This post outlines the domain, application, infrastructure, and presentation layers with DI glue, highlighting how decoupling boosts testability, maintainability, and even makes platform or data store swaps far less painful.