.NET drip Newsletter

.NET drip - May 10, 2026

Sun, 10 May 2026 00:00:00 GMT

Rate Limiting IdentityServer Endpoints

Maarten Balliauw tackles a real-world mishap where a chatty client overwhelmed /connect/token and explains when rate limiting Duende IdentityServer actually helps versus fixing client issues like token caching and lifetimes. In this post you get a pragmatic layered strategy with network throttling, ASP.NET Core rate limiting middleware, and a custom token request validator, plus the trade-offs that keep your auth stack safe without blocking legit traffic.

How to Organize Minimal APIs

Assis Zang shows how to stop Minimal APIs in .NET 10 from bloating Program.cs by treating it as the composition root and pushing endpoints, middleware, and service setup into focused extensions. This post refactors a messy sample and then applies Carter modules to group routes and handlers, yielding a cleaner structure that scales with your app.

YARP as API Gateway in .NET: 7 Real-World Scenarios You Should Know

Anton Martyniuk turns YARP into a practical API gateway playbook for .NET, showing how to wire up ASP.NET Core for routing, load balancing, centralized auth, versioned paths, and BFF patterns with clear code and config. Along the way this post shows why a composable proxy can beat heavyweight gateways in real systems, covering rate limiting, observability with OpenTelemetry and Serilog, and rollout strategies like canaries and gradual migrations.

Boost Your .NET Projects with Spargine: Centralized Time Handling with the ClockType

David McCarter spotlights Spargine's Clock type for .NET 10, a single lightweight API for time that covers local and UTC values, ticks, leap years, and Unix timestamps. This post makes the case for centralizing time logic to avoid scattered helpers, cut subtle bugs, and keep logging, scheduling, and diagnostics consistent across your codebase.

Customizing Validation Messages in Blazor Forms

Héctor Pérez walks through upgrading Blazor form validation UX, moving from built in DataAnnotations with EditForm to Telerik UI for Blazor components you can fully template and style. This post spotlights ValidationSummary, per field ValidationMessage, and a space saving ValidationTooltip, plus a reusable component pattern, so your errors feel on brand without piling on boilerplate.

Accelerating .NET MAUI Development with AI Agents

Syncfusion shares how custom AI agents supercharge .NET MAUI contributions by automating issue reproduction, test creation, and multi model try fix workflows that validate changes across platforms. This post walks through the prompts and reusable skills in GitHub Copilot CLI that cut time per issue by 50 to 70 percent while boosting test coverage and review quality.

Building Workflows with Branching Logic in .NET (Microsoft Agent Framework)

Explore how to build adaptive branching workflows in .NET by pairing Microsoft’s Agent Framework with Azure Durable Functions, using an orchestrator to classify user intent and route to specialized agents. This post offers a clear mental model and C# patterns for wiring up classifier, summary, and answer agents so your apps blend AI reasoning with real business rules.

The Modern .NET Show – The Paper Cuts Microsoft Actually Fixes: A Deep Dive into.NET 10 with Mark J Price

Jamie Taylor chats with Mark J Price about .NET 10 upgrades that turn papercuts into polish, including C# 14 extension members, file-based apps that run from a single .cs file, and ASP.NET Core improvements that remove boilerplate from validation and testing. This podcast also unpacks the new 24 month STS, what Aspire 13 means for polyglot app orchestration, and how AI and MCP can speed up debugging and day to day dev flow.

DPoP Security for .NET APIs with JwtBearer Extensions v1.0.0

Joe DeCock announces Duende.AspNetCore.Authentication.JwtBearer v1.0.0, a drop-in extension that brings DPoP proof-of-possession to ASP.NET Core APIs with minimal setup. This post explains why sender-constrained tokens matter in real systems and shows how to harden endpoints against stolen token abuse with short-lived proofs, replay detection via HybridCache or Redis, and optional server nonces.

.NET drip - May 3, 2026

Sun, 03 May 2026 00:00:00 GMT

ASP.NET Core – TryParse error when using Minimal APIs

Bart Wullems runs into a sneaky Minimal APIs model binding pitfall where a TryParse on a custom Azure DevOps webhook parser triggers an InvalidOperationException due to .NET 6 signature validation. In this post he explains how TryParse-driven binding works and shows a simple rename fix, with a nod to AsParameters for tidier endpoints.

Validating configuration at startup with IValidateOptions in .NET

Bart Wullems shows how IValidateOptions stops silent misconfiguration by validating strongly typed options at startup using the Options pattern and ValidateOnStart. You will see why class based validators beat data annotations and inline delegates for real apps, thanks to cross property rules, named options, and DI friendly checks.

.NET MAUI Community Standup | Introducing maui-labs

David Ortinau and Gerald Versluis host this month's .NET MAUI Community Standup where they explore experimental tools and libraries designed to accelerate mobile development workflows. Then they demonstrate new AI-driven capabilities for testing and managing application interfaces directly from the terminal.

Configuring Claude Code for Real .NET Projects

Matt Mattei shows how to configure Claude Code so it understands your .NET stack, using Uno Platform as the example, by organizing six small files that define permissions, behavior, and integrations. In this post you pick up patterns like pre-approving dotnet and git, adding a format-on-write hook, keeping CLAUDE.md lean, and wiring MCP servers for both docs and runtime insight so the assistant behaves like a teammate.

.NET Rocks! – ASP.NET Core in 2026 with Daniel Roth

Carl and Richard sit down with Daniel Roth to explore the 2026 shape of ASP.NET Core, balancing the steady roles of MVC and Razor with accelerating investment in Blazor, all backed by a public GitHub roadmap. This podcast helps you decide where to place your learning bets and how to influence priorities, with insight into how the .NET and language teams ship features that scale in real apps.

On the proper usage of a custom Win32 dialog class

Raymond Chen walks through a classic Win32 pitfall where a custom dialog class uses the same function as both the window procedure and the dialog procedure, causing DefDlgProc to loop until the stack blows up. This post clarifies how the two roles should cooperate so you can centralize shared dialog behavior without breaking message handling, a handy lesson even when you venture into Win32 from .NET.

.NET CLI Shebangs and Argument Parsing

Bryan Hogan hits a classic CLI gotcha in C# shebang scripts where -v is captured by dotnet run instead of your app. This post explains why that happens and shows working shebangs that include -- or use env -S so your arguments make it to your program without surprises.

Containerize Your .NET Applications Without a Dockerfile

Milan Jovanović shows how to containerize .NET apps without a Dockerfile using dotnet publish, plus practical csproj tweaks for image tags, alpine base images, and ports. In this post he also walks through pushing to registries, wiring it into GitHub Actions, deploying to a VPS with Dokploy, and the rare cases where a custom Dockerfile still makes sense.

WinUI Tips & Tricks for WinForms Developers

Greg Lutz shares practical tips for WinForms developers eyeing WinUI, focusing on the mindset shift to XAML and MVVM, adaptive layouts, centralized styling, and async-first workflows that save you from cross-thread headaches. This post explains what changes in day-to-day coding and why it leads to cleaner, more testable desktop apps, plus what to know about file access in MSIX sandboxes.

.NET drip - April 26, 2026

Sun, 26 Apr 2026 00:00:00 GMT

ASP.NET Core – TryParse error when using Minimal APIs

Validating configuration at startup with IValidateOptions in .NET

.NET MAUI Community Standup | Introducing maui-labs

Configuring Claude Code for Real .NET Projects

.NET Rocks! – ASP.NET Core in 2026 with Daniel Roth

On the proper usage of a custom Win32 dialog class

.NET CLI Shebangs and Argument Parsing

Containerize Your .NET Applications Without a Dockerfile

WinUI Tips & Tricks for WinForms Developers

.NET drip - April 19, 2026

Sun, 19 Apr 2026 00:00:00 GMT

10 New Visual Studio Extensions from Mads

Leslie Richardson hosts Mads Kristensen on this episode of the Visual Studio Toolbox, where Mads shows off 9 new Visual Studio extensions and a new update to an old one.

Introducing NtpTick: A lightweight NTP client for .NET

Jiří Činčura introduces NtpTick, a tiny, dependency-free NTP client for .NET that doubles as a tour of low-level C# features like spans, inline arrays, and System.Buffers.Binary. In this post you get a look at querying NTP servers with a clean API, access to raw packet data for deeper learning, and a hint at future NTS support that makes accurate timekeeping more practical for real apps.

How to JSON Serialize and Deserialize values as DateTime, DateTimeOffset, DateOnly and TimeOnly

Davide Bellone walks through the real headaches of moving dates through JSON in .NET, showing how System.Text.Json happily round-trips DateTime, DateTimeOffset, DateOnly, and TimeOnly when types match. This post zeroes in on the tricky cross-type cases and delivers handy JsonConverter snippets, with notes on DateTimeKind, offset preservation, and choosing a reference date for TimeOnly so your APIs behave in production.

Responsive Layout Strategies Using Blazorise Grid & Breakpoints

Mladen Macanović maps out practical responsive layout strategies in Blazorise in this post, showing when to reach for the Grid for page structure and when Flex utilities shine for local alignment, all with mobile-first breakpoints. You will pick up provider-aware utility patterns, breakpoint sizing fluency, and common anti-patterns to avoid so your Blazor UI stays readable and scalable as features grow.

Force DbContext SaveChanges to throw exception during test

Josef Ottosson shows a clean way to hit failure paths in EF Core integration tests by registering a SaveChangesInterceptor that throws, wired through AddDbContext and resolved from DI. You see how to override services per test with WebApplicationFactory to simulate database errors and verify safe, generic 500 responses without mocking your DbContext.

Post-quantum cryptography for .NET developers

Post-quantum cryptography? in .NET!? Filip W showed us what the future looks like at NDC Security 2026. Delve into the physics and mathematics of quantum computing to understand why it poses a significant threat to current encryption methods. Then explore the new post quantum cryptography standards, specifically from the perspective of the .NET ecosystem, examining practical examples related to data integrity, digital signatures, and secure communication, including end-to-end encryption.

Orchestrating Durable AI Agents in .NET

Walkthrough orchestrating durable AI agents in .NET using the Microsoft Agent Framework and Azure Durable Functions, showing how to wire an orchestrator with activity functions that run agents across multi step workflows. This post highlights why checkpointing, retries, and stateful coordination matter for long running AI pipelines and includes starter code you can adapt to real projects.

Blazor – End of Support for Bootstrap v4 (v26.1)

Elena Peskova details why DevExpress Blazor is ending Bootstrap v4 support in v26.1 after its EOL and how this sets the stage for a more maintainable future. This post highlights affected themes and the concrete steps to shift to Bootstrap v5 so your Blazor layouts keep looking sharp.

Speed Up .NET CI with Test Sharding

Gérald Barré introduces Meziantou.ShardedTest, a .NET global tool that splits your test suite into deterministic shards so CI runs in parallel and you wait only for the slowest slice. This post explains when sharding beats in-process parallelization, the trade-offs to watch, and gives drop-in GitHub Actions and GitLab examples to get you from install to faster feedback.

Windows Community Toolkit - How Microsoft uses Uno Platform to Ship Fast

Michael Hawker shares how the Windows Community Toolkit team rebuilt for WinUI 3 with Uno Platform, moving from a monolith to a shared codebase that ships faster across Windows and the web. This post spotlights WCT Labs running via WebAssembly, source-generated samples and tests, embedded docs, and a tight inner dev loop you can adapt when building cross-framework controls.

.NET drip - April 12, 2026

Sun, 12 Apr 2026 00:00:00 GMT

Building Webhooks in ASP.NET Core: Delivery Guarantees, Retries, and Security

Sudhir Mangla maps out a production-ready blueprint for webhooks in ASP.NET Core, moving from naive HTTP calls to an outbox-backed pipeline with idempotency, per-subscriber ordering, and durable retries. Along the way you get practical patterns for HMAC signing with replay protection, SSRF-safe dispatch with IP pinning, CloudEvents envelopes, Polly v8 resilience, EF Core transactions, plus the logs and DLQ that keep high-volume integrations calm.

Building Webhooks in ASP.NET Core: Delivery Guarantees, Retries, and Security

Changing how ASP.NET generates OpenAPI schema names

Tim Deschryver shows how to stop OpenAPI schema name collisions in ASP.NET by customizing CreateSchemaReferenceId to generate fully qualified schema names and handle nested types. This post explains how duplicate class names across namespaces can break docs and client code generation and demonstrates a tiny options change that keeps your OpenAPI reliable.

Microsoft Adds Custom Copilot Agents for .NET Developers with C# and WinFormsExperts

Edin KapiÄ‡ covers Microsoft's first .NET-focused GitHub Copilot custom agents, C# Expert and WinForms Expert, bringing repository-scoped guidance that nudges developers toward modern C# practices and shields fragile WinForms designer files from overzealous AI. This post shows how to drop agent profiles into .github/agents and use them in VS Code Insiders or experimental Visual Studio builds while highlighting how agent-style assistance can reduce AI-induced technical debt in real projects.

Are exceptions exposing vulnerabilities in your .NET App?

Round The Code digs into how unhandled exceptions can expose cookies, headers, and stack traces in ASP.NET Core when the developer exception page slips into Production. This post compares older Host.CreateDefaultBuilder apps with modern WebApplication.CreateBuilder templates and shows a clean global exception handler using IExceptionHandler and ProblemDetails to return safe, consistent errors.

Inside the AWS SDK for .NET: A Code Quality Wake-Up Call

David McCarter dives into the AWS SDK for .NET and uncovers widespread code quality issues that range from IDisposable misuse and cloned code to performance anti-patterns, all amplified by the pain of analyzing a 400+ project solution in Visual Studio. This post helps you sharpen your dependency-vetting skills with concrete takeaways like enforcing EditorConfig rules, spotting memory leak risks, and simple speedups such as TryGetValue and cached splitter arrays.

FullJoin in .NET 11 - potentially

Steven Giesel previews the proposed LINQ FullJoin that may arrive in .NET 11, showing how a real full outer join keeps unmatched rows from either side and trims away clunky workarounds. This post walks through the tentative API, why the result selector is nullable on both inputs, and where things stand with IEnumerable, Queryable, AsyncEnumerable, and EF support.

XamlToCSharpGenerator - Standalone Avalonia source-generator compiler backend

XamlToCSharpGenerator turns Avalonia XAML into source generated C#, adding compiled bindings, inline C# expressions, event bindings, hot reload, and a shared language service so your XAML and C# play nice together. In this post you learn why teams might swap XamlX for the SourceGen backend and how to opt in with AvaloniaXamlCompilerBackend=SourceGen, along with the NuGet packages and VS Code extension that bring first class live editing and diagnostics.

Minimal APIs After the Hype: What Remains When Boilerplate Is Gone?

Bipin Joshi reflects on Minimal APIs across .NET 6 through 10, showing how their real legacy is resetting the default to simplicity and making architecture a conscious choice again. This post contrasts where Minimal APIs excel with where structure still wins, nudging you toward intentional boundaries and disciplined restraint so lean code does not become a tangle.

Logging in .NET MAUI Apps

Cheesebaron lays out a practical recipe for logging in .NET MAUI using Microsoft.Extensions.Logging as the abstraction, Serilog for sinks and structured data, and Sentry or Firebase to add crucial crash context. This post shows how to wire it into your IoC, choose file and platform sinks, apply filters, and tap source generated logging so mobile apps stay fast while your observability levels up.

WinForms â€” Generate Custom SVG Skin Palettes with AI (v25.2)

Dmitry Tokmachev and the DevExpress WinForms team show how generative AI can turn plain language prompts into cohesive SVG skin palettes that automatically theme every control in a .NET 8 app with v25.2. In this post you get real world scenarios like branding and accessibility, a Microsoft.Extensions.AI based implementation that swaps AI providers with minimal fuss, and a production-ready sample you can add to your solution.

CoreSync - A .NET library that provides data synchronization between databases

Adolfo Marinucci's CoreSync is a .NET library for two way database sync across SQLite, SQL Server, and PostgreSQL that helps you build offline first and multi store apps without heavyweight replication. This post shows how to wire up providers and a SyncAgent, customize conflict resolution and filters, and run sync over HTTP with ASP.NET Core powered by Polly and MessagePack.

Implementing the Strategy Pattern with .NET Dependency Injection

Ricardo Peres shows how to wire up the Strategy pattern using .NET's built-in DI so your app can pick the right implementation at runtime without special plumbing. This post walks through using a factory registration with IServiceProvider and real inputs like environment, authentication, feature flags, or configuration while contrasting it with keyed services to keep consumers simple.

.NET drip - April 5, 2026

Sun, 05 Apr 2026 00:00:00 GMT

How C# Strings Silently Kill Your SQL Server Indexes in Dapper

Kevin Griffin uncovers a sneaky perf killer in Dapper where C# strings default to nvarchar, triggering implicit conversions on varchar columns and turning index seeks into scans. In this post he shows the simple DbType.AnsiString fix with the right length and offers practical ways to spot and prevent it in production.

