Newsletter Archive

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.

Getting a string length sounds trivial, but this post digs into what the JIT actually does, benchmarking string.Length, AsSpan and other patterns alongside the guidance behind CA1820 and CA1829. Expect practical takeaways on when Span helps, which checks are fastest in hot paths, and how to silence analyzers without sacrificing readability.

Alice Yang walks through practical patterns for extracting pages from Word documents in C# using Spire.Doc, from grabbing a single page or range to splitting a file into one document per page. The examples and gotchas around zero-based indexing, page vs section, and safe cloning help you automate approvals and conversions without layout surprises.

Gérald Barré shows how to have your NuGet packages include a Software Bill of Materials by wiring up Microsoft.Sbom.Targets and letting dotnet pack embed an SPDX manifest for you. This post frames SBOMs as practical supply chain hygiene that helps with license visibility and audits while keeping your release flow simple.

Mike James digs into multicast delegates and how they power C# events, untangling Delegate vs MulticastDelegate and showing how invocation lists actually behave in real code. Expect practical takeaways like why the last handler returns the value, how += and -= build or trim pipelines, and the gotcha that an exception stops the chain, all backed by clear examples and lambdas.

Matteo Pagani shows how to build a secure MCP server in ASP.NET Core that uses Microsoft Entra for identity, fronted by Azure API Management so agents like GitHub Copilot can call your tools safely over Streamable HTTP. In this post, you wire up C# tools with the MCP .NET SDK, generate OpenAPI, publish to App Service, add OAuth code flow metadata in APIM, and lock down the backend, a practical pattern you can reuse for production agent integrations.

Kalyan Singh Bondili shows a pragmatic way to capture and log ClientConnectionId from SqlConnection in .NET to correlate client connection attempts with Azure SQL diagnostics. This post includes a small console app that emits tidy JDBC-style lines with timestamps and IDs so you can pinpoint intermittent connectivity issues faster.

Damien Bowden shows how to set the amr claim correctly for passkeys with ASP.NET Core Identity in .NET 10 using the OpenID Connect EAP ACR Values so passkey sign ins return pop as expected. This post shares a clean workaround for the current framework behavior and demonstrates requesting phishing resistant authentication with acr_values so LoA and downstream authorization stay accurate.

Mark Downie walks through the Visual Studio 2026 February update that leans into practical AI and diagnostics to keep .NET devs in the flow. This post highlights Copilot powered unit test generation, call stack explanations, and a profiler that runs with your tests, plus a WinForms expert agent, richer IEnumerable DataTips, and faster Razor hot reload that smooths out day to day work.

Viktor Ponamarev walks through how .NET generic math and the INumber interfaces reshape numeric code design, moving from type-switch gymnastics and dynamic to clear constraints and compile time safety. This post highlights when and how to use numeric interfaces to build reusable, fast algorithms across many numeric types, with practical patterns you can apply to sums and other operations without sacrificing correctness.

Lowercasing strings to compare them costs allocations and can break under different cultures (hello, Turkish I). In this video, Michael shows why .ToLower()/.ToUpper() are the wrong tools for comparisons and how StringComparison and StringComparer give you fast, correct behavior. We’ll cover Contains/StartsWith/EndsWith overloads, collection comparers, EF Core caveats, and SQL Server collations. Plus, a tiny benchmark to visualize the allocation difference.

.NET 11 releases big updates to async/await and Nick covers it all in this YouTube video, including performance boosts.

Steven Thewissen shows how upcoming C# expressions in .NET MAUI XAML let you bind with {Name}, use real string interpolation, do inline math, and flip booleans without the usual converter circus, trimming boilerplate and multi-bindings. In this post he notes the feature rides on XAML source generation, is available today behind EnablePreviewFeatures in .NET 10, and even supports inline lambda handlers for quick interactions.