Minimal APIs: Fix missing OpenAPI response documentation

Round The Code uncovers a sneaky reason your Minimal APIs show incomplete Swagger docs when handlers return IResult, then fixes it with concrete return types and TypedResults that declare real response shapes. This post also shows how to register ProducesValidationProblem and ProducesProblem and add summaries so OpenAPI reliably captures 200, 404, 400 and 500 outcomes for better client generation.

Code opinion: why I prefer avoiding the Async suffix in C# asynchronous methods

Davide Bellone makes the case for skipping the Async suffix in C# method names, arguing that names should describe what the code does while return types and await already reveal how it runs. This post weighs readability and maintainability against convention, explores interface design and breaking changes, and highlights the one place the suffix shines when you ship both sync and async APIs.

The Modern .NET Show: From Zero to 3D: Ben Bowen on TinyFFR’s Rapid .NET Rendering

Jamie Taylor welcomes Ben Bowen to explore TinyFFR, a lightweight modern .NET library that takes you from dotnet new to a spinning, lit 3D scene in a few lines while keeping full control outside a heavy game engine. In this podcast you’ll hear how thoughtful API design and stellar documentation make 3D approachable for C# devs, where it shines for WPF or Avalonia tooling, and what cross-platform lessons and side projects bring back to day-to-day .NET work.

.NET Rocks! - Building Software using Squad with Brady Gaster

Carl Franklin and Richard Campbell chat with Brady Gaster about Squad, a multi-agent approach that turns GitHub Copilot into a collaborative dev team for .NET projects. In this podcast you will hear how specialist agents split responsibilities to keep context small and token use sane, share persistent project memory, and work together to solve real-world app problems.

Why IEnumerable Can Kill Performance in Hot Paths

Ali Hamza Ansari puts IEnumerable under the microscope in this post, showing how it can bog down hot paths compared to List, arrays, and Span when you need raw speed. With clear BenchmarkDotNet tests and practical takeaways, you get a feel for when deferred execution shines and when materialized collections keep throughput snappy.

.NET AI Community Standup: Real-World AI Agent Architecture in .NET

What does a real AI agent application look like beyond Hello World? Using the open-source Interview Coach sample, Bruno Capuano and Justin Yoo explore production patterns for building multi-agent systems in .NET using: - Microsoft Agent Framework - Microsoft Foundry as the model backend - Model Context Protocol (MCP) for tool integration - Aspire for orchestration and observability.

Blazorise 2.0.2 – Accessibility and Stability Improvements

Mladen Macanović shares what landed in Blazorise 2.0.2, a stability and accessibility polish pass that fixes a nasty InsufficientExecutionStackException and tightens keyboard navigation and ARIA behavior in menus and dropdowns. If you build Blazor UIs, this post shows how the patch smooths out DataGrid filters, multi-selects, file picking, and Tailwind visuals with a safe no breaking upgrade path.

Rx.NET v7 and Futures On .NET Live talk and demos

Ian Griffiths breaks down Rx.NET v7 with hands on demos and explains how the new packaging slashes self contained app size by moving UI framework support into separate packages, with analyzer hints to smooth migration. If you're moving to .NET 10, this post shows how built in LINQ for IAsyncEnumerable interacts with System.Linq.Async and how to resolve ambiguous operator errors, with sample repos to explore.

Aspire 13.1.3 Release

Microsoft shipped Aspire 13.1.3, a small patch in the 13.1 line, and this post highlights installer publishing updates contributed by @radical with a link to the full diff from 13.1.2. If you are building with .NET Aspire, these tweaks aim to make installs and distribution more predictable so your environment stays tidy.

ASP.NET Community Standup: Zstandard compression comes to .NET 11

Zstandard (zstd) is a modern, high-performance compression algorithm that's faster than gzip and brotli while achieving comparable compression ratios. In .NET 11, we're adding first-class Zstandard support across the platform, from low-level primitives in System.IO.Compression to built-in HTTP compression in ASP.NET Core. Join Daniel Roth as Radek Zikmund, Software Engineer on the .NET libraries team, walks us through the new APIs and shows off some impressive benchmarks.

.NET drip - March 29, 2026

Sun, 29 Mar 2026 00:00:00 GMT

The Value of Immutability in .NET

Barret Blake makes a practical case for favoring immutability in .NET to cut race conditions, simplify caching, and keep data honest across threads and layers. In this post, he walks through C# techniques like records, init-only setters, immutable collections, and with expressions, plus a builder pattern and guidance on when mutable models still make sense and pitfalls like shallow immutability.

Extend your coding agent with .NET Skills

Tim Heuer introduces dotnet/skills, a set of .NET focused agent skills that bundle proven context and intent so Copilot, VS Code, Visual Studio, and other coding agents handle common C# tasks with fewer wrong turns. This post shows how the skills follow the Agent Skills spec, include lightweight validators to prove they help, and can accelerate debugging and performance investigations by bringing the .NET team's battle-tested workflows into your editor.

.NET Rocks! – Avalonia 12 with Mike James & Matt Lacey

On .NET Rocks!, Carl Franklin and Richard Campbell chat with Avalonia CEO Mike James and Matt Lacey about Avalonia 12 and why it matters for .NET developers building cross-platform UIs. This podcast unpacks the move from Skia to the Impeller rendering engine for smoother mobile performance plus what enterprise editions and Avalonia Accelerate mean for teams shipping desktop, mobile, and embedded apps.

How to Avoid Code Duplication in Vertical Slice Architecture in .NET

Anton Martyniuk shares a pragmatic playbook for keeping Vertical Slice Architecture fast without drowning in duplication, reframing DRY as shared knowledge and favoring WET until real patterns appear. In this post you will learn how to centralize truly technical concerns, keep business rules in your domain, and use EF Core, specifications, and small capabilities to reduce repetition without coupling slices.

Aspire Conf 2026

Aspires first online developer conference, #AspireConf, was live for a packed day of sessions for every skill level. Regardless of language, Aspire Conf was all about how Aspire can transform the way you build and deploy your distributed apps and agents.

Your C# Logs Are Lying to You. 7 Hard Lessons From a 3 A.M. Production Disaster

Ashok Reddy recounts a 3AM production outage where walls of INFO, missing timestamps, and zero correlation left the team blind to a DI scope misconfiguration. This post turns that pain into seven practical logging patterns for .NET and C#, from structured events with request and correlation IDs to cleaner log levels and consistent context that make real outages faster to diagnose.

What’s New in Uno Platform Hot Design

Uno Platform 6.5 Release brings UX refresh to Hot Design experience. Sam Basu shows off Hot Design with Hot Reload in Uno Platform Studio, a walkthrough of Hot Design experience prior to Uno Platform 6.5, and what's changed in UnoPlatform 6.5.

How C# Strings Silently Kill Your SQL Server Indexes in Dapper

Kevin Griffin uncovers a sneaky performance trap in Dapper where passing a C# string maps to nvarchar(4000), forcing SQL Server to apply CONVERT_IMPLICIT on varchar columns and skip your index. In this post he shows how matching parameter types with DbType.AnsiString or DbString turns scans into seeks and slashes CPU, along with simple ways to find and guard against the issue in real apps.

The Modern .NET Show – From YAML Chaos to C# Clarity: Mattias Karlsson on CakeBuild

Jamie Taylor chats with Mattias Karlsson about Cake, the C# build orchestrator that replaces fragile YAML with strongly typed, locally debuggable scripts. This podcast explores how Cake orchestrates MSBuild and the .NET CLI across any CI system, smooths cross platform quirks, and now ships with a Cake SDK that leverages .NET 10 single file apps for simple distribution and a consistent developer experience.

.NET drip - March 22, 2026

Sun, 22 Mar 2026 00:00:00 GMT

Async Does Not Mean Scalable

Irina Scurtu explains why async and message queues are tools for thread management and decoupling, not magic throughput boosters. In this post she points to where bottlenecks really live in .NET apps and highlights practical levers like more stateless consumers, partitioning by keys, and tracking consumer lag instead of queue depth.

5 Architecture Tests You Should Add to Your .NET Projects

Milan Jovanović shows how to lock in your Clean Architecture with fast, automated architecture tests in .NET using ArchUnitNET and a bit of reflection. This post explains five high-impact checks from layer boundaries to naming, colocation, visibility, and external dependency guards so your CI catches drift before it becomes debt.

Richard Lander: DotNet Inspect – Azure & DevOps Podcast Episode #392

Richard Lander from the .NET team unpacks DotNet Inspect in this podcast, a CLI tool that shines a light on what is in your app and the environment it runs in, especially inside containers. It shows how surfacing runtime details and dependencies can prevent mismatches, improve build repeatability, and make production troubleshooting calmer.

.NET Rocks! – CLI First with Kathleen Dollard

Kathleen Dollard joins Carl and Richard to make the case for CLI-first apps in .NET, sharing lessons from building the .NET CLI and why POSIX conventions keep tools consistent and friendly. This podcast shows why command lines matter more in the AI era, how LLMs benefit from predictable flags and verbs, and points to projects that help you craft a great CLI without reinventing the wheel.

Make your programs run faster with one click in Visual Studio 2026

Mads Kristensen shows off a super easy way for you to optimize performance of your .NET application using your existing unit tests, the built-in profiler, and Copilot to tie it all together into a single click of a button.

Aspire Conf is Coming! Join us Live on March 23

Maddy Montaquila announces Aspire Conf, a free livestream focused on how Aspire streamlines building and operating distributed and agentic apps across C#, Python, and JavaScript. This post previews the Aspire 13.2 release with a TypeScript AppHost and agent-ready CLI that help teams model, observe, and ship complex systems with less chaos.

Windows App Development CLI v0.2: .NET support, manifest placeholders, “winappstore” and more!

Nikola Metulev unveils Windows App Development CLI v0.2, adding first-class .NET support that wires up your .csproj with the right Windows SDK NuGets and assets so WinUI, WPF, and WinForms apps package cleanly without a winapp.yaml. This post shows how manifest placeholders banish hardcoded exe names, the new winapp store command streamlines Store submissions, and the overhauled help and errors cut friction in local debugging and CI.

The Evolution of Validation Techniques in ASP.NET

Bipin Joshi charts how ASP.NET validation grew from text boxes in Web Forms to MVC model metadata to ASP.NET Core pipeline services that enforce trust at your API boundary, with automatic 400s and pluggable engines like FluentValidation. This post lands in Blazor territory with EditForm and EditContext, making the case that treating validation as contract first and UI second keeps real apps cleaner and your rules reusable.

A minimal way to integrate Aspire into your existing project

Tim Deschryver shows a minimal, low-friction way to bring .NET Aspire into an existing .NET 8 solution by adding an AppHost that runs all your ASP.NET and Angular projects with one command and a simple dashboard. This post focuses on the why of gradual adoption, wiring AddProject and AddJavaScriptApp to move off Project Tye while leaving room for tracing, containers, and secrets later.

.NET MAUI Community Standup: .NET MAUI DemoFest

The March edition of the .NET MAUI Community Standup brings Jon Dick and Allan Ritchie to show how they brought MAUI to additional platforms andn how they're using AI to accelerate their development. Of course, they're joined by hosts David Ortinau and Gerald Versluis.

Release v1.0 of the official MCP C# SDK

Mike Kistler announces v1.0 of the MCP C# SDK aligned with the 2025-11-25 spec, bringing smoother OAuth discovery, incremental scopes, URL-mode elicitation, LLM tool-calling, CIMD, and better handling for long-running requests. In this post you get practical ASP.NET Core and Microsoft.Extensions.AI examples for wiring up auth, icons, sampling with tools, SSE polling, and experimental task-backed operations that make AI agents dependable.

.NET drip - March 15, 2026

Sun, 15 Mar 2026 00:00:00 GMT

Aspire 13.1.2 Release

.NET Aspire 13.1.2 is a tidy patch focused on reliability. This post highlights a fix for template version parsing to handle the .NET 10.0 SDK separator change and updates pipeline images to non-deprecated pools, keeping scaffolding smooth and CI drama free.

C#: Class, Struct or Record - Which Should You Choose?

So many developers never step beyond using classes in their applications. This video details the differences between class, struct, and record, including when each is best used.

XAML.io v0.6: Share Running .NET Code With a Link

XAML.io v0.6 turns a shareable URL into a live, forkable .NET app that compiles and runs in the browser, now with in-browser NuGet support for popular libraries like Newtonsoft.Json. This post shows how instant, no-install demos and teaching samples become easy while still letting you download a standard Visual Studio solution when you are ready to take it further.

Real-Time AI Conversations in .NET: Local STT, TTS, VAD and LLM

El Bruno introduces ElBruno.Realtime, a pluggable pipeline for real-time local voice conversations in .NET that chains VAD, STT, LLM, and TTS using Microsoft.Extensions.AI and DI while auto-downloading models. This post shows minimal console and ASP.NET Core plus SignalR examples, with one-line swaps for Whisper, Kokoro, QwenTTS, VibeVoice, or Ollama, and explains streaming events and per-user sessions for a private assistant without cloud dependencies.

.NET drip - March 8, 2026

Sun, 08 Mar 2026 00:00:00 GMT

Prevent plus-addressing with ASP.NET Core Identity

Jerrie Pelser shows how to curb trial abuse by building a custom IUserValidator for ASP.NET Core Identity that detects plus addressing with a regex and returns a friendlier, context-aware error message. He also weighs when this rule is appropriate and teases alternatives like normalizing to the primary address.

How to Implement Builder Pattern in C#: Step-by-Step Guide

Nick Cosentino lays out a step-by-step guide to implementing the Builder pattern in C#, using an email example to show clean object construction with validation and fluent chaining. In this post you'll also see immutable builders, testing strategies, and DI friendly patterns that keep models maintainable as complexity grows.

Polymorphic Relationships in EF Core: Three Approaches

Ali Hamza Ansari walks through three ways to model polymorphic relationships in EF Core, with runnable samples for TPH, TPT, and TPC that show the mappings, migrations, and queries they generate. If you wrestle with inheritance in your domain, this post helps you choose the right strategy by comparing tradeoffs like null-heavy tables, join performance, and union-based reads.

Dapr v1.17 is now available

The Dapr maintainers ship v1.17 with workflow versioning and history retention, end-to-end tracing, Bulk PubSub now stable, and sturdier placement and CLI behavior so long-running orchestrations can breathe easy during upgrades. This post spotlights a revamped Dapr.Workflow .NET SDK that drops the DurableTask dependency, adds named and patch versioning with .NET 10 support and Testcontainers, giving C# devs smoother upgrades and sturdier tests.

How LINQ Execution Actually Works: Power of Being Lazy

DreamDrafts demystifies LINQ's deferred execution with a fun recipe metaphor, showing that Where and Select build a plan while work happens only when you iterate or call ToList, Count, First, or Max. This post helps you sidestep multiple enumeration and take control of when the database gets hit by materializing results once when you need them.

AutoMapper 16.1 and MediatR 14.1 Released

Jimmy Bogard ships AutoMapper 16.1 and MediatR 14.1, adding dependency injection friendly factories and conditions to AutoMapper and improving MediatR support for complex generic hierarchies alongside bug fixes. This post highlights how these updates make mapping decisions and request pipelines more flexible in real-world .NET apps, and tips a hat to AutoMapper crossing 1 billion downloads.

Simplifying Grid Layout in .NET MAUI Using Extension Methods

Leomaris Reyes shows how CommunityToolkit.Maui.Markup extension methods make Grid layouts in .NET MAUI cleaner and more maintainable, from .Row and .Column helpers to concise Columns.Define and Rows.Define syntax. This post also demonstrates naming rows and columns with enums plus All and Last so real apps get faster layout wiring, fewer magic numbers and easier refactors.

Reactive Extensions for .NET – Rx.NET v7 and Futures

Ian Griffiths returns to On .NET Live with a hands-on demo of Rx.NET, showing how to use LINQ over observables to join and group live AIS ship data and keep a WPF UI updated safely. In this podcast he breaks down the .NET 10 async LINQ move and the Rx 7 package split that slashes self-contained app size, then teases Rx 8 work for WASM, Unity, trimming, and Async Rx.

Building GitHub Copilot Agents in C# with Microsoft Agent Framework

El Bruno explores how GitHub Copilot can run as an autonomous agent in C# using Microsoft Agent Framework, shifting from prompt and suggestion to goal, plan, act. In this post he walks through three small samples that spin up a Copilot-backed AIAgent and apply it to real dev workflows like understanding unfamiliar repos and drafting PR-ready summaries, giving .NET teams a quick route to production-grade AI helpers.

What Does typeof Really Do in C#? typeof, GetType() and IsAssignableFrom

Melisa Akkuş demystifies typeof, GetType(), and IsAssignableFrom in C#, clarifying what each actually asks and how they behave. A tidy refresher that boosts confidence when reading framework and infrastructure code.

How do I suppress the hover effects when I put a Win32 common controls ListViewin single-click mode?

Raymond Chen shows how to keep single-click activation in a Win32 ListView without the hot-track hand and highlight by handling LVN_HOTTRACK and returning 1. This post also calls out the dialog proc nuance with DWLP_MSGRESULT, a tiny fix that pays off when you host native controls from .NET and want cleaner UX.

I Built a CLI Tool to Switch .NET MAUI Versions Instantly

MAUI Version Manager is a .NET global tool that lets you switch your .NET MAUI project between release channels - stable, nightly, or any open PR - right from the command line. It auto-detects your project, handles NuGet feeds, downloads build artifacts, updates your TargetFrameworks, and gets you up and running fast.

.NET drip - March 6, 2026

Fri, 06 Mar 2026 00:00:00 GMT

How to Implement Type Safe Unions in C# With OneOf

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.

Implementing Distributed Caching in Web API with Azure Managed Redis

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.

Should my Services be Transient, Scoped, or Singleton?

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.

Blazor Without the Bloat: Building “Power Inputs” with Plain HTML

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.

Create and Run Durable AI Agents in .NET with Microsoft Agent Framework

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.

Building a Gated Multi-Step Wizard in .NET MAUI with Tab View

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.

How to Improve Performance with Threading in .NET

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.

New in .NET 10 and C# 14: Multi-Tenant Rate Limiting

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.

How to Classify Documents using AI in C#/.NET

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.

Builder Design Pattern in C#: Complete Guide with Examples

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.

Make Unity Feel Instant: Background Jobs With Thread Manager

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.

Scalable .NET MAUI: Implementing Clean Architecture for Enterprise-Grade Apps

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.

.NET drip - March 4, 2026

Wed, 04 Mar 2026 00:00:00 GMT

String Performance: The Fastest Way to Get a String’s Length

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.

Extract Pages from Word Documents Using C#

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.

Generating SBOM for NuGet packages

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.

Deep C# - Multicast Delegates and Events

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.

Building an authenticated MCP server with Microsoft Entra and .NET

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.

Using ClientConnectionId to Correlate .NET Connection Attempts in Azure SQL

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.

Set the AMR Claim When Using Passkeys Authentication in ASP.NET Core

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.

Visual Studio February Update

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.

Generic Math in .NET: Design, Constraints, and Practical Use

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.

Stop Using ToLower() for Comparisons! The Fast, Correct Way in C#

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.

Async Await Just Got A Massive Improvement in .NET

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

.NET MAUI: C# Expressions in XAML: throw out your converters

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.

.NET drip - March 2, 2026

Mon, 02 Mar 2026 00:00:00 GMT

Catching Up with Recent Wolverine Releases

Jeremy D. Miller recaps a whirlwind of Wolverine releases that sharpen concurrency control, durability, and integrations across the .NET stack. This post spotlights inferred message grouping, classic EF Core domain events, fresh transports like HTTP and NATS, and easier idempotency so teams can ship resilient message driven services with less ceremony.

.NET Rocks! – Making Reliable Software in 2026 with Damien Brady

Carl and Richard sit down with Damien Brady on .NET Rocks! to explore what reliable software looks like in 2026 and how AI fits into the picture. This podcast shares pragmatic ways to use LLMs for code analysis and reviews to raise quality, while reminding us that practice, guardrails, and developer judgment still matter.

Introduction To Permission Authorization In ASP.NET Core 10

Mori shares how role checks spiral out of control in real apps, then introduces permission authorization in ASP.NET Core 10 to model what users can do rather than who they are. This post sets the stage for policies, requirements, and permission claims that keep controllers clean and access consistent across UI and business logic.

The Cross-Cutting Concern Fallacy in .NET Architecture: Is Middleware a Solution or a Trap?

Serhat Kaçmaz tackles the habit of stuffing every cross-cutting concern into middleware and lays out clear boundaries between middleware, MVC filters, MediatR pipeline behaviors, and decorators. With concise .NET 8 examples, this post shows validation via a MediatR pipeline behavior and caching with a repository decorator to keep business logic clean and HTTP agnostic.

Adding External Fonts in .NET MAUI

Leomaris Reyes shows how to plug custom fonts into .NET MAUI the right way, from dropping files in Resources/Fonts to wiring up ConfigureFonts and using a clean alias in XAML. This post also highlights when Android's built-in fonts are enough so you can polish your UI without shipping extra assets.

DbContext Fundamentals — What Every Developer Gets Wrong

Compile & Conquer demystifies DbContext in EF Core, showing how connection management, change tracking, query translation, transactions, and the identity map quietly drive behavior when your data acts weird. This post explains why scoped lifetime keeps things correct and fast while transient silently loses work and singleton piles up stale, thread-unsafe state, giving you a solid mental model to diagnose bugs and design safer services.

.NET AI Community Standup: Squad: AI agent teams for any project

This edition of the .NET AI Community Standup features Bruno Capuano and Brady Gaster discussing Squad, an AI development team that forms to bring your ideas to life. Using five specific agent roles (lead, frontend, backend, tester and scribe), it's not a chatbot wearing hats. Each team member runs in its own context, reads only its own knowledge, and writes back what it learned.

Getting Started with the Blazor Diagram Component

Héctor Pérez walks through Telerik UI for Blazor's Diagram component, from placing a TelerikDiagram and adding shapes and connections to using tree, layered or force layouts so you can sketch workflows and org charts without wrestling with pixel math. This post highlights practical touches like labels, end caps and selection handles, and points to JSON and styling options when you need deeper customization.

Solving the Distributed Cache Invalidation Problem with Redis and HybridCache

Milan Jovanović shows how .NET 9's HybridCache nails speed with L1 plus L2 caching, yet still needs an invalidation backplane to keep multi-node apps consistent. This post implements Redis Pub/Sub with a background listener to fan out cache removals and also highlights FusionCache as a compatible HybridCache option with a built-in backplane.

6 .NET MAUI Properties You Didn’t Know Work with Buttons

Leomaris Reyes spotlights six underrated .NET MAUI Button properties, from TextTransform and CharacterSpacing to FontAutoScalingEnabled and LineBreakMode, to help you build buttons that look sharp and behave right on every device. With short XAML examples and practical notes on accessibility and responsiveness, this post shows how to round corners, manage text flow, and keep font sizes aligned with user settings for a more polished app.

From MermaidJS to .NET: Bringing Text-Based Diagrams into Your WinForms Apps

MESCIUS shows how to bring MermaidJS text-based diagrams into WinForms using the ComponentOne FlexDiagram control, parsing Mermaid syntax and rendering interactive visuals with a single LoadMermaidGraph call. Beyond the how, this post explains why text-first diagrams fit real apps like workflow editors and documentation tools, with concise C# examples for loading from embedded resources or strings.

.NET AI Essentials - The Core Building Blocks Explained

Jeremy Likness kicks off .NET AI Essentials by showing how Microsoft.Extensions.AI gives you a single, provider-agnostic API for OpenAI, Azure OpenAI, and Ollama, with DI-friendly patterns, streaming, and typed structured outputs that spare you the JSON wrangling. This post focuses on the real-world bits like standardized options, middleware with logging and OpenTelemetry, Aspire-friendly tracing, and multimodal content that make LLM features production ready, with vectors, agents, and MCP coming next.

.NET drip - February 27, 2026

Fri, 27 Feb 2026 00:00:00 GMT

Local Image Embeddings in .NET — CLIP + ONNX

El Bruno introduces a .NET library that brings local CLIP image embeddings to your apps using ONNX Runtime, letting you experiment with multimodal search and image RAG without shipping data to the cloud. This post shows the model download scripts, a minimal C# example, and two runnable samples including an interactive Spectre.Console chat so you can get productive fast.

How to integrate Stripe with ASP.NET Core?

Denis Makarenko walks through Stripe integration options for ASP.NET Core, then implements a tidy server-side flow that creates a Checkout Session and verifies completion with just two minimal API endpoints. This post focuses on the why behind each choice and slips in practical tips like handling minor units, using idempotency keys, and surfacing the session ID for reliable redirects.

T4 templates on modern .NET

Ian Griffiths maps out how to run T4 templates on modern .NET by swapping Visual Studio's legacy engine for the TextTransformCore tool and wiring it into your build with Directory.Build files and a custom MSBuild target. Along the way this post unpacks assembly reference quirks, nesting with DependentUpon, and why teams like Rx.NET still lean on T4 instead of jumping to source generators.

XAML Source-Generation in .NET MAUI makes your app so much better

Break down what XAML source generation is, how it works, and why it can improve performance, reliability, and your overall development experience. If you're building apps with .NET MAUI, Daniel Hindrikes offers something you don’t want to miss.

How Function Composition Can Make Your Code Better

Mori shares a practical guide to function composition in C#, showing how composing small pure functions can turn imperative spaghetti into readable, testable pipelines. This post focuses on real-world refactors like order processing and data flows, explaining the mental model and patterns that make modern C# code easier to reason about and optimize.

Everything You Need to Know About Arrays in C#

Microsoft MVP Gulam Ali H. pulls back the curtain on what arrays really are in C#, from their heap memory layout and reference semantics to the performance cost of bounds checks. By tying arrays to List, Span, strings, and pooling, this post shows how GC behavior and memory patterns quietly shape correctness and speed across your .NET apps.

Automatic Service Discovery in C# with Needlr: How It Works

Nick Cosentino breaks down how Needlr auto-discovers and registers concrete classes and their interfaces in .NET, trimming boilerplate and preventing those sneaky DI runtime errors. This post explains what gets picked up, how lifetimes and exclusions work, and where source generation or reflection fits so you keep convention and manual control in balance.

LINQPad 9.6 Release Notes

Joseph Albahari rolls out LINQPad 9, a unified Windows and macOS release with C# 14 support, a redesigned UI, and a smart AI coding agent that can refactor code, write tests, and convert SQL to LINQ. This post highlights how the new provider model, faster editor and SQL tooling, and file-based app support can speed up everyday prototyping and database work across .NET 6-10.

Uno Platform 6.5: Community Standup

Sam Basu previews the Uno Platform 6.5 community standup, highlighting why these upgrades matter for building real world cross platform .NET apps. This post zeroes in on productivity boosts like Studio's agent-first AI via Antigravity MCP, a default Hot Design visual loop, and a new scope selector, plus core improvements such as Unicode TextBox input, sturdier WebView2, broader Wasm drag and drop, and sharper diagnostics that make C# and XAML work feel smoother.

.NET EF Core Should Be Your Default in 2026, Not Dapper

Vivek Baliyan revisits the Dapper vs EF Core default and shows why the once clear performance win is no longer the deciding factor. This post highlights how EF Core's productivity and evolving features can speed teams up in real apps, with pragmatic notes on when a micro ORM still makes sense.

Blue Blazes S04E02: GitHub Copilot App Modernization for .NET - featuring Matt Soucoup

Jonathan J. Tower talks with Matthew Soucoup about GitHub Copilot's App Modernization agent for .NET, unpacking how it assesses legacy codebases, plans upgrades, and executes tasks with persistent memory to keep teams moving. If you are wrangling aging .NET Framework or multi-version apps, this podcast shows how AI can de-risk migrations to modern .NET and the cloud while complementing helpers like Web Forms to Blazor tooling.

Blazor Basics: Should You Migrate to .NET 10?

Claudio Bernasconi makes the case for upgrading Blazor apps to .NET 10, not just because it is LTS but for the practical gains it brings. This post highlights smaller payloads for faster startup, a PersistentState attribute that tames prerendering on Blazor Server, new JS interop that can construct JS objects, and NavigationManager.NotFound for consistent 404s across render modes. The focus is on what real apps get in return: quicker loads, less glue code and more correct behavior.

.NET drip - February 25, 2026

Wed, 25 Feb 2026 00:00:00 GMT

Mastering Industrial Camera Integration: C# + VisionPro Real-Time Acquisition Deep-Dive

JIN walks through building a production-ready C# integration with Cognex VisionPro for real-time industrial camera acquisition, from device enumeration and connections to single-shot and continuous preview. In this post you pick up pragmatic patterns for safe resource disposal and troubleshooting the classics like 'connected but no frames' and memory leaks so your capture pipeline runs 24/7 without drama.

Reliably Refreshing the WebView2 Control

Rick Strahl explains why WebView2.Reload can leave previews stale and shows how to force a true hard refresh in C#, so images and other dependent resources actually update. In this post he compares a simple URL reset, Profile.ClearBrowsingDataAsync, and a DevTools cache clear, with practical notes for WPF and WinForms and when to use each.

Collection Performance: High-Performance Collection Randomization in .NET

Randomizing large collections without tanking throughput is trickier than it looks, and dotnettips digs into what actually makes a shuffle fast in .NET. This post compares popular techniques with cache friendly in-place algorithms, explains how Random usage and allocations impact scalability, and shares practical snippets you can drop into arrays and lists.

EF Core State Validation

Ricardo Peres tackles those mysterious SaveChanges exceptions by validating EF Core state ahead of time with ChangeTracker metadata, surfacing friendly ValidationResult messages for required and max length issues. This post then shows three practical ways to bring full Data Annotations validation into EF Core using a SaveChanges override, a SaveChangesInterceptor, or the SavingChanges event so you can pick the least intrusive option for your app.

ACID in Practice for .NET: Isolation Levels, Anomalies, and Transaction Pitfalls

Sudhir Mangla untangles why isolation levels, not just transactions, decide whether your .NET app hits lost updates, phantoms, or deadlocks, especially when RCSI and Snapshot shift behavior in Azure SQL and RDS. This post delivers battle-tested EF Core patterns like RowVersion concurrency, savepoints, targeted UPDLOCK usage, plus outbox and idempotency with Polly retries to keep your data sane under load.

Local Embeddings in .NET — The Easy Way

El Bruno introduces ElBruno.LocalEmbeddings, a lightweight NuGet package that generates embeddings locally in .NET with a few lines of C#, perfect for tinkering with Foundry Local or Ollama. This post walks through single and batch generation and cosine similarity to help you prototype semantic search and RAG fast without spinning up cloud vector infrastructure.

How to Implement Abstract Factory Pattern in C#: Step-by-Step Guide

Nick Cosentino lays out a step-by-step path to implementing the Abstract Factory pattern in C#, complete with runnable examples that go from interfaces to concrete factories and client code. In this post you will learn how to keep related object families consistent, plug factories into DI, dodge common gotchas, and add new variants without sprinkling conditionals everywhere.

C# 14 in .NET 10: language features that actually matter in production

C# 14 is not about syntactic novelty. It is about reducing friction in patterns teams already use: extensions, domain modeling, source generation, and performance-sensitive code.. Anderson Godoy walks us through the changes that will stand out the most.

Microsoft .NET Code Analysis: Efficient String Prefix Checks — StartsWith() vs.IndexOf()

dotNetDave digs into .NET code analysis rule CA1858 to show why StartsWith is the right tool for string prefix checks compared to IndexOf, covering performance, clarity, and culture-safe comparisons. This post explains when to use StringComparison, what the analyzer is nudging you toward, and how a tiny change can trim allocations in hot paths.

Aspire App Lifecycle Guide

Microsoft's Aspire lifecycle guide walks through inner-loop development with aspire run, local deployment with aspire deploy, and CI/CD publishing via GitHub Actions, all using a single AppHost to keep environments consistent. In this post you follow a Blazor and SQL Server example with persistent volumes and generated Docker Compose artifacts that make it easier to move from local debugging to production-ready containers.

Everyone Tunes C#.NET APIs Wrong

Ashok Reddy shares how he turned sluggish C# and .NET endpoints into snappy APIs with a measured approach that delivered a 20x speedup. This post zeroes in on real bottlenecks through profiling and tackles common culprits like chatty logging and request queuing so your services stay fast when the load gets real.

The EF Core AsNoTracking Mistake That Quietly Broke My Data Layer

Michael Preston shares how a one-line EF Core optimization using AsNoTracking trimmed memory and latency but quietly broke identity resolution across queries in the same request scope. This post peeks under EF Core's hood and shows when to keep tracking on, when no-tracking is safe, and how to dodge sneaky relationship bugs.

.NET drip - February 23, 2026

Mon, 23 Feb 2026 00:00:00 GMT

Local Images in MAUI Blazor: One Problem, Four Solutions, One Winner

Joachim Leonfellner shows off four methods to use local images in MAUI Blazor. Along the way, he covers the pros and cons and identifies a clear winner.

Enterprise Patterns for ASP.NET Core Minimal API: Data Transfer Object Pattern

Chris Woodruff explains how the Data Transfer Object pattern keeps ASP.NET Core Minimal API contracts stable by separating domain and persistence models from what clients see, avoiding the pitfalls of returning EF Core entities. This post shares practical mapping techniques, before and after endpoints, and sensible rules for when DTOs matter so your APIs are safer, slimmer, and easier to evolve.

Getting Started with the Blazor Skeleton Component

Héctor Pérez walks through the Telerik UI for Blazor Skeleton component and shows how skeleton screens make loading states feel faster while keeping layouts stable. Using a simple IsLoading flag and matching shapes and animations to avatars, text, and images, this post demonstrates a practical pattern you can drop into real Blazor pages for a smoother UX.

Introducing Flexible Pricing for Avalonia Accelerate

Mike James introduces flexible rent-to-own pricing for Avalonia Accelerate, where monthly subscribers receive a permanent license after twelve months and shipped apps keep running thanks to no runtime checks. This post also unveils a refreshed customer portal and reseller redemption that streamlines billing, seat management, upgrades, and support, making professional .NET UI with Avalonia easier to adopt in real teams.

The Valet Key Pattern on Azure: Secure Direct Uploads with SAS and ASP.NET Core

Sudhir Mangla walks through the Valet Key pattern so your ASP.NET Core API authorizes uploads while Azure Blob Storage does the heavy lifting using User Delegation SAS and managed identities. This post delivers a production-ready blueprint with modern .NET snippets for a tiny valet API, browser chunked uploads and integrity checks, plus zero trust essentials like quarantine, scanning, and targeted revocation.

Convert HTML to PDF in .NET (C#): Real-World Scenarios, PDF Standards, and BestPractices

Bjoern Meyer shows how to turn HTML into reliable PDFs in C# with TX Text Control, including a small .NET sample, adding headers and footers, and exporting to PDF/A or PDF/UA. The heart of this post is why PDFs win for invoices, reports, and contracts where consistency, archiving, accessibility, and a defensible layout matter more than browser quirks.

C# Console menus with Actions

Karen Payne shares a simple pattern for building interactive C# console menus using Spectre.Console with Action delegates, including options that pass parameters for real tasks like saving images or powering dotnet tools. This post explains the tiny set of classes that wire selections to operations and includes tips and sample repos to quickly prototype and organize learning or utility work.

The '#:package' Trick That Turns One .cs File Into a Real App

Abe Jaber shows how the new #:package directive in .NET 10 lets you ship a real console app from a single .cs file, complete with NuGet dependencies, no csproj required. This post focuses on practical guardrails for tiny but reliable tools like parsing args, piping stdin, cancellation, predictable exit codes and timeouts so you can build internal utilities fast without the scaffolding overhead.

Mastering Business Logic in .NET: A Deep Dive into the Specification Pattern

Ahmad Al-Freihat shows how the Specification Pattern can rescue sprawling business rules by turning them into reusable, testable objects you can use both in memory and in EF Core queries. This post introduces the Masterly.Specification library with composable operators like And, Not, Xor and Implies, a fluent builder, diagnostics and caching so your domain stays a single source of truth and your code stays readable.

Goodbye Factory Classes: Modern C# Activators Explained

Mohammad Shoeb explains how modern C# activators, reflection, and dependency injection can replace most factory classes and make object creation simpler in real applications. Using a multi-tenant payments example, this post shows how Activator plus a container unlocks plugin-style extensibility, fewer deployments, and guidance on when factories still belong.

What It Took to Implement VS Code Debugging for .NET nanoFramework

Laurent Ellerbach shows how .NET nanoFramework brought full VS Code debugging to embedded C#, translating DAP to the device Wire Protocol through a C# bridge and TypeScript adapter without changing device firmware. This post digs into pdbx and portable PDB symbol mapping to land breakpoints on the right lines, while sharing pragmatic architecture choices and AI-assisted workflows you can reuse for your own tooling.

Reflection in C#: The Ultimate Guide

Michael Maurice maps out how reflection turns C# from strongly typed to smartly adaptable, from simple type inspection to on-the-fly invocation, plugin discovery, and even code generation. This post explains where reflection quietly powers your favorite frameworks, when to use it yourself, and how to avoid the performance potholes with practical patterns.

.NET drip - February 20, 2026

Fri, 20 Feb 2026 00:00:00 GMT

Internationalization Architecture for Global .NET Applications

Sudhir Mangla maps out an architecture-first blueprint for building global .NET apps that behave consistently across platforms by adopting ICU, resolving culture correctly, and keeping formatting in the presentation layer. This post helps you avoid costly i18n pitfalls with concrete patterns for NodaTime, money as structured data, ICU MessageFormat and Fluent, RTL friendly CSS, culture-aware storage and search, plus production-grade caching, testing, and trimming.

.NET 10 support in Visual Studio 2022

Mike Irving shows how to target .NET 10 from Visual Studio 2022 without jumping to the new IDE by installing the .NET SDK and verifying with dotnet --version, so you can keep your project moving. In this post he also shares when an upgrade to Visual Studio 2026 makes sense and mentions alternatives like VS Code with C# Dev Kit or Rider.

5 Minimal API myths and the real truth

Round The Code busts five Minimal API myths with practical patterns for moving logic out of Program.cs, organizing route groups, unit testing handlers, and wiring up authorization, validation, and OpenAPI in .NET 10. If you are coming from controllers, this post shows how to keep Minimal APIs clean, scalable, and well documented so they fit real world apps, not just toy projects.

.NET MAUI Xcode 26.3 Support

Rolf Bjarne lays out the dotnet/macios plan for Xcode 26.3 support, from branching and version bumps to API bindings and the xtro and introspection test gauntlet. This post gives a behind the scenes look at how .NET for iOS and macOS track new Xcode releases, and what that means for MAUI dependencies, NuGet packages, and your builds staying green.

Introducing Pri.ProductivityExtensions.Source - A .NET Standard Package to Enable Modern C# Language Features

Peter Ritchie introduces Pri.ProductivityExtensions.Source, a source-only NuGet that adds internal polyfills for newer BCL types so modern C# features work in .NET Standard libraries without extra assemblies. This post lays out why features like ranges, indices, and CallerArgumentExpression trip up .NET Standard projects and how the package unblocks analyzers and PowerShell modules while keeping wide compatibility.

New in .NET 10 and C# 14: Fast Model Validation for APIs

Ali Hamza Ansari breaks down how .NET 10 and C# 14 turbocharge API model validation by swapping reflection for precomputed metadata, cutting allocations, and streamlining hot paths for steadier p95 and p99 latency. In this post you get a minimal BenchmarkDotNet setup comparing .NET 8 and .NET 10 plus practical context on why these changes can deliver around 3x faster validation in real traffic.

.NET Toolbox February Update

Steven Giesel rolls out a February refresh of his browser-based .NET Toolbox, adding an Options Generator that turns JSON config into C# options classes, a typed DI helper for HttpClient and SignalR, and an SRP analyzer to spot single responsibility drift. This post shows how these open source, client-side tools cut boilerplate and encourage cleaner design, with Roslyn-powered ideas possibly on the horizon.

.NET 10: Post-Quantum Cryptography Comes to .NET

Anthony Giretti gives a clear, no-drama tour of .NET 10's new post-quantum crypto, covering ML-DSA, SLH-DSA, and ML-KEM with patterns that feel like everyday System.Security.Cryptography. In this post you will learn when each algorithm shines and how to future-proof signatures and key exchange in real apps without rewriting everything.

Visual Studio 2026 Release Notes – February Update 18.3.0

The Visual Studio team rolls out 2026 updates that weave AI into everyday C# work with Copilot powered test generation, call stack analysis, and NuGet security help from both an MCP server and new audit sources. ASP.NET and Blazor devs get faster Razor Hot Reload with auto restart, a snappier Razor editor with Tag Helper go to definition and better IntelliSense, plus practical IDE polish like speedy scrolling, colorized completions, and cleaner Solution Explorer views.

The Better Way to Configure Entity Framework Core

Mori recounts a production incident where orders vanished after a clean deploy, tracing it to EF Core defaults hiding behind a perfectly normal DbSet. This post shows how to take back control with explicit, centralized configuration for entities, clarifying relationships and delete behavior to keep data safe when version or model changes roll through.

C# Expressions are coming to .NET MAUI

Daniel Hindrikes walks us through the new C# expressions feature for .NET MAUI. C# Expressions is so much more than replacing converters; you can finally write inline, strongly-typed logic directly in XAML, making your UI code cleaner and faster to write. Not to mention its performance boost!

.NET AI Community Standup: Foundry Local for .NET Devs 🚀

This month's .NET AI Community Standup brought Bruno Capuano, Jeff Fritz, and Maanav Dalal together to explore Foundry Local and how C# developers can use it to run AI models directly on their machines, without cloud dependencies. Watch them discuss architecture, local-first AI scenarios, and how Foundry Local fits into modern .NET and AI workflows.

.NET drip - February 18, 2026

Wed, 18 Feb 2026 00:00:00 GMT

9 No-Nonsense Ways I Manage .NET

Adam shares nine practical ways to tame .NET 10 app configuration with the Options pattern so your settings stay typed, validated, and reloadable. If your config feels like a junk drawer, this post shows how to model settings as config objects, ditch magic strings, and set sensible defaults your future self will appreciate.

Zeta: It's Time to Rethink Validation in .NET

Per Sonberg introduces Zeta, a schema-first async validation library for .NET inspired by Zod that treats schemas as composable values and returns result types with path-aware errors. Along the way, this post contrasts it with FluentValidation pain points around async, DI and composition, shows simple ASP.NET Core integration, and shares early benchmarks with lower allocations and faster failure handling.

.NET 10.0.3 Release

The dotnet/dotnet repo has tagged v10.0.3, marking the next point release on the .NET 10 line. This post is handy for version pinning in CI or dependency manifests, though assets and notes were not visible here due to a loading hiccup.

How to Run Azure Service Bus Locally using .NET Aspire

If you’ve ever had to share a single “dev” Service Bus namespace with your team (and deal with broken queues, leftover subscriptions, or random test messages), this setup is the fix: a clean, repeatable local environment that’s perfect for development and integration testing. Milan Jovanović show you how in this video.

Building a 3.6GB .NET Audio Joiner with GitHub Copilot CLI

El Bruno shows how to use GitHub Copilot CLI to spin up a .NET console app that joins 65 MP3s into one 3.6GB file, turning a scrappy idea into a reliable utility. In this post you pick up practical patterns like streaming to disk to dodge memory limits, adding Spectre.Console polish, and knowing when to step outside Copilot to keep real-time output.

WinDev Helper - A WinUI Extension for VS Code

Alvin Ashcraft’s WinDev Helper extension turns VS Code into a tidy WinUI 3 workbench with F5 debugging, x86 x64 ARM64 builds, MSIX signing, and C# Dev Kit features like Solution Explorer. This post shows how winapp CLI integration and ready made templates reduce the friction of scaffolding, packaging, and shipping Windows App SDK apps while XAML IntelliSense and Hot Reload remain on the roadmap.

I Built a .NET App in One File - And It Changed Everything

Ashok Reddy explores the .NET 10 preview feature for single file C# apps that lets you bypass project files and spin up native executables fast. In this post he builds a one file password generator that checks Have I Been Pwned, showing how this lightweight workflow can speed up prototypes, scripts, and everyday utilities.

.NET Rocks! - The Role of AI in Secure Software with Ben Dechrai

Carl Franklin and Richard Campbell talk with Ben Dechrai about how AI tooling is changing secure software practices for .NET teams, from code exposure risks and model choices to the realities of running models locally. This podcast offers practical ways to set guardrails for AI-assisted coding and to understand the emerging AI-driven attack and defense landscape so your C# apps ship safer.

LINQ in EF Core Explained: From Lambda Expressions to SQL

Benedict Odoh peeks under the hood of LINQ in EF Core, showing how your lambda expressions become expression trees that EF translates to SQL and why that mental model matters for performance. This post contrasts query and method syntax, clarifies deferred vs immediate execution and terminal operations, and demystifies loading related data with Include, lazy loading, and explicit loading to help you shape cleaner, faster data access.

.NET 8.0.24 / 8.0.124 Release

The .NET team tagged the .NET 8 servicing release with runtime 8.0.24 and SDK 8.0.124 on GitHub, including clear steps to build from the release tag or attached source archives. This post also highlights PGP signatures and the 2023 public key so you can verify artifacts and keep your pipeline squeaky clean.

Aspire 13.1.1 Release

Aspire 13.1.1 lands with targeted fixes that smooth local HTTPS setup, clean up Vite config path handling, and resolve Azure publishing hiccups, plus an update to Azure.Identity 1.17.1. In this post, you get the highlights on what was patched and why it makes day to day development less cranky, from templates that build reliably to dev certs that behave.

.NET 11 Preview 1 Release

James Montemagno shares .NET 11 Preview 1 with release notes across C#, ASP.NET Core, MAUI, runtime and the SDK. This post points you to what is changing across the stack and how to try the preview with the .NET 11 SDK in Visual Studio 2026 Insiders or VS Code with the C# Dev Kit.

.NET drip - February 16, 2026

Mon, 16 Feb 2026 00:00:00 GMT

.NET MAUI v10.0.31 SR3.1 Release

PureWeen ships .NET MAUI 10.0.31 SR3.1, a small service release that bumps the patch version and reverts a recent Android SafeAreaEdges Container fix. This post flags a change that may impact label placement under the Android status bar, useful for anyone polishing cross platform layouts.

Microsoft Ships OData .NET (ODL) 9.0.0 Preview 3: Safety, Modern APIs, and SpecCompliance

Edin Kapić recaps Microsoft's OData .NET 9.0.0 Preview 3 with safer defaults, cleaned up APIs, and tighter spec compliance that mean fewer surprises around nullable actions and untyped JSON. This post spotlights the migration gotchas from 8.x, why some legacy bits were trimmed, and how the client stack is marching toward .NET 8 to 10 alongside ASP.NET Core OData.

Clean Architecture in .NET: Testing, Best Practices and Final Thoughts

Compile & Conquer closes out a Clean Architecture in .NET series with this post on pragmatic production readiness. You get a sensible testing plan per layer, from pure domain unit tests with no mocks to application tests with mocked ports and integration tests against a real database. It also flags common traps like anemic models, EF leaking into your domain, and returning entities from handlers so your core stays maintainable.

C# 14 Null-Conditional Assignment: Practical Examples and Best Practices

Raghunath explores the null-conditional assignment operator ?.= for C# 14, a small tweak that trims repetitive null checks when updating optional dependencies. With concrete examples across logging, UI, caching, middleware, and plugins, this post shows how to apply it safely, where to avoid it in core domain updates, and what it compiles down to. Expect a practical decision guide and patterns you can drop into everyday code.

The New field Keyword in C# 14: Practical Usage, Examples, and Best Practices

Raghunath explores C# 14's new field keyword and how it gives you direct access to an auto property's backing field inside getters and setters without extra boilerplate. Through clear examples for validation, change tracking, and lazy initialization, this post focuses on where field improves readability and maintainability and when simpler models still win. It wraps with best practices and performance notes that show the feature adds control with no runtime cost.

NET MAUI Community Standup: Live from MAUI Day London

David Ortinau and Gerald Versluis host the .NET MAUI Community Standup live from MAUI Day London where they discuss various topics, including control customization, build times, and the platform's future. Plus, learn about upcoming features and explore strategies for creating data-driven apps.

The Modern .NET Show - Jody Donetti on Creating FusionCache and Collaboratingwith Microsoft on HybridCache

Jody Donetti shares the story and design of FusionCache, showing how hybrid caching in .NET avoids cache stampedes, improves resilience, and lets you start in memory then flip on a distributed layer like Redis without rewriting code. Framed around Microsoft's HybridCache and the IHybridCache abstraction, this podcast spotlights real multi-level caching patterns that speed up APIs, scale across pods, and keep data fresh without drama.

Microsoft Agent Framework for .NET v1.0.0-preview.260205.1 Release

Microsoft's Agent Framework for .NET ships a new preview that tightens how agents manage sessions and context, boosts declarative workflow fidelity when mapping ChatMessage, and starts moving from reflection to source generation. In this post you will spot a few intentional breaking changes along with new Anthropic samples and reorganized durable agent examples that make building real-world C# agents smoother.

.NET Rocks! - .NET Source Generators with Jason Bock

Carl Franklin and Richard Campbell chat with Jason Bock about when .NET source generators shine, from compile-time regex to safer P/Invoke, and where they can backfire. This podcast offers practical heuristics for deciding if generators will pay off in your codebase, balancing performance wins with complexity, diagnostics, and build-time costs.

Authentication and Authorization Best Practices in .NET

Catharsis packages a practical tour of authentication and authorization in ASP.NET Core, showing how JWT-backed sign-in, Identity, and minimal API/controller hooks fit together. It also covers token hardening tips like short expirations, strong signing keys, and refresh flows.

How .NET 10's Microsoft Agent Framework is Revolutionizing AI

Explore .NET 10's Microsoft Agent Framework and how agent-based apps bring the JARVIS spirit to everyday C# work. If you write C#, you will see how your skills map to defining agents and their tool access with Azure OpenAI or local models.

Understanding Interfaces in C#: Why Default Interface Implementations Exist Alongside Abstract Classes

Mohan Veer Singh explains how interfaces shape clean, testable C# code and why C# 8 added default interface implementations alongside abstract classes. Through DI-friendly examples and an IPaymentService evolution scenario, this post shows how to grow shared contracts in NuGet and microservices without breaking consumers. You will learn where interfaces, abstract classes, and default methods fit in real projects and how they keep enterprise codebases stable.

.NET drip - February 13, 2026

Fri, 13 Feb 2026 00:00:00 GMT

ASP.NET Core Pitfalls - Content Type Mismatch

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.

Solving Message Ordering from First Principles

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.

Enterprise Patterns for ASP.NET Core: Front Controller and MVC Pattern

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.

Implementing Level of Authentication (LoA) with ASP.NET Core Identity and Duende

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.

A Complete Guide to Converting Markdown to PDF in .NET C#

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.

How to Read Excel Files with C#

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.

Exploring Marshal Methods in .NET MAUI

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.

Learning C#? Let's Start Together! (Part 1: Hello, C#!)

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.

Collection Expression Arguments in C# 15+

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.

File logging in ASP.NET Core made easy with Serilog

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.

Explaining Contract Tracked Changes Automatically Using .NET C# and AI

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.

How to Build High-Performance Microservices Using .NET 10?

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.

.NET drip - February 11, 2026

Wed, 11 Feb 2026 00:00:00 GMT

Implementing API Versioning in .NET

Sai Nitesh Palamakula lays out a practical path to API versioning in ASP.NET Core, explaining when to use URL, query string, header, or media type versions and the tradeoffs of each. This post shows how to wire up Asp.Versioning with Swagger and includes controller patterns for every strategy so your APIs can evolve without breaking clients.

launchSettings.json Explained: The File Every ASP.NET Dev Ignores (Until It Breaks Something)

Donie Sweeton demystifies launchSettings.json, the ASP.NET Core file that quietly tells Visual Studio and dotnet run how to start your app in development. This post gives a clear mental model of profiles, Kestrel versus IIS Express, and injected environment variables. You will see why machine specific ports cause Git conflicts and how a tidy launchSettings.json makes local ports, HTTPS, and Swagger behave.

Background Jobs in .NET: Hangfire, Quartz, Temporal in 2026

Aliaksandr Marozka maps the .NET background job landscape for 2026, comparing .NET 9 BackgroundService, Hangfire, Quartz.NET, and Temporal through hard-won project lessons. This post highlights the production tradeoffs like retries with exponential backoff, observability, schedule complexity, and ops overhead, then boils them into a clear decision path so you know when a simple worker is enough and when to reach for a scheduler or a workflow engine.

What Is a Lambda Expression (and Why C# Feels Incomplete Without It)

Melisa Akkuş gives a crisp tour of C# lambda expressions, from the arrow syntax to when to use single-line vs block forms. This post shows how lambdas unlock readable LINQ, delegate-based APIs, and event handlers, and why so much of modern C# would feel clunky without them. Expect bite-size examples you can drop into everyday code.

Implementing A2A protocol in NET: A Practical Guide

Mariyam Ashai introduces the Agent to Agent Standard for interoperable AI and shows how to wire it up in .NET 8 with ASP.NET Core. In this post you build a tiny currency agent and a console client with the A2A and A2A.AspNetCore packages, learning how Agent Cards, Tasks, and message Parts create a reliable contract between agents.

Generative AI with Large Language Models in C# in 2026

Jeremy Likness gives .NET devs a clear, jargon-free tour of generative AI essentials, from tokens and embeddings to prompts, tools, RAG, MCP, and the idea of agents. If you are deciding how to evaluate models and wire up tool calls or a cloud to local workflow, this post delivers the mental model and vocabulary to move from experiments to real apps.

TDD in .NET: Anti-Patterns - When NOT to Use TDD

Ajay Kumar digs into TDD in .NET with a pragmatic lens, showing how common anti-patterns like test obsession, over mocking, and skipping refactoring quietly tank developer confidence and speed. In this post, C# examples contrast brittle implementation focused tests with behavior driven tests, and explain when TDD shines and when prototyping, UI heavy work, or performance sensitive code deserve a different approach. Expect practical guardrails like aiming for meaningful coverage, mocking only externals, and keeping feedback loops fast.

MewUI - A lightweight code-first .NET UI toolkit focused on fluent C# markup and NativeAOT-friendly

Aprillz's MewUI is an experimental, code-first .NET GUI library built for NativeAOT and trimming that swaps XAML for fluent C# markup. If you want to ship lean utilities that start fast and stay tidy, the samples show how far modern C# can go.

What's New with APIs in .NET 10: Taking a Look at Real Improvements

Dave Brock tours .NET 10 and C# 14 from an API developer's perspective, grounded in a realistic order management sample. This post highlights built-in Minimal API validation, OpenAPI 3.1 docs, EF Core 10 named query filters and server-sent events that trim boilerplate and improve safety, plus C# touches like field-backed properties and null-conditional assignment to simplify patches.

C# 14 in Action: High-Performance Lambda Expressions with Parameter Modifiers

Raghunath explores how C# 14 upgrades lambda expressions with parameter modifiers like ref, in, and out, bringing them much closer to full method parity. If you care about intent-driven code, fewer allocations, and more expressive APIs, this reads like a handy roadmap.

.NET 10 & C# 14: Less Code, Better Performance

James Miller spotlights .NET 10 and C# 14 upgrades that cut ceremony and sharpen performance. This post shows how the field keyword streamlines guarded properties, ref friendly lambdas avoid copies, and EF Core niceties like LeftJoin and JSON partial updates tame data work, with minimal API validation and single-file runs trimming the boilerplate.

DevExpress Blazor AI Chat Agent2Agent (A2A) Protocol Integration

Dmitry Tokmachev shows how to connect DevExpress Blazor AI Chat to Agent2Agent compliant AI agents with a lightweight adapter that translates A2A messages into IChatClient. The approach highlights why open agent standards matter for .NET apps by making cross-platform agents pluggable in a familiar chat UI.

.NET drip - February 9, 2026

Mon, 09 Feb 2026 00:00:00 GMT

ReSharper and Rider 2025.3.2 Updates Out Now!

Sasha Ivanova highlights Rider and ReSharper 2025.3.2, adding ACP agent registry support to Rider's AI Chat and a batch of fixes that smooth everyday C# workflows. In this post Hot Reload is reliable again for Blazor WebAssembly and interceptor scenarios, MAUI analysis and Android deployment are corrected, inspections understand C# 14 extension members, and multi-targeted builds are steadier.

Choosing the Right .NET MAUI Picker: Date, Time, and Lists Made Simple

Hariram Subramanian breaks down when to use DatePicker, TimePicker, DateTimePicker, and Picker in .NET MAUI, mapping real app flows to the right control. This post highlights MVVM friendly bindings, cross platform consistency, and practical touches like cascading lists and dialog vs inline modes, topped off with a quick decision checklist and a GitHub sample. Expect guidance you can drop into scheduling, filtering, and everyday forms without fighting the UI.

How does Aspire expose resource connection info to the Azure Functions runtime?

Safia Abdalla explains how .NET Aspire bridges the configuration gap between Azure Functions triggers and Aspire client integrations using the IResourceWithAzureFunctionsConfig adapter. This post shows how WithReference injects the right environment variables for both emulator connection strings and identity based Azure setups, so Functions bindings and your SDK clients are happy without hand rolled config.

Simple OCR and NER Feature Extraction in C# with ONNX

Scott Galloway lays out a beginner friendly, all local pipeline in C# to turn scanned text into structured entities using Tesseract for OCR and a BERT NER model via ONNX Runtime. You will learn how tokenization, inference, and BIO decoding fit together, how to merge WordPiece tokens, and when this deterministic approach beats an LLM on speed, cost, and privacy. A NuGet helper is coming, but the copy paste code here gets you from image to people, orgs, and places today.

Debugging NServiceBus in Visual Studio Code

Particular Software walks through setting up VS Code to build and debug NServiceBus solutions that span multiple projects. This post explains how to wire up tasks.json and launch.json, launch console and web endpoints, attach to running processes, and use compound configurations to debug several endpoints at once. Great for cross platform .NET work when you want Visual Studio level control in a lighter editor.

Visual Studio 2026: How AI Is Transforming the Way Developers Code

Lucy Njeri Muturi walks through Visual Studio 2026's AI-first upgrades, from Copilot's Cloud Agent and context-aware chat to adaptive paste and profiler assistance. This post highlights how these features smooth out real work like debugging failing tests, reviewing PRs, refactoring and setup through MCP while keeping you in control.

.NET Rocks! - App Distribution on Windows with Shmueli Englard

Carl Franklin and Richard Campbell talk with Shmueli Englard about real-world paths to ship Windows apps. This podcast digs into MSIX packaging, using the Microsoft Store for updates, licensing and payments, and when rolling your own updater makes more sense. Expect pragmatic pros and cons to help you choose a distribution model that fits your .NET app without surprises.

Visualizing Geo-Spatial Data in .NET MAUI with Interactive Charts and Maps

Walk through building a geo-analytics dashboard in .NET MAUI with Syncfusion Charts and Maps, wired up with MVVM and modular user controls. This post shows how a map selection drives KPIs, trend lines, and circular charts to explore real EV adoption data using XAML and C# bindings, with a sprinkle of mobile-friendly touches like bottom sheets.

Building Resilient APIs with the Retry Pattern

Assis Zang digs into why APIs fail in the real world and shows how the Retry pattern keeps flaky integrations from derailing user experience. Using Polly 8 in ASP.NET Core, this post builds a resilience pipeline with exponential backoff, sensible retry conditions, and a minimal API that calls a secondary service.

Encrypting Properties with System.Text.Json and a TypeInfoResolver Modifier(Part 1)

Steve Gordon kicks off a series on transparently encrypting JSON properties with System.Text.Json using a TypeInfoResolver modifier instead of custom converters. This post shows an attribute-first, DI friendly approach that hooks JsonPropertyInfo get and set delegates so sensitive strings serialize as encrypted values and round-trip cleanly in a minimal API. It grounds the idea in real needs like storing OAuth tokens and sets up Azure Key Vault integration and crypto shredding for the next part.

Multi-Provider Feature Flags in .NET with OpenFeature

André Silva shows how to tame scattered feature flags in .NET by composing multiple providers behind a single OpenFeature client. This post walks through wiring OpenFeature.Providers.MultiProvider with dependency injection, choosing strategies like FirstMatchStrategy, and applying patterns such as primary plus fallback, gradual migrations, and tenant routing. A practical path to vendor-agnostic flags without rewriting call sites.

Stop Building SPAs for Every Screen: htmx + ASP.NET Core Razor Pages Workshop(Open)

Chris Woodruff opens a free htmx + ASP.NET Core Razor Pages workshop that swaps the SPA tax for server-rendered fragments and a clean hypermedia loop. This post includes step-by-step labs, instructions, and a GitHub repo so you can carry these patterns into real apps with less JavaScript baggage.

.NET drip - February 6, 2026

Fri, 06 Feb 2026 00:00:00 GMT

Building an AI-Powered Form Assistant with Blazor

Ed Charbeneau shows how to build an AI-powered RMA assistant in Blazor that turns rigid forms into a friendly chat. This post uses Microsoft.Extensions.AI, function tools, and JSON schema to steer the model while binding updates into EditContext and pairing a chat UI with a real form using Telerik components.

C# 14 and Clean Architecture: modeling expressive domains without boilerplate

Anderson Godoy shows how C# 14 can make domain models more expressive while guarding Clean Architecture boundaries. This post walks through using extension members to keep domain semantics in the right layer, field backed properties for normalization, and expanded partials that play nicely with source generators for IDs and converters. You get simple rules that cut helper sprawl and duplication while keeping real business rules visible.

Environment-based Configuration in ASP.NET Core

Mukesh Murugan demystifies environment-based configuration in ASP.NET Core, showing how appsettings files, environment variables, User Secrets, and launch profiles stack in .NET 10. You'll pick up practical patterns and precedence rules to keep secrets safe, tame per-environment overrides, and dodge common mistakes that cause those head-scratching prod bugs.

EF Core Lazy Loading Performance Gotcha

Mark Heath uncovers a sneaky EF Core ILazyLoader quirk that can fire off pointless database queries as soon as you call Add on a new entity. Build your object graph first, then add to the context right before saving to keep your app snappy.

Introducing OpenSilver 3.3: Blazor Components Now Run Directly Inside XAMLApplications

OpenSilver 3.3 lands with Blazor components running directly inside XAML apps, so you can drop DevExpress, Syncfusion, MudBlazor and more into MVVM views with native bindings and no interop tricks. This post highlights practical integration patterns, why it enables low risk WPF modernization across WebAssembly and MAUI Hybrid, and what else ships like .NET 10 support, a Responsive markup extension, and major WPF compatibility gains.

From Confusion to Clarity: My Journey Through C#, .NET, Azure DevOps, and Corporate Life

Rishabh Gupta maps a refreshingly honest path from confusion to clarity in C#, .NET 8, and ASP.NET MVC, highlighting the 2 AM aha moments that turn theory into useful code. This post favors real work over interview trivia, from tracing a request through the MVC pipeline to the realities of migrations, AI tools, and learning while holding a day job. If tutorial hell has you spinning, you will find practical guardrails that save weeks of trial and error.

Which .NET Version Should I Use Right Now?

Mahesh Chand cuts through .NET version churn with a rule of thumb and a plan you can trust. If you are juggling dependencies and deadlines, the decision framework and low risk checklist will save future you some headaches.

Autofac: The IoC Container That Makes Dependency Injection Click

Unpack dependency injection in .NET and how Autofac turns the 'don't use new' mantra into testable, maintainable code. If the built-in DI starts to chafe as your app grows, the examples make a grounded case for when Autofac is worth it.

Building a Self-Fixing .NET 10 App with AI Agents

Jean-Baptiste S. shows how to build a self-fixing .NET 10 setup that turns production exceptions into GitHub PRs. Backed by Azure Monitor, Application Insights, Redis dedupe, and a Semantic Kernel agent using Claude, this post covers the tool use loop, smart filtering, and prefetching code context to propose credible fixes. The result is less firefighting and a cost profile that fits real teams, not research labs.

We Almost Shipped a Broken .NET Build Because of NuGet Versions (Here's What Fixed It)

Abe Jaber recounts a near-release scare caused by NuGet version drift across a multi-project .NET repo, where CI and local restores disagreed. This post shows how Central Package Management with a single Directory.Packages.props at the repo root stops mismatched dependencies, yielding deterministic builds and easier upgrades. Perfect for teams juggling multiple APIs, workers, and tests who want fewer restore surprises.

New in .NET 10 and C# 14: EF Core 10's Faster Production Queries

Ali Hamza Ansari benchmarks EF Core 10 on .NET 10 with C# 14 against .NET 8, showing 25 to 50 percent faster read queries in a realistic PostgreSQL setup. This post pairs minimal API and DbContext code with BenchmarkDotNet, then unpacks why production workloads get faster, from JIT inlining and expression tree caching to leaner row materialization and small tweaks like static lambdas and JSON options. Perfect if you want practical steps and the mental model to make data access snappier without rewriting queries.

How to Build Android Widgets with .NET MAUI

Toine de Boer shows how to build Android home screen widgets with .NET MAUI by leaning on native RemoteViews, AppWidgetProvider, and Intents from your C# code. Rather than step by step, this post highlights production-minded patterns like data sharing with Preferences, interactive actions via PendingIntent, scheduled refreshes, and a minimal MAUI startup to keep widgets snappy. If you are shipping cross-platform widgets alongside iOS, you will pick up clear guidance on configuration screens, context pitfalls, and reliable update flows.

.NET drip - February 4, 2026

Wed, 04 Feb 2026 00:00:00 GMT

Playwright v1.58.0 Release

Playwright v1.58 brings a token efficient, agent friendly Skills CLI along with UI Mode and Trace Viewer polish, plus a new Speedboard timeline for merged reports that makes .NET E2E testing feel smoother. This post also highlights breaking selector removals and a devtools launch change, and adds an isLocal flag for CDP, helpful for keeping ASP.NET Core pipelines speedy and green.

Clean Architecture in .NET: Why I Stopped Fighting the Framework and StartedBuilding Better APIs

Rishabh Gupta turns Clean Architecture from buzzword soup into a practical guide for .NET Web APIs. This post shows how the dependency rule and a clean four layer split keep your domain independent of frameworks, with code examples and pitfalls that explain why testing and swaps like EF to Dapper get much easier. He also calls out when this approach is overkill so you use it where it truly pays off.

Maddy Montaquila: .NET Update - Azure & DevOps Podcast Episode #386

Jeffrey Palermo sits down with Maddy Montaquila, Senior Product Manager on the .NET Aspire team and former MAUI PM, to unpack the latest .NET update and what it means for building cross platform and cloud native apps. This podcast explores where Aspire and MAUI are headed, lessons from the Xamarin to MAUI journey, and practical guidance that can simplify your tooling and app architecture.

Azure Maps: Understanding View vs. Routing Coordinates

Why Azure Maps returns both a view coordinate and a routing coordinate for the same place, and how that split keeps your pins pretty and your directions accurate. In this post you will learn when to use the view coordinate for display and the routing coordinate for ETAs and turn-by-turn, plus which API fields identify each. If you have ever routed to the middle of a building or the wrong side of a divided road, this will help you fix it.

ASP .NET Core IDisplayMetadataProvider

Karen Payne shows how a custom IDisplayMetadataProvider turns FirstName into First Name across your ASP.NET Core views. This post contrasts it with the Display attribute, walks through simple Program.cs wiring and dynamic model discovery, and shares a sample repo that pairs the provider with FluentValidation to keep your UI clean and consistent.

Getting Started with the Aspire CLI - A Complete Guide

Chris Ayers gives a practical tour of the Aspire CLI for building and running distributed apps across .NET, Python, and JavaScript. If you want less config glue and an easier path to adding databases and caches, this post offers a clean workflow and the why behind it.

Deploying AI Applications to Azure Web Apps: A Practical Architecture Guide

Gregor Suttie shares a practical architecture for deploying AI-enabled apps on Azure Web Apps, treating the app as an orchestrator for Azure OpenAI rather than a model host. This post focuses on managed identities instead of API keys, private endpoints, Key Vault backed configuration, and observability with Application Insights, plus a Bicep example that keeps infra clean and auditable.

MCP Development with FireStore .NET, C# and Gemini CLI

William McLean walks through building a minimal MCP server in C# that plugs Gemini CLI into Firestore, then iterates by adding new tools directly from the CLI. This post focuses on why MCP makes .NET a solid fit for AI workflows language independence, a simple stdio transport, and Firestore backed tools that enable a real inventory scenario. It is a friendly blueprint for moving from local validation to cloud ready patterns.

.NET Toolbox

Steven Giesel kicks off the year with a free, open source .NET Toolbox built entirely client side to smooth out everyday dev tasks, especially for newcomers to web work. This post highlights a visual Middleware Designer that teaches common ASP.NET pipelines, flags pitfalls like authorization before authentication, and lets you simulate requests, plus a Package Centralizer that generates Directory.Packages.props from your csproj files to simplify version management.

8 "Finally Maintainable" Steps to Build a CRUD REST API with Clean Architecture+ DDD in .NET

Michael Maurice lays out eight pragmatic steps for building a maintainable CRUD REST API in .NET 10 using Clean Architecture and DDD. This post walks a tiny Products API through domain, application, infrastructure, and API layers so business rules live in the domain, EF Core stays in infrastructure, and controllers remain calm. If your last API grew into a ball of EF queries and if statements, these patterns show how to keep it testable and ready to grow.

Full-stack static typing with OpenAPI TypeScript and Microsoft.AspNetCore.OpenApi

John Reilly shows how to wire up end-to-end static typing between an ASP.NET Core Web API and a React TypeScript client by pairing Microsoft.AspNetCore.OpenApi with openapi-ts. He explains why OpenAPI 3.1 surfaces C# nullability more accurately than older tooling and how a couple of schema transformers tame number|string oddities, delivering a lean client and smaller bundles. If keeping front end and back end in sync without hand-written glue sounds good, this post maps out a pragmatic path with scripts you can drop into your workflow.

S3 Versioning in .NET - Protect Against Accidental Deletes and Recover Any File Version

Mukesh Murugan shows how to build a minimal .NET API that enables S3 bucket versioning, lists an object's history, restores older versions, and recovers deletes by handling delete markers. You will learn how version IDs and delete markers work under the hood, plus practical guardrails like IAM permissions, lifecycle policies to keep costs in check, and MFA delete for critical data. The patterns for audit trails, rollback to last known good, and scheduled cleanup make it easy to bake resilience into real apps.

.NET drip - February 2, 2026

Mon, 02 Feb 2026 00:00:00 GMT

5 C# Secrets That Make LINQ Queries 10x Faster (You're Using It Wrong)

Martin digs into five LINQ habits that separate clean code from fast code, showing how deferred execution, allocations, and query shape choices create hidden speed bumps. A friendly tune-up for hot paths that turns readable queries into production-ready performance.

IQueryable vs IEnumerable: What Every .NET Developer Must Know

Curious Orbit breaks down the real-world difference between IEnumerable and IQueryable in .NET, showing how LINQ runs in memory vs on the database and why that choice affects scalability. This post demystifies deferred execution and expression trees in EF Core, then highlights pitfalls like calling ToList or switching to AsEnumerable too early. You'll walk away knowing when each interface makes sense so your queries do the heavy lifting in the right place.

AWS Lambda SnapStart for .NET : Cut Cold Starts by 90% (With Benchmarks)

Mukesh Murugan shows how to enable AWS Lambda SnapStart for .NET 8 and chop cold starts by 58 to 94 percent using real benchmarks. This post walks through setup, the runtime hooks that warm JIT before snapshot and refresh secrets after restore, plus practical gotchas, costs, and when to pair SnapStart with Native AOT.

Gauge Controls: Real-time Performance Tracking, Player Stats in .NET MAUI

Leomaris Reyes explores Telerik's Gauge control for .NET MAUI as a fast, visual way to surface real-time stats in apps, from game-style health and stamina to progress tracking. This post explains when to use radial, vertical, and horizontal gauges and shows practical XAML snippets for indicators, ranges, gradients, and layout tweaks like StartAngle, SweepAngle, and AxisRadiusFactor.

Value Types and Reference Types in C#

Ajay Narkhedkar breaks down value types and reference types in C#, tying stack vs heap behavior to everyday bugs and performance surprises. This post clarifies how assignment and parameter passing really work, why string behaves differently, and when to pick struct or class for safer, faster code. A tidy mental model here can save your future self from head-scratching shared-state issues.

.NET 10 and C# 14 Null-conditional assignment

Henrique Siebert Domareski introduces C# 14 null conditional assignment in .NET 10, showing how you can safely set properties with ?. on the left of an assignment. By skipping writes when the target is null, this post trims boilerplate if checks and makes nested updates far less noisy. Great for working with optional aggregates without risking NullReferenceException.

How to Copy and Paste Events in Blazor Scheduler Using Clipboard

Mahesh Palanisamy shows how to add cut, copy, and paste to Syncfusion's Blazor Scheduler using built in clipboard support. If you are building scheduling UI in .NET, you will learn practical ways to reduce retyping and create a snappy, flexible workflow.

C# for Everything: One Language Powering the Modern Software World

Raghunath Bhukan charts how modern C# and .NET let teams build nearly anything, from high performance ASP.NET Core APIs to Blazor UIs, MAUI apps, Unity games, and ML.NET powered services, all within one ecosystem. This post highlights the real payoff in consistency and reuse: shared skills, tooling, and patterns that reduce context switching without sacrificing speed. It also calls out where C# is not the best fit so you can make clearer architecture bets.

Compile Time Checking of String Parameters in C#

Swapping input and output path strings is an easy bug the C# compiler will not catch. This post applies the make unrepresentable states unrepresentable idea by introducing marker types plus a generic AppSettingPath wrapper so constructors and methods demand the right path at compile time. The result is a tiny, testable pattern that clarifies intent and prevents costly runtime surprises.

Modern C# Error Handling Patterns You Should Be Using in 2026

Tejaswini Naresh IT maps how C# error handling evolved into design-first resilience for 2026. This post shows how typed exceptions, Result-style flows, centralized middleware, and structured telemetry turn failures into predictable, observable behavior your team can reason about. Less panic, more predictability for production apps.

Hello, here: Generics are here for nanoFramework

Announcing generics support in .NET nanoFramework and pulling back the curtain on the engineering that makes it work on tiny devices, from ECMA-335 friendly TypeSpec and MethodSpec to 16-bit tokens, caching and a new PE v2.0 format. This post focuses on why it matters in real code by adding Span, List and Stack plus stackalloc semantics so allocation-free patterns feel natural on microcontrollers. It also covers the preview firmware and tooling alignment you will need and notes a few debugger rough edges.

When Scoped DbContext Fails Real Production Scenarios

Compile & Conquer unpacks why EF Core's default scoped DbContext can trip you up in production, from singleton background services to parallel work and long-running reports. This post explains how the one request one context assumption leads to concurrency errors, stale data, and timeouts, and previews safer patterns like short-lived contexts and IDbContextFactory for better lifetime control. A friendly reality check for anyone building hosted services or parallel pipelines in ASP.NET Core.

.NET drip - January 30, 2026

Fri, 30 Jan 2026 00:00:00 GMT

Microsoft Agent Framework for .NET v1.0.0-preview.260121.1 Release

Microsoft's Agent Framework drops a new .NET preview that tightens APIs for building C# AI agents with async-only threads, the new AsAIAgent helpers, and consolidated options. This post highlights breaking changes and fresh samples like Durable Agents plus package updates to Microsoft.Extensions.AI 10.2.0 and Google.GenAI 0.11.0 so you can plan a smooth upgrade.

.NET Rocks! - MAUI in 2026 with Gerald Versluis

Carl and Richard catch up with Gerald Versluis on where .NET MAUI stands today and what is landing with .NET 10, including quality, performance, and ease of use improvements. If you build cross-platform UIs, this podcast unpacks MAUI's near-term roadmap and how it plays with Uno and Avalonia to make shipping smoother in 2026.

ReSharper 2026.1 Early Access Program Has Begun

Sasha Ivanova shares what is landing in the ReSharper 2026.1 EAP for C# devs, including smarter code generation that wires up LoggerMessage methods and a cleanup action that consolidates scattered extension members. This post spotlights inspections that catch ImmutableArray pitfalls and short-lived HttpClient patterns along with analysis speedups and a move from DPA to integrated performance monitoring so your code stays safer and your IDE feels snappier.

Announcing winapp, the Windows App Development CLI

Nikola Metulev unveils winapp, an open-source Windows App Development CLI that takes the grunt work out of building Windows apps with .NET, C++, Rust or Electron. This post highlights one-command setup for manifests, certs and SDKs, adding package identity for debugging without full packaging, plus simple MSIX packing and easier paths to Windows AI and Windows App SDK features for C# developers.

The Modern .NET Show - From Chaos to Control: Anton Moldovan on Load Testingwith NBomber

Jamie Taylor chats with NBomber founder Anton Moldovan about bringing load testing under your C# roof using a simple lambda based approach instead of a custom DSL. This podcast compares end to end user journeys with microservice isolation, shows how to plug results into xUnit and CI, and pairs load testing with chaos engineering to build resilient systems.

How to deploy .NET applications with systemd and Podman

Tom Deseyn shows how to containerize a .NET app with the .NET SDK, then run it as a reliable systemd service using Podman quadlets. This post explains why images simplify distribution and upgrades, how Microsoft.Extensions.Hosting.Systemd improves startup and logging, and what rootless containers, volumes, and a dedicated service user mean for safer day 2 operations.

Introduction to Pattern Matching in C#

Ajay Narkhedkar walks through modern C# pattern matching, showing how to replace brittle if-else ladders with expressive type, property, relational, logical, and positional patterns. This post leans on relatable scenarios like user roles, order statuses, and grading to show how you get safer casts, clearer intent, and tidier decision logic. Expect takeaways you can apply right away in APIs and business rules without the usual conditional spaghetti.

EF Core, Ad-Hoc Queries, and Plan Cache Pollution

Rodrigo Bercocano do Amaral unpacks a sneaky perf killer in EF Core: ad-hoc queries that pollute SQL Server's plan cache. In this post he shows how use counts in the plan cache reveals poor plan reuse, why interpolating values into FromSqlRaw causes single-use plans, and how LINQ or FromSqlInterpolated keep queries parameterized. The guidance is especially useful on Azure SQL where instance-level tweaks are limited, helping you keep CPU and memory steady.

FracturedJson - A family of utilities that format JSON data in a way that's easy for humans to read but compact

FracturedJson tackles the age-old choice between minified and pretty-printed JSON by formatting like a human would: inline when simple, compact multiline for arrays, and table-style alignment for similar objects. In this post, you'll learn the heuristics and options like MaxInlineComplexity and MaxTableRowComplexity that make diffs, logs, and config files easier on the eyes while staying compact, plus how comments can be preserved. It is available as a .NET library along with a browser formatter, VS Code extension, and more.

New in .NET 10 and C# 14: Enhancements in APIs Request/Response Pipeline

Ali Hamza Ansari benchmarks minimal APIs in .NET 8 and .NET 10 to show how the new LTS and C# 14 make request pipelines snappier. By combining JIT and GC improvements with practical tweaks like static lambdas and AllowOutOfOrderMetadataProperties, this post demonstrates lower latency and allocations, plus faster endpoint selection in ASP.NET Core. If you want to see which small changes yield big wins in real API scenarios, this post walks through reproducible benchmarks and code.

Use AI to Build Cross Platform Applications with Uno Platform, VS Code, Agentsand MCPs

Nick Randolph shows how to pair Uno Platform with VS Code and Model Context Protocol agents to have AI scaffold and iterate on a real cross platform C# app. This post is a practical look at making agents genuinely useful for .NET UI work, from new project templates to AI guided UI refinements.

Leveraging Span-Based String Concatenation for Improved Performance

Dig into span-based string concatenation and why it can be a tidy performance boost in hot paths. This post compares using ReadOnlySpan with string.Concat overloads to the usual + and StringBuilder, highlighting where allocations disappear and throughput improves. You get practical guardrails on when the span approach pays off and when simpler options are perfectly fine.

.NET drip - January 28, 2026

Wed, 28 Jan 2026 00:00:00 GMT

.NET MAUI Community Standup - Run .NET MAUI on Linux with Avalonia

David Ortinau, Gerald Versluis, Tim Miller, and Javier Suarez walk us through community updates, the origin story of Avalonia, Control Gallery, AlohaKit and several MAUI demos.

Windows Package Manager 1.12.460

The Windows Package Manager team ships 1.12.460 with App Installer moving to WinUI 3, manifest v1.12, and first class font support including a winget-font source plus install and uninstall. This post shows how the update smooths dev box setup and scripting with fixes for portable PATH upgrades and several reliability issues.

.NET 8.0.23 / 8.0.123 Release

Announcing the v8.0.123 release tag for .NET 8.0.23, with guidance on cloning the tag to build .NET from source or using the attached source archives. This post emphasizes PGP-signed tarballs and zipballs with a public key for verification, a practical boost for supply chain hygiene.

Recent updates to NetEscapades.EnumGenerators: new APIs and System.Memorysupport

Andrew Lock recaps new capabilities in NetEscapades.EnumGenerators 1.0.0-beta19 and why generated enum helpers can be dramatically faster than the built-in Enum APIs. This post introduces EnumParseOptions to turn off number parsing and control comparison behavior, plus SerializationOptions to emit lower or upper invariant names without extra allocations. It also adds ReadOnlySpan<char> APIs via System.Memory so span-based parsing works on netstandard2.0 and .NET Framework targets.

C# 14 New Feature: Implicit Span Conversions

Ian Griffiths unpacks C# 14’s implicit span conversions in .NET 10 and how they make Span and ReadOnlySpan feel first class. You will see why arrays and strings now flow cleanly into span-based APIs, enabling simpler signatures, better type inference, and extension methods that finally behave the way you expect. He also highlights gotchas with older libraries and offers practical design tips to avoid overload ambiguities.

End-to-End Observability for .NET on Azure: OpenTelemetry, Application Insights, and Azure Monitor

Sudhir Mangla maps the shift from the legacy Application Insights SDK to OpenTelemetry and shows how to get real end-to-end observability for .NET on Azure. This post focuses on why the change matters and gives a practical path with the Azure Monitor OTel distro, the Collector, solid log-trace correlation, and KQL-driven troubleshooting that keeps costs in check.

Strategy vs Factory in C#: The Confusion That Breaks Real Systems

Ravikumar Makwana explains the real difference between Factory and Strategy in C#, showing how confusing the two leads to brittle code and hidden bugs. Using payment and notification examples, he frames Factory as the choice for what to create and Strategy as the choice for how behavior varies at runtime, then composes them for a clean, testable design. If your code mixes creation and behavior checks, this post offers practical guidelines and sample implementations to simplify things without over-engineering.

Top 10 errors found in C# projects in 2025

A round-up of 10 real-world bugs PVS-Studio caught in 2025 C# projects, surfacing sneaky issues like null coalescing precedence, slippery pattern matching, and LINQ deferred execution with captured variables. This post shows why Equals and GetHashCode drift, why anonymous unsubscription does nothing, and how bit flags can make switch cases unreachable.

Records in C#: The Feature That Quietly Changed How I Write Code

Ravikumar Makwana shows how C# records, as data-first types, tame state bugs through value-based equality, immutability, and the with expression for safe updates. This post highlights where records shine in everyday code like DTOs and value objects, while keeping classes for behavior and identity. It closes with a simple rule of thumb to decide between records and classes.

Windows App SDK 1.8.4 Release (v1.8.260101001)

Microsoft ships Windows App SDK 1.8.4, a stability-focused update that trims the Windows ML DLL and adds playful new TextRewriter tones like Rewrite as Shakespeare and Rewrite in Sci‑fi. The release smooths out real world pain points for WinUI 3 apps, fixing Class not registered errors in self-contained deployments and improving StoragePickers, PublishSingleFile, and incremental builds. If you build Windows desktop apps in C#, this post shows what just got easier and why it matters.

Betatalks, the Podcast Episode #121 - Building Smarter Apps with .NET MAUI and ML.NET - with Anjuli Jhakry

Rick and Oscar chat with Anjuli Jhakry, a .NET MAUI developer and MVP building a startup app for people with food intolerances. She shares lessons from moving from Xamarin.Forms to .NET MAUI, why .NET 8 feels production ready, and how she uses ML.NET to learn from user feedback to deliver personalized recommendations. This podcast also hits on keeping architectures simple and how mentorship and community can accelerate developer growth.

ASP.NET Community Standup - What's next for Orleans?

Join Daniel Roth, Mike Kistler, and Reuben Bond discuss the future of Orleans in the ASP.NET Community Standup.

.NET drip - January 26, 2026

Mon, 26 Jan 2026 00:00:00 GMT

PostSharp 2026.0 Generally Available: Support for .NET 10, C# 14 and ExtensionBlocks

Gael Fraiteur announces PostSharp 2026.0 with full support for .NET 10 and C# 14, including the new extension blocks syntax. This post explains how aspects now skip extension block members by default and how to opt in with AllowExtensionBlockMembers, plus a helper to detect compiler-generated metadata. If you maintain AOP in mature codebases, you'll see what changed in the framework baselines and what to review before migrating.

.NET and .NET Framework January 2026 Servicing Releases Updates

Rahul Bhandari and Tara Overfield share the January 2026 servicing updates for .NET 10.0.2, 9.0.12 and 8.0.23, all non-security patches with links to runtime, ASP.NET Core, SDK, EF Core, WPF and WinForms changelogs. This post helps you gauge update urgency and zero in on fixes that might touch your stack, and it notes that .NET Framework has no new updates this month.

.NET MAUI 10.0.30 SR3 Release

.NET MAUI 10.0.30 SR3 doubles down on quality and developer experience with 100+ fixes across platforms, addressing navigation hangs, SafeArea quirks, and reliability in CollectionView, ScrollView, SearchBar, and Slider. This post also brings Android Material 3 opt in via a build property, sharper XAML binding behavior, refreshed docs and readmes, and sturdier testing so day to day MAUI work feels smoother.

Windows App SDK 1.7.7 (1.7.251220001)

Announcing the Windows App SDK 1.7.7 stable release, a focused maintenance update that steadies WinUI 3 development and fixes an issue that blocked Image Super Resolution on some devices. This post includes links to the release notes, NuGet, and WinUI Gallery for deeper details that may matter to your C# desktop apps.

Repository Pattern: The Right Way to Free Your Code from the Database

Melisa Akkuş shows how the Repository Pattern frees your business logic from EF Core, Dapper, and SQL by hiding data access behind a simple interface, so your services stop thinking in LINQ. This post goes interface-first, explains why returning IQueryable breaks the abstraction, and shows that swapping implementations often comes down to a DI registration, yielding easier tests and cleaner services.

RunAs Radio Show #1019 – Azure in 2026 with Jeremy Winter

Richard Campbell talks with Azure CPO Jeremy Winter about what Azure is rolling out in 2026, from SRE and resiliency agents to Azure Migrate updates, Kubernetes Fleet, and HorizonDB. The focus is on how Copilot and new automation make .NET apps sturdier, migrations less painful, and multi-cluster ops more manageable, along with the impact of new, more efficient global datacenters. This podcast helps you spot the services that could cut on-call noise and shape a practical 2026 cloud roadmap.

Choosing a Cross-Platform Strategy for .NET: MAUI vs Uno

J. Tower maps the real tradeoffs in choosing .NET MAUI vs Uno Platform by focusing on what you are optimizing for and the four questions that actually decide the choice: is web a first-class target, how broad your reach needs to be, native feel vs consistent visuals, and how complex your UI is. This post shows where MAUI’s native-control path fits and where Uno’s WebAssembly reach and design-system consistency pay off, plus a simple two-week prototype plan to test the decision on real workflows without months of debate.

Blue Blazes S04E01: Uno Platform – featuring Sam Basu

Jonathan Tower interviews Sam Basu, Microsoft MVP and Lead Developer Advocate at Uno Platform, about the present and future of cross-platform app development in .NET. This podcast explores how a single codebase can target iOS, Android, WebAssembly, Windows, macOS, and Linux with Uno, why its native and Skia rendering paths matter for performance and design consistency, and how it compares to .NET MAUI, React Native, and Flutter.

Factory Pattern in C#

Abhishek Yadav walks through the Factory pattern in C#, using a down to earth notification example and a Simple Factory implemented with a switch expression. This post shows how centralizing object creation reduces coupling, supports the Open Closed Principle, and keeps code easier to test, along with guidance on when to use the pattern and common pitfalls.

Blazor Community Standup - Planning the future of Blazor in .NET 11

Dan Roth, Javier Nelson, and Larry Ewing talk about the future of Blazor! In this video, they walk through the themes and ideas they're considering for .NET 11 and open the floor for your questions, suggestions, and experiences to help guide their next steps.

Modernizing Your Apps | Visual Studio Toolbox

Eriawan Kusumawardhono joins Robert Green on the Visual Studio Toolbox to show us how to use Copilot to modernize existing apps to use the latest technologies.

.NET Web Developer 2026 Roadmap - Brutally Honest Edition

Ed offers his annual .NET web developer roadmap offering his advice on what technologies to learn and which ones to skip. He also covers other topics like the developer job market and his favorite .NET books and YouTube channels. (Though he left out my favorite. 😉)

.NET drip - January 23, 2026

Fri, 23 Jan 2026 00:00:00 GMT

C# Is TIOBE Language of 2025

Mike James reports C# has been named TIOBE Programming Language of the Year 2025 after the biggest year-over-year gain, even as Python cools from its mid-2025 peak. This post explains what the index does and does not measure, ties the momentum back to Anders Hejlsberg's component-oriented vision for C#, and explores what rising share could mean for hiring and the .NET ecosystem. The takeaway is steady momentum that may push C# past Java soon, with practical implications for teams choosing languages and tooling.

Validation in .NET 10: Native Support for Minimal APIs

Prasad Raveendran walks through native validation for Minimal APIs in .NET 10, bringing them much closer to MVC controllers. This post shows how data annotations plus AddValidation enable a source generated validator that short circuits bad requests with consistent ProblemDetails, trimming boilerplate and keeping handlers focused on business logic. A small addition with a big impact on production readiness.

Fixing OllamaSharp Timeouts in C# (with a Simple Extension and just for fun)

El Bruno ran into 100-second HttpClient timeouts while using OllamaSharp for long-running local model work and traced it to the library's fixed client timeout. In this post he packages the fix as a small extension so you can set timeouts directly on the OllamaSharp client, with quick, standard, and long presets. If you are doing video analysis or lengthy generations, this keeps your runs alive and your code tidy.

Redis Cache Patterns Explained: Cache-Aside vs Read-Through vs Write-Through vs Write-Behind

Baibhav Kumar unpacks Redis caching patterns that shape real production behavior, focusing on who owns the source of truth, who handles failures, and where latency lands. This post contrasts cache-aside, read-through, write-through and write-behind with practical tradeoffs, and includes a C# cache-aside example for .NET apps. A clear guide to choosing the safer default vs when to accept risk for consistency or speed.

Azure SQL Database High Availability: Architecture, Design, and Built-in Resilience

Mohamed Baioumy from Microsoft explains how Azure SQL Database bakes high availability into the platform across General Purpose, Business Critical, and Hyperscale, and what actually happens during failover. This post walks through gateway routing, replica and storage models, and typical recovery times, then ties it back to app design with zone redundancy choices and why your .NET clients still need transient retries. Handy context for matching SLAs to the right tier while keeping ops overhead low.

ToonEncoder - A JSON-Compatible Format Encoder for C# and LLMs

Yoshifumi Kawai unveils ToonEncoder, a C# library that encodes a JSON-compatible TOON format to shrink LLM prompts by packing primitive object arrays into a compact, CSV-like layout. This post shows where TOON pays off in real apps, how to plug it into Microsoft.Extensions.AI with source generated converters using attributes like GenerateToonTabularArrayConverter and GenerateToonSimpleObjectConverter, and why encode only is often all you need for function calls. Expect practical guidance on selectively applying TOON so you save tokens while keeping JSON where it still fits best.

Repository Pattern vs Direct DbContext Usage in .NET

Yohan Malshika compares direct DbContext usage and the repository pattern in ASP.NET Core with EF Core, showing where each shines. This post lays out definitions, pros and cons, and a small code sample, then frames the decision around project size, domain complexity, and testing needs. You come away knowing when to keep it simple with DbContext and when an extra abstraction can save you pain later.

Everything You Need to Know About List in C#

Gulam Ali H. unpacks List beyond the dynamic array mental model, showing how capacity growth, resizing, and iteration rules shape performance and correctness. This post walks through what happens under the hood, why operations like Insert and Remove can surprise you at scale, and when EnsureCapacity, TrimExcess, or alternative collections are the better fit.

ASP.NET Core route constraints: A quick guide for developers

Round The Code gives a quick tour of ASP.NET Core route constraints for Minimal APIs, showing how to push validation to the edge with int, bool, Guid, date and string rules, plus regex and file path checks. If your endpoints need to be picky about inputs, this post shows how to make the URL do the heavy lifting.

Why string.Empty and "" Aren't Always the Same Reference in .NET

Jordan Rowles untangles why string.Empty and the empty string literal are usually the same object but can diverge when empty strings are created at runtime. This post demystifies string interning, how it impacts ReferenceEquals checks, memory usage, and debugging, and where String.Intern helps or hurts. Expect clear, practical guidance like preferring string.IsNullOrEmpty for checks and using string.Empty for intent.

The "Mixed Mode Operations" Anti-Pattern in ORMs

Atakan Serbes unpacks the Mixed Mode Operations anti-pattern in ORMs, where bulk SQL updates bypass the change tracker and leave EF Core out of sync with the database. A concise guide for speeding up large updates without breaking the mental model of your Unit of Work.

What Is the EF Core Model DbContext, OnModelCreating, and the Truth About Caching

Melisa demystifies how EF Core builds the IModel on first use, what DbContext actually does, and when OnModelCreating kicks in. This post explains why the model is cached and shared across DbContext instances, using a helpful blueprint vs worker analogy to make performance implications clear. Expect practical guidance on shaping the model with Fluent API and global filters without wasting cycles rebuilding metadata.

.NET drip - January 21, 2026

Wed, 21 Jan 2026 00:00:00 GMT

.NET Rocks!: Uno and .NET 10 with Sam Basu and Jerome Laban

Carl Franklin and Richard Campbell sit down with Jerome Laban and Sam Basu to unpack what .NET 10 means for the Uno Platform. This podcast connects the dots between Uno, MAUI, and WebAssembly, and digs into how AI with MCP can speed delivery and smooth legacy migrations.

WebForms Core Is Now Available on NuGet

Mohammad Rabie announces WebForms Core on NuGet, bringing a server driven UI runtime that integrates with ASP.NET Core, Razor Pages, and MVC. This post walks through the Commander and Executor model that sends intent based commands to the browser for deterministic updates, tiny payloads, and a stateless server, with a simple C# example that removes a DOM element without writing JavaScript. If you want SPA like interactivity without a front end framework, this offers a clean C# first path.

Announcing DotnetPsCmds - PowerShell CmdLets for .NET

Peter Ritchie introduces DotNetPsCmds, a PowerShell module that reimagines dotnet CLI tasks with object outputs, pipelining, and sensible defaults that make scaffolding .NET solutions and projects faster. This post shows how to compose solution and project creation, add package and project references, and reuse objects in pipelines, while trimming boilerplate files and avoiding noisy solution folders. You will see practical examples plus a short roadmap for templated solutions and solution level configuration.

.NET 10: Streaming over WebSockets with the New WebSocket Stream API

Anthony Giretti explores the new .NET 10 WebSocket stream API that makes sockets feel like regular Stream I/O. This post shows how treating a WebSocket as a Stream trims custom framing and loops in real world scenarios like large file transfers and real time feeds, with a client example that reads like copying between file streams. If Stream is second nature, this will slide right into your existing patterns.

Real Plugin Systems in .NET: AssemblyLoadContext, Unloadability, and Reflection-Free Discovery

Jordan Rowles digs into building production-ready plugin systems in .NET that can actually unload and hot reload without file locks or memory leaks. This post nails the AssemblyLoadContext mental model, plus patterns like shadow copying and reflection-free discovery with System.Reflection.Metadata to avoid type identity chaos and static cache leaks. A practical blueprint for safe contracts, realistic unload testing, and knowing when to move out of process.

Install and use Microsoft Dot NET 10 with the Raspberry Pi

Pete shares a practical guide to getting .NET 10 running on a Raspberry Pi and writing your first C# IoT apps. This post includes a one-line install script, a Hello World console, and hands-on GPIO samples to blink an LED and read a button, plus notes on board compatibility, library deprecations, and a 3A+ workaround. Great for going from fresh Pi to real pins without tripping over missing libs or numbering schemes.

Memento Pattern, Using The Command Pattern, and Domain Events in .NET

Jordan Rowles combines the Memento pattern, the Command pattern, and domain events in .NET to deliver reliable undo, redo, and a complete audit trail without exposing internals. This post walks through a practical Order aggregate with commands, snapshots, and event replay, showing how the pieces fit for real apps where state changes matter.

New in .NET 10 and C# 14: EF Core 10' Faster Production Queries

Ali Hamza Ansari breaks down how .NET 10 and C# 14 make EF Core 10 queries faster in production, with benchmarks showing 25 to 50 percent gains. In this post he explains the why behind the speedups including JIT inlining, expression tree caching, and leaner row materialization, and shows small code changes like static lambdas and relaxed JSON metadata ordering that reduce allocations. You will come away knowing which improvements matter and how to apply them to real APIs.

Azure.AI.Translation.Text v2.0.0-beta.1 Release

Azure's .NET Translator SDK hits 2.0.0-beta.1 with support for the Azure AI Translator 2025-10-01-preview API, bringing LLM translations, adaptive custom translation, tone variants, and gender-aware output. This post highlights important breaking changes like renamed properties and removed options, helping you plan a smooth migration for multilingual apps.

Dependency Injection Made Simple: A Practical .NET Core Guide

Darshan Adakane makes dependency injection in ASP.NET Core feel simple, moving from tightly coupled code to interface-first design that is easy to test and evolve. In this post you will compare constructor and parameter injection, register services in Program.cs, and see how Transient, Scoped, and Singleton lifetimes shape behavior. A friendly guide that helps your services play nicely together without turning your code into a tangle.

ASP.NET Core roadmap for .NET 11

Dan Roth shares the ASP.NET Core roadmap for .NET 11, an early look at priorities rather than a feature list. The focus spans fundamentals like performance and reliability, doubling down on Minimal APIs, Blazor, SignalR and gRPC, plus easier distributed apps with Aspire. It also explores agentic web apps via the Microsoft Agent Framework and Copilot assisted development through MCP servers and custom agents.

C# 14 Extension Members: Complete Guide to Properties, Operators, and Static Extensions

Laurent tours C# 14 extension members, which go beyond methods to let you add properties, operators, and static members to types you don't control. This post shows how extension blocks can make APIs feel native and more readable, with examples like operator math on Point and IEnumerable factories, plus guidance on ref receivers, resolution rules, and migrating from classic extensions.

.NET drip - January 19, 2026

Mon, 19 Jan 2026 00:00:00 GMT

XAML Studio is now Open Sourced

Michael Hawker opens up XAML Studio under the .NET Foundation, turning the WinUI prototyping workhorse into a community-driven project. This post explains how years of building XAML Studio spawned reusable Windows Community Toolkit controls like SwitchPresenter, the Sizer suite, and experimental Adorners, and what V2 adds for faster XAML iteration with live editing and debugging.

The 2025 Year-End Performance Review for .NET

Viktor Ponamarev recaps a zero overhead year for .NET, where Adaptive Server GC in .NET 9 and sharper JIT work in .NET 10 delivered real memory and throughput gains with almost no tuning. This post shows how params Span in C# 13 and the preview of C# 14 killed hidden array allocations while Garnet, MemoryPack, Sep, and Frozen collections turned common workloads into lean, fast paths. Expect practical insights on getting faster apps by upgrading the runtime and choosing specialized libraries instead of rewriting logic.

Deep C# – The Console

Mike James demystifies the Windows console for .NET by showing how to open and attach a console from non-console apps using a few Win32 calls. Ideal when you want quick logging or interactive I/O without building a custom UI.

Introduction to Delegates in C#

Ajay Narkhedkar demystifies C# delegates showing how to pass behavior without tight coupling. This post walks through single-cast and multicast delegates, passing delegates as parameters, and the built-in Func, Action, and Predicate, then connects the dots to events and LINQ. Expect practical patterns to make your code more flexible, testable, and calm under change.

C# 14 Improved Lambda Expressions: Using ref, in, and out Parameters for High-Performance Code

Raghunath walks through C# 14’s upgraded lambdas that accept ref, in, and out parameters, trimming boilerplate and enabling in-place updates and copy-free reads. This post highlights when these modifiers shine and closes with a handy decision guide to balance speed and readability.

Custom Validator in ASP.NET Core MVC (Beginner-Friendly)

Walk through creating custom validation in ASP.NET Core MVC, from a simple MinimumAge attribute to a cross property date check with IValidatableObject. This post shows how validation fires in API controllers, how errors surface via ModelState, and how to exercise the rules in Postman without any Razor or JavaScript. Perfect when built in attributes are close but not quite enough and you want clean, reusable domain rules.

Why Serious Engineering Teams Are Reconsidering .NET in 2025

Spencer Thomason argues that .NET 10 is winning teams back through refinement, not reinvention, with runtime and memory improvements that actually matter under load and less ceremony like running a single C# file. If you are weighing stacks, you will find a practical view of how modern C# now fits the realities of enterprise delivery.

.NET Concurrency, Parallelism, and async/await

Patrik Duch untangles the knots between concurrency, parallelism, and async/await in .NET, clarifying that async is about nonblocking work rather than extra CPU. With a clear mental model and a practical CI test example, this post shows when to embrace concurrency and when true parallelism actually makes things faster. Expect fewer threading myths and more confident performance choices.

C# 14 Field Keyword: Simplifying Property Accessors

Laurent Kempé explores C# 14's new field keyword and how it bridges the gap between auto-properties and full property logic. This post shows practical patterns like validation, transformations, lazy initialization, and MVVM-friendly change notifications without manual backing fields, along with nuances such as contextual usage and property initializers. The result is cleaner properties, simpler migrations, and fewer refactoring pitfalls in .NET 10 projects.

Add Tailwind 4 to an ASP.NET Core 10 MVC or Razor Pages project

Jerrie Pelser shows how to wire Tailwind 4 into an ASP.NET Core 10 MVC or Razor Pages app without a heavy front-end pipeline. Using the Tailwind CLI, the new @import and @source directives, and a small MSBuild target, this post generates site.css in wwwroot on every build while keeping client files neatly isolated. Ideal if you want utility-first styling that is predictable in local dev and CI.

Build AI Agents with Microsoft Agent Framework in C#

Mashrul Haque introduces Microsoft Agent Framework, the preview successor to AutoGen and Semantic Kernel, and shows how to build practical AI agents in C# without duct tape. This post covers getting started with Microsoft.Extensions.AI, adding memory with threads, wiring up C# tools, and orchestrating multiple agents, plus hard won notes on token costs, errors, and shifting APIs. A clear look at what you gain by consolidating on the new model and how to try it safely.

Simplifying Code Signing for Windows Apps: Artifact Signing (GA)

Microsoft rebrands Trusted Signing to Artifact Signing and makes it generally available for Windows app developers. This post shows how the fully managed service handles short-lived certificates, verified publisher identity, RBAC, and full audit trails while plugging into GitHub Actions, Azure DevOps, Visual Studio, MSBuild, and signtool.

.NET drip - January 16, 2026

Fri, 16 Jan 2026 00:00:00 GMT

C# 14 More Partial Members: Partial Events and Partial Constructors

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 vNext Emulator: Query and Observability Enhancements

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.

Enterprise Patterns for ASP.NET Core Minimal API: Identity Map Pattern

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.

The Practical Series Every .NET Developer Needs Before Building Real Backends (Part 1)

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.

What is Redis and how does it fit into Clean Architecture in a .NET application

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.

3x Faster, 99.9% Less Memory: Optimizing .NET String Processing

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.

.NET 10 and ASP.NET Core: Refinements That Matter in Production

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.

Handling Time Zones & Dates Correctly in .NET

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.

Understanding SQL and NoSQL Distributed Transaction Problem in C# — Transactional Outbox Pattern

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.

Type-Safe Collections in C#: How NonEmptyList Eliminates Runtime Exceptions

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.

TDD in .NET: Refactoring Safely

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 Introduced LeftJoin and RightJoin

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.

.NET drip - January 14, 2026

Wed, 14 Jan 2026 00:00:00 GMT

Does C# 14’s field Keyword Replace FluentValidation?

A crisp walkthrough of C# 14’s field keyword and why it doesn’t replace FluentValidation. Field streamlines property-level invariants by letting you set the compiler-generated backing field directly, while FluentValidation remains the go-to for contextual, cross-property, user-friendly input rules at application boundaries. The upshot is a layered approach: field for safeguarding domain integrity, FluentValidation for rich input validation.

Rock Your Code: Code & App Performance for Microsoft .NET (5th Edition)

David McCarter’s Rock Your Code: Code & App Performance for Microsoft .NET (5th ed.) is a hands-on, benchmark-driven guide to writing fast, scalable C# for .NET 10 and beyond. It dives into real-world patterns for memory, collections, LINQ, strings, I/O, and more plus analyzers, caching, logging, serialization, source generators, and the Spargine library balancing runtime speed with cloud cost. A companion to his coding standards book, it helps you think like a performance engineer from the first line of code.

The Complete Guide to C# .NET Input Controls

Ever wrestled with phone-number masks, culture-aware numbers, or a dropdown that needs to be searchable? This guide surveys C#/.NET input controls text, masked, numeric, date/time, and selection then shows how ComponentOne’s editors (C1TextBox, C1MaskedTextBox, C1NumericBox, C1DateRangePicker, C1MultiSelect, etc.) bring validation, formatting, and localization together across WinForms, WPF, ASP.NET Core, Blazor, WinUI, and .NET MAUI. It’s a practical look at when to stick with native widgets versus reaching for richer controls to cut boilerplate and keep behavior consistent.

Channels in C# .NET: Building High-Performance Concurrent Pipelines

A friendly primer on System.Threading.Channels shows how to build high-throughput, async pipelines in .NET without drowning in locks and polling. It contrasts Channels with ConcurrentQueue and manual synchronization, highlights bounded channels for built‑in backpressure, and walks through producer/consumer patterns using ChannelWriter/Reader, await foreach, and graceful completion. You’ll also get practical use cases, best practices, and context on why ASP.NET Core leans on Channels for predictable performance under load.

TDD in .NET: Practicing TDD in a Web API Project

Ajay Kumar walks through a pragmatic, layered TDD approach for a .NET Web API by building a “get expenses by category” endpoint in an Expense Manager app. He splits responsibilities across controller, service, and repository, using Moq and in-memory fakes to keep tests fast, DTOs to protect boundaries, and the red–green–refactor loop to guide design. It’s a clear blueprint for what to test, what to mock, and how to keep your API thin, tidy, and change‑friendly.

The C# ‘Best Practice’ that is secretly killing your API performance

A cautionary tale for clean-code fans: spinning up a new HttpClient in a using block per request can quietly trigger socket exhaustion under load thanks to TIME_WAIT. The author recounts a real production outage at an event check-in system and shows how IHttpClientFactory, named clients, and DI-backed connection pooling fix it with reused sockets and sensible timeouts. A crisp reminder that HttpClient is special and how to keep high-throughput .NET APIs from melting their ephemeral ports.

Practical JWT Mastery in .NET

Part 4 of a practical JWT-in-.NET series strips the mystery from signatures covering hash basics, HMAC (HS256), and why symmetric keys can bite you in microservices. It contrasts RSA/ECDSA’s private/public split, introduces JWKS for safe rotation and discovery, previews verification in code, and tees up how a validated token becomes HttpContext.User reminding us that strong, well-guarded keys (not algorithm glitter) keep your APIs honest.

The 10 Most Interesting C# Bugs We Found in Open Source in 2025

Static-analysis sleuthing meets real-world C# in a roundup of ten noteworthy bugs uncovered across open-source projects in 2025. Rather than just gawking at glitches, it teases out the patterns behind them and how analyzers and better idioms can catch issues earlier handy guardrails for your day-to-day .NET work. A light, practical tour of pitfalls that quietly ship to prod and the habits that keep them from tagging along.

.NET 10 & C# 14: Less Code, Better Performance

.NET 10 and C# 14 get a down-to-earth walkthrough aimed at everyday dev pain points less boilerplate, more zip. On the C# side you’ll see chained ??= for deep object graphs, a new field keyword to safely work with auto-property backing fields, and ref/out/in-friendly lambdas for zero-copy hot paths. Platform-wise, it highlights cleaner left-join patterns and JSON partial updates in EF Core, built-in validation for minimal APIs, and friendlier quick-script workflows practical wins from CRUD to performance-heavy code.

Enable Modern Run dialog box in Windows 11

Windows 11 Insider builds are rolling out a modernized Win+R Run dialog, and this walkthrough shows how to enable it either via a Settings toggle or a quick registry edit, then restart Explorer). Targeting recent Dev/Beta previews like build 26220, it’s a small but welcome quality-of-life tweak for developers who live in Win+R to launch tools, scripts, and system commands.

Getting Started with Microsoft Agent Framework

A friendly, code-first tour of Microsoft Agent Framework (MAF) positioned as the successor to Semantic Kernel showing how to build C# agents with tool/function calling, strongly-typed structured outputs, and durable threads without playing framework roulette. It also covers RAG with a vector store and TextSearchProvider plus Azure AI Foundry’s managed agents, illustrating how MAF blends SK’s integrations with AutoGen-style orchestration to take you from local experiments to production.

Background Jobs in .NET: Hangfire, Quartz, Temporal in 2026

A clear, real-world guide to background work in .NET 9+, comparing BackgroundService, Hangfire, Quartz.NET, and Temporal what each does well, how retries with exponential backoff are handled, and how to wire up monitoring and tracing with OpenTelemetry. It includes concise C# examples and a pragmatic decision map to know when a simple hosted service will do, when you need a scheduler and dashboard, and when your flows call for a durable workflow engine in 2026.

.NET drip - January 12, 2026

Mon, 12 Jan 2026 00:00:00 GMT

Create and Read JWT Tokens in C# .NET

A quick, code-first walkthrough of creating and reading JWTs in C# using System.IdentityModel.Tokens.Jwt covering claim selection, HMAC-SHA256 signing, and parsing token headers/claims without validation. It emphasizes real-world guardrails (JWTs are readable, validate on the backend, set expirations, and prefer certificates over shared secrets) and points toward production patterns like refresh tokens and role-based authorization. A tidy primer whether you’re prototyping an auth flow or tightening up an API.

How to generate Code Coverage for a .NET Solution

David Guida walks through wiring up Coverlet to generate solution‑wide code coverage in .NET, including a GitHub Actions pipeline that merges results across test projects, outputs both JSON and OpenCover, and drives a README badge. He also covers the real-world gotchas: running tests sequentially (-m:1) to avoid cross-project contamination and excluding test assemblies via a .runsettings file so your numbers actually mean something. A tidy, copy‑pasteable setup to keep your .NET 8 codebase honest without a build-pipeline yak shave.

Azure Cost Estimation: Your Strategic Guide to Cloud Pricing

Azure Essentials tackles unpredictable cloud bills with a practical, three-layer approach to estimating Azure costs architecture, configuration, and usage so your .NET workloads don’t surprise the finance team. Thomas Maurer and Britt walk through modeling scenarios with the Azure Pricing Calculator and Azure Migrate, then show how Azure Advisor, Cost Management, Copilot in Azure, and Monitor help refine and optimize over time. A clear, developer-friendly blueprint for turning “it depends” into numbers you can plan around.

C# 14 in Action: High-Performance Lambda Expressions with Parameter Modifiers

C# Corner breaks down how C# 14 levels up lambdas with parameter modifiers (ref, in, out), pushing them closer to full method parity for clearer intent and faster paths in real-world code. Through scenarios like hot-loop updates, large-struct reads, Try-parse patterns, and buffer processing, it shows how these enhancements trim boilerplate, improve API design, and keep performance-sensitive code as readable as your favorite LINQ.

7 Mistakes .NET Developers Should Avoid

This concise guide calls out seven career-slowing pitfalls for .NET devs and offers practical upgrades: move from .NET Framework to .NET 6/7/8 and ASP.NET Core, write cleaner SOLID code, practice C# problem-solving, and get comfortable with Azure, Docker, Git, and CI/CD. It also reminds us that communication, documentation, and tests aren’t extras they’re how you ship confidently. A friendly gut-check for keeping skills sharp and relevant.

Digital Essentialism in .NET: How Verdict is Redefining the Result Pattern

Meet Verdict, a ‘digital essentialism’ take on the Result pattern for .NET that uses a readonly struct to keep the happy path allocation-free backed by eye-popping benchmarks (e.g., 189x faster than FluentResults) and far less GC pressure. It pairs the lean core with opt-in goodies like ASP.NET Core ProblemDetails mapping, LoggerMessage-based logging, async chaining, and multi-error validation handy for APIs and microservices chasing lower latency and lower cloud costs.

Partial Events and Constructors in C# 14 (.NET 10) Explained with Examples

C# 14 (on .NET 10) introduces partial constructors and partial events, finally letting you split initialization and event accessors across files so source-generated and hand-written code play nicely together. The article walks through practical patterns init hooks, customizable add/remove accessors, and generator-friendly APIs plus gotchas, best practices, and why there’s no runtime cost. A tidy upgrade for anyone juggling source generators, ORMs, or UI frameworks who wants cleaner seams and fewer merge headaches.

Hybrid Cache & Output Caching in .NET: A Game Changer for High-Performance Applications

A friendly walkthrough of Hybrid Cache and Output Caching in modern ASP.NET Core, showing how Hybrid Cache marries IMemoryCache speed with distributed stores (like Redis) behind a single, resilient API while Output Caching serves full HTTP responses instantly. With clear code snippets and a realistic e‑commerce scenario, it highlights when these patterns shine (and when they don’t) and the kind of gains you can expect think ~300ms down to ~20ms and far fewer DB hits on read‑heavy endpoints. Less cache plumbing, more throughput.

SQL Server Regular Expression Performance and Guidelines

SQL Server 2025 brings native regex functions to T‑SQL (compat level 170), and Ben Johnston road-tests them with practical, real-world guidance. The headline: REGEXP_REPLACE is often a big win that simplifies gnarly text cleanup, but REGEXP_LIKE can be 10–50x slower than LIKE on big tables and tends to scan rather than seek so filter first and test, especially with Unicode. He maps each regex function to its legacy counterpart, showing where they shine (imports/parsing) and when the old standbys are still the better choice.

Changing Immutable Collections

Jon Skeet explains why, for build-once/read-many workloads, FrozenDictionary and ImmutableArray can beat ImmutableDictionary and ImmutableList and shows the usage patterns that make the difference. He details a mostly drop-in migration (new namespace, Count→Length, value-type nullability tricks with .Value or pattern matching) and the real-world gotchas. The payoff: read-heavy validation fell from ~5.5ms to ~0.826ms, with some naming nitpicks and value-type awkwardness as the only lingering gripes.

What’s New with APIs in .NET 10: Taking a Look at Real Improvements

Dave Brock walks through .NET 10 and C# 14 from an API developer’s seat, using a tidy order-management API to show why the changes matter in practice. Highlights include built-in Minimal API validation with ProblemDetails, OpenAPI 3.1 (including YAML endpoints), SSE support, and EF Core 10’s named query filters for safer multi-tenant data plus C# 14’s field keyword, null-conditional assignments, and extension members to trim boilerplate. A practical, no-drama tour of upgrades that make APIs cleaner, better documented, and easier to evolve.

C# Smart Enums: advanced

Part 3 of the Smart Enums series shows how to end the copy‑paste parade by moving enum lookup logic into a generic base class that uses the CRTP pattern. With a per‑type static dictionary, Initialize() to skip reflection, and Get/GetOrDefault/TryGet APIs, you get O(1) lookups, strict type safety, and zero boilerplate perfect when your app juggles lots of status types. Tested on .NET 6, with references to generics constraints and Ardalis.SmartEnum for production‑grade inspiration.