2026
203 postsSignalR Authentication Refresh in .NET 11: No More Forced Reconnects on Token Expiry
.NET 11 lets SignalR clients swap in a fresh access token on a live connection instead of forcing a reconnect when the old one expires. Here's how to configure it on the server and client, and where the guardrails are.
Extension Indexers in C# 15: Finally, this[] on Types You Don't Own
C# 15 rounds out extension members with indexers, letting you add this[] syntax to types you can't modify. Here's how the syntax works, how resolution is prioritised against real indexers, and where the preview feature still bites.
ASP.NET Core Ditches CSRF Tokens for Fetch Metadata in .NET 11
.NET 11 introduces an automatic CSRF protection middleware that uses browser Fetch Metadata headers instead of tokens. It's on by default, requires no code changes, and fundamentally changes how cross-site request forgery is handled in ASP.NET Core.
ReSharper 2026.2 Brings Debugging to VS Code, Cursor, and Every Editor Microsoft Locked Out
ReSharper 2026.2 ships the most requested feature for its VS Code extension: a full debugger built on the Rider engine. With Microsoft's C# Dev Kit banned from Cursor and other editors, JetBrains now offers the only complete .NET development experience outside Visual Studio and Rider.
The MSBuild Binlog MCP Server Turns Your AI Assistant into a Build Detective
Microsoft's Binlog MCP Server exposes 38 tools that let AI assistants query MSBuild binary logs directly, turning cryptic build failures and performance bottlenecks into natural-language conversations.
LINQ Finally Gets FullJoin and Tuple-Returning Overloads in .NET 11
.NET 11 adds Enumerable.FullJoin for full outer joins and tuple-returning overloads for Join, GroupJoin, LeftJoin, and RightJoin, eliminating the result selector boilerplate that has plagued LINQ joins since 2007.
Closed Class Hierarchies in C# 15: Exhaustive Matching Comes to Inheritance
C# 15 introduces the closed modifier for class hierarchies, restricting derivation to the declaring assembly and enabling exhaustive switch expressions without a default arm. Here is how it works, how it differs from unions and sealed classes, and where it fits in domain modelling.
dotnetup: The .NET SDK Version Manager That Should Have Existed Years Ago
Microsoft is building dotnetup, an official cross-platform .NET SDK and runtime version manager inspired by rustup. Here's what it does, how it works with global.json, and why it matters for teams and CI pipelines.
SkiaSharp 4.0 Reaches Stable with 24% Faster GPU Rendering and Animated WebP Support
SkiaSharp 4.148.0 is the first production-ready v4 release, delivering up to 24% faster GPU rendering, animated WebP encoding via SKWebpEncoder, a legacy-free API surface, and critical lifecycle fixes. Here is what changed since Preview 1 and how to migrate.
Blazor SSR Finally Gets Client-Side Validation in .NET 11
With .NET 11 Preview 5, Blazor SSR forms gain automatic client-side validation and a new async validation pipeline, closing the biggest gap between static rendering and interactive modes.
Aspire 13.4: TypeScript AppHost Goes GA, Plus Go, Bun, and Blazor WASM Integrations
Aspire 13.4 lands at Build 2026 with TypeScript AppHost graduating to general availability, new hosting integrations for Go, Bun, and Blazor WebAssembly, process-backed resource commands, persistent resource lifetimes, and a stack of Kubernetes deployment improvements.
.NET MAUI Moves to CoreCLR: The End of the Mono Split
.NET 11 Preview 4 makes CoreCLR the default runtime for MAUI on Android, iOS, and Mac Catalyst, ending the long-standing Mono/CoreCLR split and bringing tiered JIT, PGO, full diagnostics, and a path to NativeAOT on mobile.
C# Is Redesigning unsafe: What Safety Contracts Mean for Your Code
C# is overhauling the unsafe keyword from a syntax gate into a formal safety contract system with propagation, suppression boundaries, and documentation requirements. Here is what changes, how it compares to Rust, and what you need to do to prepare.
Foundry Local 1.1: Running AI Models on Device in Any .NET Application
Foundry Local lets you ship AI-powered .NET applications that run entirely on the user's device — no cloud, no per-token costs, no network latency. Version 1.1 adds text embeddings, live audio transcription, and broadens .NET compatibility all the way back to .NET Framework 4.6.1.
HTTP QUERY: The New Method That Fixes What GET and POST Got Wrong
.NET 11 Preview 4 adds first-class support for the HTTP QUERY method -- a safe, idempotent verb that accepts request bodies. Here is how it works in ASP.NET Core, why it matters for API design, and where the ecosystem stands today.
Escape Analysis in .NET 10: How the JIT Eliminates Heap Allocations Automatically
The .NET 10 JIT compiler can now prove that many objects never leave their parent method and allocate them on the stack instead of the heap, eliminating GC pressure without any code changes.
[PersistentState] in .NET 10: Blazor Finally Solves the Prerendering State Problem
.NET 10 introduces the [PersistentState] attribute, replacing dozens of lines of manual serialisation boilerplate with a single attribute. It also extends state persistence to services, enhanced navigation, and circuit reconnection.
WebSocketStream in .NET 10: Treating WebSockets Like Any Other Stream
The new WebSocketStream class in .NET 10 wraps a WebSocket in a standard System.IO.Stream, eliminating the frame-management boilerplate that has plagued WebSocket code for years and unlocking the entire stream ecosystem for WebSocket transports.
Aspire 13.3: Kubernetes Deployment with Helm, Browser Telemetry, and a CLI That Cleans Up After Itself
Aspire 13.3 ships native Kubernetes deployment via Helm, browser telemetry streaming, three JavaScript publishing models, and an aspire destroy command that tears down what aspire deploy created. Here is what changed and why it matters.
Global Exception Handling in ASP.NET Core with IExceptionHandler
IExceptionHandler gives ASP.NET Core apps a structured, testable, and chainable way to handle exceptions globally — replacing hand-rolled middleware and scattered try-catch blocks with a first-class framework feature.
Durable Workflows in the Microsoft Agent Framework: From Prototype to Production
The Microsoft Agent Framework can define multi-agent workflows, but they vanish when the process dies. The Durable Task extension fixes that, taking your workflows from in-memory prototypes to fault-tolerant, scalable Azure Functions deployments without changing your workflow code.
GitHub Copilot Testing for .NET: AI-Powered Unit Tests That Actually Build and Run
Visual Studio 2026 ships a purpose-built @Test agent that generates, builds, runs, and self-heals C# unit tests across your entire solution. Here is how the workflow operates, what it does well, and where you still need to think for yourself.
A2A v1 in .NET: Cross-Platform Agent Communication Without the Glue Code
The A2A protocol gives AI agents a standard way to discover and talk to each other across frameworks, languages, and vendors. With v1 shipping in the Microsoft Agent Framework for .NET, here is how to expose and consume agents over A2A using familiar ASP.NET Core patterns.
PostgreSQL as a Distributed Cache in .NET: One Database, Two Jobs
Microsoft's new Caching.Postgres package turns your existing PostgreSQL instance into a distributed cache. Combined with HybridCache, it delivers a tiered caching architecture without adding Redis to your infrastructure.
Governing MCP Tool Calls in .NET with the Agent Governance Toolkit
The Agent Governance Toolkit gives .NET developers policy-based control over MCP tool execution, from prompt injection detection to privilege rings. Here is how to lock down your AI agents before they reach production.
VSTest Drops Newtonsoft.Json: What Changes for Your Test Projects in .NET 11
VSTest is removing its long-standing Newtonsoft.Json dependency in .NET 11 Preview 4, switching to System.Text.Json on .NET and JSONite on .NET Framework. Here's what breaks, why it matters, and how to fix it.
SkiaSharp 4.0 Preview 1: Variable Fonts, Immutable Paths, and a New Co-Maintainer
SkiaSharp 4.0 Preview 1 lands with Skia milestone 147, a proper variable font API, immutable SKPath backed by SKPathBuilder, colour font palettes, and Uno Platform stepping in as co-maintainer. Here is what changed and what it means for your .NET graphics code.
CVE-2026-40372: The ASP.NET Core Data Protection Flaw That Demands More Than a Patch
A critical HMAC validation bug in Microsoft.AspNetCore.DataProtection lets attackers forge authentication cookies and decrypt protected payloads. Upgrading to 10.0.7 fixes the code, but key rotation and artifact auditing are essential to close the window fully.
Node.js Native Addons in C#: Replacing C++ and node-gyp with .NET Native AOT
The C# Dev Kit team replaced their C++ Node.js addon with C# compiled via .NET Native AOT, eliminating Python and node-gyp from their build chain. Here's how N-API, UnmanagedCallersOnly, and LibraryImport make it work.
Asp.Versioning Meets Built-In OpenAPI: Versioned API Documentation in .NET 10
Asp.Versioning v10.0.0 brings first-class integration with .NET 10's built-in OpenAPI library, replacing the Swashbuckle-era workarounds with a single AddOpenApi call, automatic per-version documents, and RFC 9745 deprecation headers.
Visual Studio Goes Rolling: What the 2027 Announcement Means for .NET Teams
At VSLive! Las Vegas, Microsoft confirmed that Visual Studio 2027 will arrive as an in-place update to 2026 — not a side-by-side install. Here is how the new annual rolling release model, decoupled build tools, and LTSC channels change daily life for .NET developers.
UnsafeAccessorAttribute: Zero-Overhead Private Member Access Without Reflection
UnsafeAccessorAttribute lets you access private fields, methods, and constructors at the same speed as direct calls — no reflection, no Reflection.Emit, and full Native AOT compatibility. Here's how to use it, when it makes sense, and where developers trip up.
.NET 10 on Ubuntu 26.04: One apt install Away from a Clean Linux Setup
Ubuntu 26.04 LTS ships .NET 10 in the default package archive, ending years of package conflicts and multi-feed confusion. Here is what changed, how to set up your environment, and what the new container images and Native AOT tooling look like.
Pin Clustering Arrives in .NET MAUI Maps: No More Third-Party Dependencies
.NET 11 Preview 3 adds built-in pin clustering to the MAUI Map control, grouping nearby markers automatically on iOS, Mac Catalyst, and Android without requiring external packages.
Writing Node.js Native Addons in C# with .NET Native AOT
Microsoft's C# Dev Kit team replaced their C++ Node.js addons with C# and Native AOT, eliminating Python dependencies and simplifying their build pipeline. Here is how N-API, UnmanagedCallersOnly, and a custom DLL import resolver make it work.
CVE-2026-40372: The Data Protection HMAC Bug That Made Cookie Forgery Trivial on Linux
Microsoft's emergency .NET 10.0.7 out-of-band update patches a CVSS 9.1 flaw in the Data Protection managed encryptor. If you run ASP.NET Core on Linux, your HMAC validation was effectively broken since .NET 10 shipped.
Blazor's Virtualize Component Finally Handles Variable-Height Items in .NET 11
.NET 11 Preview 3 reworks the Virtualize component to measure actual item heights at runtime using a running average, eliminating the broken spacing and scroll jumps that plagued lists with variable-height content since the component shipped in .NET 5.
EF Core 11 Preview 3: Cheaper Change Tracking, Safer Migrations, and Cleaner SQL
EF Core 11 Preview 3 ships GetEntriesForState to bypass DetectChanges, ExcludeForeignKeyFromMigrations for cross-boundary relationships, migration tree divergence detection, and leaner join generation. It also bumps SqlClient to 7.0 and makes MigrationsNotFound throw by default.
#:include Lands in .NET 11: File-Based Apps Finally Go Multi-File
.NET 11 Preview 3 adds the #:include and #:exclude directives to file-based apps, letting you split scripts across multiple files without reaching for a .csproj. Here is how they work, what they don't do, and where the edges still need sanding.
.NET April 2026 Security Patches: SMTP Header Injection and XML Recursion Bombs Explained
Microsoft's April 2026 servicing update patches two high-severity vulnerabilities in System.Net.Mail and System.Security.Cryptography.Xml. Here is how they work, why they matter, and what you need to do.
TickerQ: The Source-Generated Job Scheduler That Skips the Reflection Tax
TickerQ replaces the reflection-heavy plumbing of Hangfire and Quartz.NET with compile-time source generators, EF Core persistence, and a built-in real-time dashboard. Here is how to set it up, define jobs, and avoid the gotchas.
dotnet watch Finally Works With Aspire: Per-Resource Hot Reload in .NET 11
The .NET 11 Preview 3 SDK ships a named-pipe coordination layer between dotnet watch and Aspire AppHosts, enabling per-resource hot reload, crash recovery with deferred relaunch, and proper Ctrl+C handling for Windows desktop apps.
The Visual Studio Debugger Agent: From Bug Report to Verified Fix Without Leaving the IDE
Visual Studio 18.5 ships a Debugger Agent that reads your bug report, sets breakpoints, watches runtime state as you reproduce the issue, and proposes a verified fix. Here is how the workflow operates and where it fits alongside the existing Profiler and custom agents.
.NET 11 JIT and Runtime Improvements: Free Performance You Didn't Ask For
.NET 11 Preview 3 ships JIT improvements that eliminate bounds checks, fold switch expressions into branchless code, and speed up casts -- plus VM-level wins like 200x faster interface dispatch on iOS and faster GUID generation on Linux. Here is what changed and why it matters.
System.Text.Json in .NET 11: PascalCase, Per-Member Naming, and Type-Level Ignore
Three new features in .NET 11 Preview 3 give you fine-grained control over JSON serialisation: a built-in PascalCase naming policy, a per-member naming attribute, and type-level ignore conditions.
System.Threading.Lock: The Purpose-Built Lock That Replaces Your object Hack
Since .NET 9, the System.Threading.Lock type gives you a dedicated, faster, and semantically clearer alternative to locking on a bare object. Here is how it works, why it is roughly 25% faster than Monitor, and what to watch out for when migrating.
.NET 11 SDK Preview 3: The CLI Improvements That Sharpen Your Inner Dev Loop
.NET 11 Preview 3 brings multi-file file-based apps via #:include, inline environment variables with dotnet run -e, CLI-editable solution filters, and a dotnet watch that recovers from crashes and integrates with Aspire.
Full-Text Search in EF Core 11: Ranked Results Without Leaving LINQ
EF Core 11 finally brings first-class full-text search support for SQL Server, including migration-managed catalogs and indexes, and FREETEXTTABLE/CONTAINSTABLE translation with ranking scores baked into your LINQ queries.
System.IO.Pipelines: The High-Performance I/O API You're Still Not Using
System.IO.Pipelines is the API that powers Kestrel's legendary throughput, yet most .NET developers still reach for raw streams and byte arrays. Learn how PipeReader and PipeWriter eliminate the buffer-management nightmare and give you backpressure for free.
Orleans: The Virtual Actor Framework That Makes Distributed .NET Feel Like Local Code
Orleans turns distributed systems into a problem you already know how to solve. Its virtual actor model lets you write single-server C# that the runtime scales across a cluster, handling activation, placement, and fault recovery behind the scenes.
Azure MCP Server 2.0: The Bridge Between Your AI Agents and Your Azure Infrastructure
Azure MCP Server 2.0 ships with self-hosted remote deployment, 276 tools across 57 Azure services, and enterprise-grade authentication. Here is what .NET developers need to know to wire AI agents into their cloud infrastructure.
User-Defined Compound Assignment Operators: The C# 14 Feature That Kills Needless Allocations
C# 14 lets you define instance-level +=, -=, ++, and other compound assignment operators that mutate in place instead of allocating new objects. Here's how they work, when they fall back, and where the pitfalls hide.
LeftJoin and RightJoin: The LINQ Operators That Should Have Existed From Day One
.NET 10 adds first-class LeftJoin and RightJoin methods to both System.Linq and EF Core 10, replacing the infamous GroupJoin-SelectMany-DefaultIfEmpty incantation with something you can actually read.
TypedResults: The Minimal API Return Type That Writes Your OpenAPI Spec for You
TypedResults and the Results<T1, T2> union pattern give Minimal API endpoints compile-time safety, automatic OpenAPI metadata, and cleaner unit tests. Here is how to use them properly and why they should be your default.
XenoAtom.Terminal.UI: A Reactive TUI Framework That Treats the Terminal Like a Real UI Platform
XenoAtom.Terminal.UI brings retained-mode rendering, reactive state binding, and 60+ composable controls to .NET terminal applications. Here is why it is worth your attention if you build CLI tools or dashboards.
SearchValues: The .NET Type That Turns Text Searching Into a SIMD Problem
SearchValues<T> analyses your search criteria once at creation time, then uses SIMD vectorisation and specialised algorithms to search spans at speeds most hand-written loops cannot match.
Keyed Services in .NET: The Built-In DI Feature You're Probably Not Using Yet
Keyed services bring named registrations to .NET's built-in dependency injection container, replacing custom factories and IEnumerable filtering with a clean, attribute-driven approach that works across the entire ASP.NET Core stack.
TUnit: The Source-Generated Testing Framework That Skips Reflection Entirely
TUnit replaces runtime reflection with compile-time source generation for test discovery, delivering faster execution, Native AOT support, and compile-time safety that xUnit, NUnit, and MSTest cannot match.
SQL MCP Server: Microsoft's Answer to the NL2SQL Problem
Microsoft's SQL MCP Server gives AI agents deterministic, RBAC-secured access to SQL Server, PostgreSQL, Cosmos DB, and MySQL without generating a single line of raw SQL. Here is how it works and why it deliberately avoids NL2SQL.
The .slnx Solution Format: .NET 10's Quiet Revolution in Project Organisation
.NET 10 makes .slnx the default solution format, replacing the decades-old .sln with clean XML, zero GUIDs, and merge-friendly structure. Here is how to migrate and what to watch out for.
First-Class Span Types in C# 14: The End of Overload Sprawl
C# 14 promotes Span<T> and ReadOnlySpan<T> to first-class citizens with implicit conversions, smarter type inference, and new overload resolution rules that eliminate the need for duplicate API overloads across arrays and spans.
Named Query Filters in EF Core 10: The End of the Single-Filter Workaround
EF Core 10 finally lets you attach multiple named query filters to a single entity type and disable them selectively, replacing the awkward && chaining workaround that has haunted multi-concern filtering for years.
Passkeys in ASP.NET Core 10: Phishing-Resistant Auth Without the Third-Party Dependency
ASP.NET Core 10 ships with built-in passkey support in Identity, bringing WebAuthn registration and authentication into the framework. Here's how it works, what the API surface looks like, and where you'll still need a third-party library.
Kiota: Microsoft's OpenAPI Client Generator That Understands Your API's Shape
Kiota generates strongly typed API clients from OpenAPI specs using a hierarchical request builder pattern. Here's how to use it, wire it into DI, and avoid the pitfalls that trip up most teams.
ASP.NET Core 2.3 End of Support: The Clock Is Ticking on .NET Framework's Last Bridge
Microsoft has announced that ASP.NET Core 2.3 on .NET Framework reaches end of support on April 7, 2027. Here is what that means, why the version number is stranger than it looks, and how to plan your migration.
Mapperly: The Source-Generated Mapper That Makes AutoMapper Feel Like Legacy Code
Mapperly generates object mapping code at compile time using Roslyn source generators, delivering hand-written performance with zero reflection. Here is how to use it and why teams are switching.
Microsoft Agent Framework 1.0: Building AI Agents in .NET Without the Guesswork
Microsoft Agent Framework 1.0 merges Semantic Kernel and AutoGen into a single, production-ready SDK for building AI agents in .NET. Here is what the unified model looks like, how tools and middleware work, and where workflows fit in.
Garnet: Microsoft's High-Performance Redis Alternative Built on .NET
Garnet is a Redis-compatible cache store from Microsoft Research that outperforms Redis at both low and high concurrency. Here's how to use it from your .NET applications.
HybridCache: The .NET Caching API That Should Have Existed Years Ago
HybridCache combines in-process and distributed caching behind a single API, with built-in stampede protection, tag-based invalidation, and zero-allocation reads for immutable types. Here is how to use it and why it replaces most hand-rolled IDistributedCache code.
The field Keyword in C# 14: Backing Fields Without the Boilerplate
C# 14 introduces the field contextual keyword, letting you add validation, lazy initialisation, and change notification to properties without declaring explicit backing fields. Here's how it works, what it compiles to, and where it falls short.
Blazor Finally Gets TempData: Flash Messages and PRG Without the Workarounds
.NET 11 Preview 2 brings TempData to Blazor static SSR as a cascading parameter, enabling flash messages, one-time notifications, and the POST-Redirect-GET pattern without custom state hacks.
EF Core 11 Preview: One-Step Migrations, Full-Text Indexes, and the End of Sync I/O
EF Core 11 brings one-step migrations, managed full-text search indexes, complex types with TPT/TPC inheritance, MaxBy/MinBy translation, and a hard cut from synchronous Cosmos DB access. Here is what matters and what will break.
Wolverine: The .NET Message Handler That Replaced Half My Infrastructure
Wolverine combines in-process mediation, asynchronous messaging, and a transactional outbox into a single handler model with zero-reflection code generation. Here is why it is worth evaluating if your project has outgrown MediatR.
Visual Studio 2026: The AI-Native IDE That Actually Earned the Title
Visual Studio 2026 shipped on March 31 with AI agents for profiling and debugging, Razor cohosting inside Roslyn, decoupled toolchains, and over 5,000 bug fixes. Here is what matters for .NET developers.
Server-Sent Events in ASP.NET Core: Native Streaming Arrives in .NET 10
.NET 10 adds first-class Server-Sent Events support with TypedResults.ServerSentEvents, SseItem<T>, and a client-side SseParser. No more hand-rolled text/event-stream responses -- here is how the new API works from endpoint to EventSource.
File-Based Apps in .NET 10: Scripts, Prototypes, and the End of Boilerplate
The dotnet run app.cs feature in .NET 10 lets you run C# from a single file with NuGet references, shebang support, and native AOT publishing -- no project file required. Here is how it works, where it shines, and where the edges still bite.
Vector Search in EF Core: From Exact Distance to Hybrid Search with SQL Server 2025
EF Core now supports native vector search against SQL Server 2025, from exact VECTOR_DISTANCE queries to approximate DiskANN-indexed VECTOR_SEARCH and hybrid search combining semantic and full-text results.
Native OpenTelemetry Tracing in ASP.NET Core: .NET 11 Drops the External Dependency
ASP.NET Core in .NET 11 Preview 2 natively populates OpenTelemetry semantic convention attributes on HTTP server activities, eliminating the need for the OpenTelemetry.Instrumentation.AspNetCore package. Here is what changed, how to migrate, and what to watch out for.
Post-Quantum Cryptography in .NET 10: ML-KEM, ML-DSA, and SLH-DSA from System.Security.Cryptography
With .NET 10 shipping built-in support for three NIST-standardised post-quantum algorithms, here is how ML-KEM, ML-DSA, and SLH-DSA work in practice, what the APIs look like, and what you need to watch out for on different platforms.
Collection Expression Arguments in C# 15: Passing Capacity, Comparers, and More with the with() Syntax
C# 15 adds the with() element to collection expressions, letting you pass constructor arguments like capacity and comparers directly inside the bracket syntax. Here is how it works, what it compiles to, and where it falls short.
The Copilot Profiler Agent in Visual Studio 2026: AI-Driven Performance Tuning That Actually Works
Visual Studio 2026's Copilot Profiler Agent combines AI with the built-in performance profiler to find bottlenecks, generate BenchmarkDotNet benchmarks, and suggest verified fixes — all from a natural language prompt.
The GitHub Copilot SDK for .NET: Embedding Agentic AI Into Your Own Applications
The GitHub Copilot SDK hit public preview this week, giving .NET developers programmatic access to the same agent runtime behind Copilot CLI. Here's how to wire it up with custom tools, streaming, and BYOK support.
Microsoft.Extensions.AI: The Unified AI Abstraction Layer for .NET
Microsoft.Extensions.AI provides IChatClient, IEmbeddingGenerator, and VectorStoreCollection abstractions that decouple your .NET code from specific AI providers, with a middleware pipeline for caching, telemetry, and function calling.
Runtime Async in .NET 11: The End of Compiler-Generated State Machines
How .NET 11's runtime async moves async/await handling from the compiler into the runtime itself, delivering cleaner stack traces, better debugging, and reduced allocations without changing a line of your code.
Union Types in C# 15: Exhaustive Pattern Matching Without the Workarounds
C# 15 introduces union types with the union keyword, bringing implicit conversions, exhaustive switch expressions, and compiler-enforced closed type sets to .NET. Here is what they look like, how they lower to structs, and where they replace the OneOf hacks.
Zstandard Compression in .NET 11: Faster Than Brotli, Built Into the Box
A practical guide to the new Zstandard compression APIs in .NET 11, covering streaming, one-shot, and dictionary-based compression alongside ASP.NET Core and HttpClient integration.
The modernize-dotnet Agent: AI-Powered .NET Upgrades Across Every IDE
Microsoft's modernize-dotnet Copilot agent brings structured, AI-driven .NET upgrades to Visual Studio, VS Code, the CLI, and GitHub.com -- turning what used to be a week-long migration into a reviewable, three-stage workflow.
JetBrains 2026.1: ReSharper Breaks Out of Visual Studio, Rider Gets an ASM Viewer
ReSharper 2026.1 ships as a VS Code extension, adds built-in performance monitoring, and fixes dozens of OOP-mode issues. Rider 2026.1 lands file-based C# programs, a native assembly viewer, and an open AI agent registry. Here is what matters for .NET developers.
Aspire 13.2: An AI-Agent CLI, TypeScript AppHosts, and a Dashboard That Exports Everything
Aspire 13.2 ships a CLI built for coding agents, preview TypeScript AppHost support, a telemetry export API, and a stack of new Azure integrations. Here is what changed and what it means for your workflow.
Custom Copilot Agents in Visual Studio 2026: Building Team-Specific AI Workflows
Visual Studio 2026 v18.4 introduces custom agents defined as .agent.md files in your repository, letting teams build AI workflows with workspace awareness, MCP connections, and access to IDE tooling like the new find_symbol tool.
The MCP C# SDK Hits v1.0: Building AI Tool Servers in .NET
The official Model Context Protocol C# SDK has reached v1.0 with authorization, icon metadata, elicitation, and task support. Here is how to build production MCP servers that expose your .NET services to AI agents.
Extension Members in C# 14: Properties, Operators, and Static Extensions
C# 14 overhauls extension syntax with extension blocks that support properties, operators, and static members. Here's how the new syntax works, when to migrate, and what you still can't do.
878 Pull Requests Later: What the .NET Team Learned from Copilot Coding Agent
The .NET team ran GitHub's Copilot Coding Agent against dotnet/runtime for ten months. The data tells a nuanced story about where AI excels, where it struggles, and what your team needs to get right before adopting it.
The NuGet MCP Server: AI-Powered Package Management in Your IDE
The NuGet MCP Server brings AI-driven package management to Visual Studio, VS Code, and GitHub Copilot agents — letting you fix vulnerabilities, update dependencies, and query package info through natural language.
Null-Conditional Assignment in C# 14: Less Ceremony, Fewer Bugs
C# 14 lets you assign to properties and indexers through the ?. and ?[] operators, eliminating a whole class of repetitive null checks. Here's how to use it, where it shines, and what the compiler won't let you do.
Running .NET in Web Workers: The New dotnet new webworker Template
How to use the new first-party Web Worker project template in .NET 11 Preview 2 to offload CPU-intensive work from the browser's main thread, keeping your Blazor WebAssembly UI responsive.
.NET Agent Skills: Teaching Your Coding Agent to Think in C#
Microsoft's dotnet/skills repository gives AI coding agents specialised .NET knowledge through the open Agent Skills standard. Here's how the system works, what's available, and how to set it up in your editor.
.NET 11 Preview 2: Runtime Async, Native OpenTelemetry, and AI-Ready EF Core
A practical walkthrough of the standout features in .NET 11 Preview 2, from runtime-native async and built-in OpenTelemetry tracing to vector search in EF Core and a resilient Kestrel parser.
TimeProvider: Finally, Testable Time in .NET
How System.TimeProvider in .NET 8 replaces years of IClock wrappers with a first-class abstraction for testable, deterministic time — and how FakeTimeProvider makes testing time-dependent code straightforward.
Worker Services and the .NET Generic Host
How to build long-running background services in .NET using the Generic Host and BackgroundService, with practical patterns for queue processing and scheduled tasks.
.NET Runtime Configuration Knobs You Should Know
A guide to the most useful .NET runtime configuration settings for GC tuning, threading, diagnostics, and globalisation.
Service Discovery in .NET: From Aspire to Production
Understand how .NET service discovery works in Aspire's AppHost, through configuration, and via DNS in production environments.
Making Your .NET Application Trim and AOT Ready
How to prepare your .NET application for IL trimming and Native AOT compilation, including common pitfalls and analysis tools.
Managing .NET SDK Versions with global.json
How to use global.json to pin SDK versions, manage roll-forward policies, and keep your team on the same toolchain.
Structured Logging with OpenTelemetry in .NET
Move beyond plain text logs with structured logging that integrates with OpenTelemetry and correlates with distributed traces.
.NET 9: The Features Worth Knowing About
A curated overview of the most impactful new features in .NET 9 for application developers.
Upgrading from .NET 6 to .NET 8: A Practical Checklist
A step-by-step guide to upgrading your .NET 6 applications to .NET 8, covering breaking changes, TFM updates, and common pitfalls.
The Configuration Binding Source Generator in .NET 8
How .NET 8's configuration binding source generator eliminates reflection from your configuration pipeline and improves AOT compatibility.
Distributed Tracing in .NET: Following Requests Across Services
Learn how distributed tracing works in .NET using Activity, ActivitySource, and W3C trace context propagation.
The LoggerMessage Source Generator: High-Performance Logging
How the LoggerMessage source generator eliminates boxing, string allocation, and reflection in .NET logging for maximum throughput.
IOptions, IOptionsSnapshot, and IOptionsMonitor: Choosing the Right One
Understanding the three options interfaces in .NET's configuration system and when to use each one.
SignalR Performance Tuning in .NET
Optimise SignalR for high-throughput scenarios with transport selection, buffer tuning, serialisation choices, and connection management strategies.
Protobuf Serialization in .NET with Google.Protobuf and gRPC
A practical guide to using Protocol Buffers in .NET for efficient, schema-driven serialization in gRPC services and beyond.
The JSON Source Generator in System.Text.Json
How the System.Text.Json source generator eliminates reflection-based serialisation, improving startup time and enabling AOT compilation.
OpenTelemetry in .NET Aspire: Traces, Metrics, and Logs
Understand how Aspire configures OpenTelemetry for automatic instrumentation and how to extend it with custom telemetry.
MessagePack Serialization for High-Performance .NET Services
How to use MessagePack-CSharp for compact, fast binary serialization in .NET applications and when to choose it over JSON.
JSON Source Generation for AOT-Ready .NET Applications
How to use System.Text.Json source generators to eliminate reflection and make your serialization AOT-compatible.
Writing Custom JsonConverters in System.Text.Json
A hands-on guide to building custom JsonConverter implementations for System.Text.Json, from simple value converters to complex object converters.
The Regex Source Generator Explained
How .NET 7's GeneratedRegex attribute uses source generation to compile regular expressions at build time for better performance.
Health Checks in .NET Aspire: Monitoring Service Readiness
Configure health checks in Aspire to monitor service readiness, database connectivity, and downstream dependency availability.
Migrating from Newtonsoft.Json to System.Text.Json
A practical guide to migrating your .NET projects from Newtonsoft.Json to System.Text.Json, covering API differences, gotchas, and incremental adoption strategies.
Background Notifications via SignalR
Push real-time notifications to clients from background services, message queues, and scheduled jobs using IHubContext.
Integration Testing with .NET Aspire
Use Aspire's testing support to write integration tests that spin up real infrastructure and validate your services end to end.
Attribute-Driven Source Generation Patterns
Explore patterns for using marker attributes to drive source generation, including attribute discovery, property extraction, and handling edge cases.
Testing Source Generators with Microsoft.CodeAnalysis.Testing
A practical guide to testing source generators and analysers using the official Microsoft.CodeAnalysis.Testing framework.
Building Custom Resources in .NET Aspire
Learn how to create custom Aspire resources for infrastructure components that do not have built-in support.
Emitting Diagnostics from Analysers and Source Generators
Learn how to report errors, warnings, and informational messages from analysers and generators using the Roslyn diagnostics API.
RabbitMQ in .NET Aspire: Messaging Between Services
Add RabbitMQ messaging to your Aspire application with automatic broker provisioning, connection management, and telemetry.
Debugging Source Generators: Techniques That Actually Work
Practical strategies for debugging source generators, from Debugger.Launch() to emitting generated files to disk.
The IIncrementalGenerator Pipeline: Transforms, Filters and Caching
A deep dive into the incremental generator pipeline operators — Where, Select, Collect, and Combine — and how they enable efficient caching.
Azure SignalR Service: Managed Real-Time at Scale
Offload WebSocket connection management to Azure SignalR Service and scale to thousands of concurrent connections without infrastructure headaches.
PostgreSQL in .NET Aspire: From Container to DbContext
Wire up PostgreSQL with Entity Framework Core in Aspire, from AppHost container declaration to fully configured DbContext injection.
Using Redis with .NET Aspire: Caching Made Simple
Add Redis caching to your Aspire application with automatic container management, connection wiring, and health checks.
Incremental Source Generators: A Practical Guide
A hands-on introduction to incremental source generators, the modern replacement for ISourceGenerator that offers dramatically better IDE performance.
Code Fix Providers: Turning Analyser Warnings into One-Click Fixes
Learn how to pair a Roslyn analyser with a code fix provider that offers automated corrections directly in the IDE.
The Aspire Dashboard: Your Distributed Application at a Glance
Explore the Aspire dashboard's capabilities for monitoring logs, traces, and metrics across your distributed .NET application.
Aspire Service Defaults: What They Do and Why They Matter
Understand the ServiceDefaults project in .NET Aspire and how it configures resilience, health checks, and telemetry across all your services.
Writing a Custom Roslyn Analyser from Scratch
Build a custom Roslyn analyser that flags methods exceeding a configurable line count, complete with project setup and testing.
SignalR with Blazor: Real-Time UI Updates
Integrate SignalR with Blazor Server and Blazor WebAssembly to build reactive user interfaces that update in real time.
Aspire AppHost: Orchestrating Your .NET Applications
Learn how the Aspire AppHost project wires up services, databases, and messaging into a single orchestrated local development environment.
Syntax Trees and the Semantic Model: Roslyn's Two Pillars
Understand how Roslyn represents code as syntax trees and enriches it with semantic meaning through the semantic model.
Client Reconnection Strategies for SignalR
Build resilient SignalR clients that handle disconnections gracefully with automatic reconnection, state recovery, and user feedback.
Platform Lifecycle Events in .NET MAUI
Understanding and handling platform lifecycle events in .NET MAUI for backgrounding, resuming, and managing app state across platforms.
Markdig: Parsing and Rendering Markdown in .NET
Use Markdig to parse Markdown into HTML with support for extensions like tables, task lists, and custom renderers.
Hot Reload and Productivity Tips for .NET MAUI Development
Maximise your .NET MAUI development speed with XAML Hot Reload, .NET Hot Reload, and practical productivity techniques.
Humanizer: Making Data Human-Readable in .NET
Use Humanizer to transform strings, dates, numbers, and enums into human-friendly text with minimal code.
Streaming Data with SignalR in .NET
Use SignalR's server-to-client and client-to-server streaming to handle continuous data flows like live feeds and file uploads.
Scrutor: Assembly Scanning for .NET Dependency Injection
Use Scrutor to automatically register services by convention, eliminating repetitive DI registration code in .NET applications.
Drawing with Microsoft.Maui.Graphics: Custom UI Without SkiaSharp
How to use the built-in Microsoft.Maui.Graphics API for custom drawing, charts, and visual effects in .NET MAUI.
YARP: Building a Reverse Proxy in .NET
Use YARP (Yet Another Reverse Proxy) to route, load balance, and transform HTTP traffic in your .NET applications.
MessagePack Protocol for SignalR: Faster, Smaller Messages
Switch SignalR from JSON to MessagePack for smaller payloads and faster serialisation in performance-sensitive applications.
CollectionView Patterns in .NET MAUI: Beyond the Basics
Practical patterns for CollectionView in .NET MAUI including grouping, selection, empty states, incremental loading, and layout customisation.
MassTransit: Message-Based Communication in .NET
Use MassTransit to build event-driven .NET applications with RabbitMQ or Azure Service Bus without coupling to a specific transport.
Scaling SignalR with a Redis Backplane
Learn how to scale SignalR across multiple servers using Redis as a backplane for message distribution.
Webhook Patterns in .NET: Sending and Receiving
How to implement webhook sending and receiving in ASP.NET Core, covering signature verification, retry logic, and reliability patterns.
Data Binding Deep Dive in .NET MAUI
An in-depth look at .NET MAUI data binding modes, value converters, compiled bindings, and multi-bindings.
Dapper: Fast Data Access with Raw SQL in .NET
Use Dapper for high-performance database queries when you want full control over your SQL without the overhead of a full ORM.
Dependency Injection in .NET MAUI: The Built-In Container
How to use the built-in Microsoft.Extensions.DependencyInjection container in .NET MAUI for pages, view models, and platform services.
Hangfire: Fire-and-Forget Background Jobs in .NET
Use Hangfire to queue, schedule, and monitor background jobs with automatic retries and a built-in dashboard.
Custom Handlers in .NET MAUI: Replacing the Old Renderer Model
How to create custom handlers in .NET MAUI to customise native control behaviour, replacing the legacy custom renderer approach.
SignalR Groups and User Management
Master SignalR groups for targeted message delivery and learn how to manage user-to-connection mappings effectively.
API Rate Limiting in ASP.NET Core
How to implement rate limiting in ASP.NET Core using the built-in rate limiting middleware with fixed window, sliding window, and token bucket algorithms.
Quartz.NET: Scheduling Recurring Jobs in .NET
Use Quartz.NET to schedule cron-based and interval-triggered jobs with persistent storage and dependency injection.
Building MAUI Blazor Hybrid Apps: Web UI Meets Native Power
How to build .NET MAUI Blazor Hybrid apps that combine Razor components with native device capabilities.
Authentication and Authorisation in SignalR
Learn how to secure SignalR hubs with JWT bearer tokens, cookie authentication, and granular authorisation policies.
Polly v8: Resilience Pipelines for .NET Applications
Build retry, circuit breaker, and timeout strategies with Polly v8's new resilience pipeline API in .NET.
ETags and Conditional Requests in .NET APIs
How to implement ETags and conditional requests in ASP.NET Core for efficient caching and safe concurrent updates.
Platform-Specific Code in .NET MAUI with Partial Classes
How to use partial classes and multi-targeting to write clean platform-specific code in .NET MAUI without cluttering your shared logic.
Mapster vs AutoMapper: Which Object Mapper Should You Use?
Compare Mapster and AutoMapper on performance, configuration, and developer experience to pick the right object mapper for your .NET project.
Shell Navigation in .NET MAUI: Routes, Parameters, and Deep Linking
A comprehensive guide to Shell-based navigation in .NET MAUI, covering route registration, query parameters, and URI-based deep linking.
Idempotency in APIs: Making Retries Safe
How to implement idempotent API endpoints in .NET using idempotency keys, preventing duplicate operations from network retries.
Strongly-Typed SignalR Hubs: Eliminating Magic Strings
Replace fragile SendAsync calls with compile-time safe interfaces using strongly-typed SignalR hubs in .NET.
Serilog Structured Logging: Beyond Console.WriteLine
Set up Serilog for structured logging in .NET with sinks, enrichers, and message templates that make logs queryable.
MVVM Made Simple with CommunityToolkit.Mvvm in .NET MAUI
How to use CommunityToolkit.Mvvm source generators to eliminate MVVM boilerplate in your .NET MAUI applications.
FluentValidation: Expressive Input Validation for .NET
Build readable, testable validation rules with FluentValidation instead of scattering data annotations across your models.
Migrating from Xamarin.Forms to .NET MAUI: A Practical Guide
A step-by-step guide to migrating your Xamarin.Forms application to .NET MAUI, covering project structure changes, namespace updates, and common pitfalls.
HATEOAS in Practice: Hypermedia Links in .NET APIs
A pragmatic approach to implementing HATEOAS in ASP.NET Core APIs, adding discoverable links without over-engineering.
SignalR Hub Patterns: Structuring Real-Time Endpoints in .NET
Explore common patterns for organising SignalR hubs in .NET applications, from simple chat examples to well-structured production code.
MediatR Pipeline Behaviours: Cross-Cutting Concerns Without the Mess
Use MediatR pipeline behaviours to cleanly inject logging, validation, and caching into your request pipeline without polluting handler logic.
Pagination Patterns: Cursor vs Offset in .NET APIs
A comparison of cursor-based and offset-based pagination in .NET APIs, with implementation examples and guidance on when to use each.
Automatic Versioning with Nerdbank.GitVersioning
Use Nerdbank.GitVersioning to derive deterministic, semver-compliant versions from your Git history without manual version bumps.
Refit: Typed HTTP Clients for .NET
How to use Refit to generate strongly typed HTTP clients from interface definitions, eliminating boilerplate HttpClient code.
.NET SDK Container Publishing: No Dockerfile Required
Publish .NET applications as container images directly from the SDK without writing a Dockerfile.
API Documentation with Scalar and OpenAPI in .NET
How to generate interactive API documentation in ASP.NET Core using OpenAPI and Scalar as a modern alternative to Swagger UI.
Code Coverage in CI for .NET Projects
Collect, report, and enforce code coverage thresholds in your .NET CI pipeline using Coverlet and ReportGenerator.
SourceLink: Debug NuGet Packages Like Your Own Code
Enable SourceLink in your .NET libraries so consumers can step into your source code directly from the debugger.
Directory.Build.props Patterns for .NET Solutions
Use Directory.Build.props to centralise build settings, enforce standards, and reduce duplication across .NET projects.
Central Package Management in .NET
Manage NuGet package versions in one place using Directory.Packages.props to eliminate version drift across projects.
REST API Design Conventions That Actually Matter
Practical REST API design conventions for .NET APIs covering resource naming, HTTP methods, status codes, and common pitfalls.
dotnet-tools and Local Tool Manifests
Use local tool manifests to version and share .NET CLI tools across your team without global installs.
Building GraphQL APIs with Hot Chocolate in .NET
A hands-on guide to building a GraphQL API in ASP.NET Core using Hot Chocolate's annotation-based and code-first approaches.
PeriodicTimer for Clean Background Work in .NET
Replace Task.Delay loops with PeriodicTimer for reliable, cancellable periodic background work in .NET hosted services.
Building a NuGet Package Publishing Pipeline
Automate NuGet package building, versioning, and publishing with GitHub Actions and best practices for package metadata.
Docker Compose for Local .NET Development
Set up a Docker Compose environment for .NET development with databases, caches, and hot reload.
ThreadPool Tuning in .NET: What You Can (and Cannot) Control
Understand how the .NET ThreadPool manages threads, when to adjust minimum threads, and how to diagnose starvation.
gRPC-Web: Bringing gRPC to the Browser
How to expose gRPC services to browser clients using gRPC-Web middleware in ASP.NET Core.
Dockerfile Best Practices for .NET Projects
Practical Dockerfile patterns that improve build speed, image size, and security for .NET applications.
.NET Container Images Explained: Chiselled, Alpine, and More
Understand the differences between .NET's container image variants — standard, Alpine, chiselled, and AOT — and when to use each.
Getting Started with gRPC in .NET
A practical introduction to building high-performance gRPC services in .NET using Protocol Buffers and the Grpc.AspNetCore package.
Diagnosing and Preventing Deadlocks in Async .NET Code
Identify the root causes of async deadlocks in .NET, learn diagnostic techniques, and apply patterns that prevent them.
Multi-Stage Docker Builds for .NET Applications
Use multi-stage Docker builds to produce small, secure .NET container images without shipping the SDK.
GitHub Actions for .NET: A Practical CI/CD Pipeline
Build a complete CI/CD pipeline for .NET projects using GitHub Actions, from restore through to deployment.
Interlocked and Lock-Free Patterns in .NET
Use Interlocked operations for high-performance, lock-free atomic updates to shared state in concurrent .NET applications.
2025
152 postsSemaphoreSlim for Async Throttling and Rate Limiting
Use SemaphoreSlim to limit concurrent access to resources in async code, preventing overload of databases, APIs, and shared services.
Security Headers Middleware for ASP.NET Core
Building a comprehensive security headers middleware for ASP.NET Core that covers X-Content-Type-Options, X-Frame-Options, Referrer-Policy, and more.
IAsyncEnumerable and Async Streams in .NET
Stream data asynchronously with IAsyncEnumerable, reducing memory usage and enabling reactive-style processing over async data sources.
Cryptography in .NET: Hashing, Encryption, and Getting It Right
A practical guide to hashing passwords, encrypting data, and using .NET's cryptography APIs without the common pitfalls.
CancellationToken Best Practices in .NET
Learn how to properly propagate, link, and respond to CancellationTokens throughout your async .NET code.
Input Validation and Sanitisation in .NET
Practical approaches to validating and sanitising user input in .NET applications to prevent injection attacks and data corruption.
API Key Authentication Patterns in ASP.NET Core
Implementing API key authentication in ASP.NET Core using middleware, authentication handlers, and endpoint filters.
Task.WhenAll vs Task.WhenAny: Patterns for Concurrent Operations
Master Task.WhenAll and Task.WhenAny patterns for running concurrent async operations, with error handling and timeout strategies.
Role-Based vs Policy-Based Authorisation in ASP.NET Core
Comparing role-based and policy-based authorisation in ASP.NET Core, with practical examples showing when to use each approach.
Blazor Custom Elements: Using Blazor Components Outside Blazor
Registering Blazor components as web custom elements for use in non-Blazor applications.
Customising ASP.NET Core Identity: Beyond the Defaults
How to extend and customise ASP.NET Core Identity with custom user properties, stores, password policies, and token providers.
Parallel.ForEachAsync: Controlled Async Concurrency
Use Parallel.ForEachAsync to process collections concurrently with built-in degree-of-parallelism control and cancellation support.
Secrets Management in .NET: From User Secrets to Azure Key Vault
Practical patterns for managing secrets in .NET applications, covering user secrets for development and Key Vault for production.
Virtualisation in Blazor: Rendering Large Lists Efficiently
Using the Virtualize component to render thousands of items without destroying performance.
Content Security Policy Headers in ASP.NET Core
How to implement Content Security Policy headers to mitigate XSS and data injection attacks in ASP.NET Core applications.
System.Threading.Channels for Producer-Consumer Pipelines
Use System.Threading.Channels to build efficient, back-pressure-aware producer-consumer pipelines in .NET.
Error Boundaries in Blazor: Graceful Error Handling
Using ErrorBoundary components to catch and recover from runtime errors without crashing the entire application.
CSRF Protection in ASP.NET Core: How Anti-Forgery Tokens Work
Understanding cross-site request forgery attacks and how ASP.NET Core's anti-forgery system prevents them.
SynchronizationContext Demystified
Understand what SynchronizationContext is, how different .NET platforms implement it, and why it shapes async behaviour.
HTTPS and Certificate Management in .NET
Configuring HTTPS in ASP.NET Core, managing certificates for development and production, and enforcing secure connections.
QuickGrid: High-Performance Data Grids in Blazor
Using the built-in QuickGrid component for sorting, filtering, and paginating tabular data.
The ASP.NET Core Data Protection API: Encrypting Data the Right Way
How ASP.NET Core's Data Protection API handles key management, encryption, and data persistence — and how to configure it for production.
ConfigureAwait Explained: When and Why It Matters
Understand what ConfigureAwait(false) actually does, when to use it, and why library authors care about it more than application developers.
OAuth 2.0 and OpenID Connect in .NET: What You Actually Need to Know
A practical breakdown of OAuth 2.0 and OpenID Connect in ASP.NET Core, covering authorization code flow, token handling, and common integration patterns.
State Management Patterns in Blazor
Practical approaches to managing state in Blazor applications, from simple services to Fluxor.
Async/Await Under the Hood: How the Compiler Builds State Machines
Explore how the C# compiler transforms async methods into state machines, and what actually happens when you await a Task.
JWT Authentication in ASP.NET Core: A Practical Guide
How to implement JWT bearer authentication in ASP.NET Core, from token generation to validation and refresh strategies.
The Result Pattern for Error Handling in .NET
How to replace exceptions with the Result pattern in .NET for predictable, composable error handling in your domain and application layers.
Authentication and Authorisation in Blazor
Implementing authentication flows and role-based authorisation in Blazor applications.
Enhanced Navigation and Form Handling in Blazor
How Blazor's enhanced navigation intercepts link clicks for SPA-like transitions without full page reloads.
The Decorator Pattern with Dependency Injection in .NET
How to use the decorator pattern with .NET's DI container to add cross-cutting concerns like caching, logging, and retry logic without modifying existing code.
Feature Flags in .NET with Microsoft.FeatureManagement
How to implement feature flags in .NET using Microsoft.FeatureManagement for safe deployments, A/B testing, and gradual rollouts.
Blazor Sections and Streaming Rendering in .NET 8
Using SectionOutlet and streaming rendering to build responsive pages that load progressively.
The Modular Monolith in .NET: Best of Both Worlds
How to structure a modular monolith in .NET that gives you the boundaries of microservices without the operational complexity.
JavaScript Interop in Blazor: When and How to Call JS from .NET
Practical patterns for calling JavaScript from Blazor and .NET from JavaScript.
Event Sourcing Basics in .NET
An introduction to event sourcing in .NET, covering event stores, aggregate rehydration, and projections with practical code examples.
The Saga Pattern in .NET: Managing Distributed Transactions
How to use the saga pattern to coordinate multi-step business processes across services in .NET, with orchestration and choreography approaches.
Forms and Validation in Blazor
Building robust forms with built-in validation using EditForm, DataAnnotations, and custom validators.
The Outbox Pattern for Reliable Messaging in .NET
How to use the transactional outbox pattern to guarantee reliable message publishing alongside database writes in .NET.
Respawn: Fast Database Reset Between Integration Tests
Use Respawn to intelligently reset your test database between tests without the overhead of dropping and recreating it.
Cascading Values and Parameters in Blazor
How to pass data down the component tree without prop drilling using cascading values.
The Specification Pattern in .NET: Composable Query Logic
How to use the specification pattern to encapsulate, compose, and reuse query logic in .NET applications.
The Repository Pattern: When to Use It and When to Skip It
A balanced look at the repository pattern in .NET, including when it helps, when it hurts, and what alternatives exist.
Testing Async Code in .NET: Patterns and Pitfalls
Practical patterns for testing asynchronous .NET code correctly, including common mistakes that lead to false-passing tests.
Understanding the Blazor Component Lifecycle
A deep dive into Blazor's component lifecycle methods and when each one fires.
Domain-Driven Design Value Objects in C#
How to implement value objects in C# to encode domain rules, eliminate primitive obsession, and make invalid states unrepresentable.
CQRS with MediatR in .NET: Separating Reads from Writes
A hands-on guide to implementing the CQRS pattern in .NET using MediatR, with pipeline behaviours for cross-cutting concerns.
Mutation Testing with Stryker.NET: Are Your Tests Actually Good?
Use Stryker.NET to evaluate the real effectiveness of your test suite by introducing deliberate mutations to your code.
Vertical Slice Architecture: Organising by Feature, Not Layer
How vertical slice architecture groups code by feature rather than technical layer, and why it can reduce coupling in .NET applications.
Blazor Server vs WebAssembly vs Auto: Choosing the Right Render Mode
A practical comparison of Blazor's three render modes and when to use each one.
Clean Architecture in .NET: Structuring Projects That Last
A practical guide to implementing Clean Architecture in .NET, with project structure, dependency rules, and real code examples.
Architecture Testing in .NET with NetArchTest
Enforce architectural rules as automated tests using NetArchTest to prevent dependency violations and structural drift.
Application Insights and OpenTelemetry in .NET
How to instrument .NET applications with OpenTelemetry and export telemetry to Application Insights for end-to-end observability.
End-to-End UI Testing with Playwright for .NET
Use Playwright's .NET bindings to write reliable, cross-browser end-to-end tests for your web applications.
Bicep for .NET Developers: Infrastructure as Code Without the YAML
A practical introduction to Azure Bicep for .NET developers who want to define their infrastructure alongside their application code.
Generating Realistic Test Data with Bogus in .NET
Use the Bogus library to generate realistic fake data for your .NET tests with deterministic, locale-aware data generation.
Test Data Builders in .NET: Clean, Maintainable Test Setup
The test data builder pattern helps you construct complex test objects with sensible defaults while keeping tests readable and maintainable.
Azure Event Grid with .NET: Event-Driven Architecture Made Simple
How to publish and subscribe to events using Azure Event Grid in .NET applications for loosely coupled, event-driven architectures.
Cosmos DB with the .NET SDK: Practical Patterns
How to work effectively with Azure Cosmos DB using the .NET SDK, covering client setup, CRUD operations, partitioning, and query patterns.
FluentAssertions Patterns for Clearer .NET Tests
Practical patterns for using FluentAssertions to write expressive, self-documenting test assertions in .NET.
Azure SignalR Service: Real-Time .NET Without the Infrastructure
How to offload SignalR connection management to Azure SignalR Service for scalable real-time .NET applications.
Azure Container Apps for .NET Developers
How to deploy and scale .NET applications on Azure Container Apps with Dapr integration, scaling rules, and managed ingress.
Snapshot Testing in .NET with Verify
Use the Verify library to catch unintended changes in your API responses, serialised objects, and complex outputs through snapshot testing.
Sealed Classes and Devirtualisation in .NET
How marking classes as sealed enables the JIT to devirtualise method calls, eliminating virtual dispatch overhead.
Managed Identity for .NET Apps: Eliminating Secrets
How to use Azure Managed Identity to authenticate .NET applications to Azure services without storing credentials.
Azure Static Web Apps with a .NET API Backend
How to pair a static frontend with an Azure Functions-based .NET API using Azure Static Web Apps.
Moq vs NSubstitute: .NET Mocking Libraries Compared
A head-to-head comparison of Moq and NSubstitute covering syntax, features, and which to choose for your .NET tests.
Profile-Guided Optimisation (PGO) in .NET
How dynamic and static PGO let the JIT compiler make smarter optimisation decisions based on real runtime behaviour.
Azure App Configuration for .NET: Centralised Settings and Feature Flags
How to centralise application settings and feature flags using Azure App Configuration with the .NET configuration system.
Testcontainers for .NET: Real Database Integration Tests
Use Testcontainers to spin up real database instances in Docker for integration tests that mirror production behaviour.
Azure Key Vault as a Configuration Provider in .NET
How to use Azure Key Vault as a configuration source in .NET applications, replacing hardcoded secrets with secure, centralised management.
ValueTask vs Task: When to Use Which
Understand when ValueTask<T> offers genuine performance benefits over Task<T> and when it introduces unnecessary risk.
Azure Service Bus with .NET: Queues, Topics, and Reliable Messaging
How to send and receive messages with Azure Service Bus using the Azure.Messaging.ServiceBus SDK in .NET applications.
Integration Testing ASP.NET Core with WebApplicationFactory
How to use WebApplicationFactory to write fast, reliable integration tests for your ASP.NET Core APIs without deploying anything.
Azure Blob Storage Patterns for .NET Applications
Practical patterns for uploading, downloading, and managing blobs in .NET using the Azure.Storage.Blobs SDK.
SIMD and Vector<T> in .NET
Leverage hardware SIMD instructions through Vector<T> and Vector128/256 to process data in parallel on a single core.
Azure Functions Isolated Worker Model: The Modern Approach
How to build Azure Functions using the isolated worker model for full control over dependencies, middleware, and startup configuration.
xUnit vs NUnit vs MSTest: Choosing Your .NET Test Framework
A practical comparison of the three major .NET test frameworks to help you pick the right one for your project.
Struct Layout and Padding in .NET
Understand how the CLR lays out struct fields in memory and how padding affects performance and memory usage.
Connection Resiliency in EF Core: Surviving Transient Failures
How to configure EF Core's retry logic for transient database failures, including execution strategies, manual retries, and transaction handling.
GC Generations and the Large Object Heap Explained
How .NET's generational garbage collector works, and why the Large Object Heap deserves special attention.
EF Core Migrations Best Practices: From Development to Production
Practical strategies for managing EF Core migrations across teams, environments, and production deployments without losing data.
GC Workstation vs Server Mode in .NET
Understand the difference between workstation and server garbage collection modes and when to use each.
JSON Columns in EF Core: Storing Complex Objects as JSON
How to map complex .NET objects to JSON columns in EF Core 7+, enabling flexible schemas while keeping LINQ query support.
Temporal Tables in EF Core: Querying Data Through Time
How to configure and query SQL Server temporal tables in EF Core 6+ for point-in-time queries, audit trails, and historical data analysis.
string.Create and String Performance in .NET
Build strings without intermediate allocations using string.Create and other low-allocation string techniques.
Bulk Operations in EF Core: ExecuteUpdate, ExecuteDelete, and Beyond
How to perform efficient bulk updates and deletes in EF Core 7+ using ExecuteUpdate and ExecuteDelete, bypassing the change tracker.
EF Core Interceptors and Diagnostics: Hooking Into the Pipeline
How to use EF Core interceptors to modify commands, add logging, implement audit trails, and diagnose query performance issues.
Frozen Collections in .NET 8
FrozenDictionary and FrozenSet trade construction time for dramatically faster lookups in read-heavy scenarios.
Raw SQL in EF Core: FromSqlInterpolated and Beyond
When and how to use raw SQL in EF Core with FromSqlInterpolated, FromSqlRaw, and SqlQuery, while staying safe from SQL injection.
Response Caching vs Output Caching in ASP.NET Core
Understand the differences between response caching and output caching in ASP.NET Core, when to use each, and how to configure cache policies and invalidation.
A Practical Guide to BenchmarkDotNet
Set up and run reliable micro-benchmarks in .NET using BenchmarkDotNet, the standard tool for performance measurement.
TPH vs TPT: Choosing an Inheritance Strategy in EF Core
A practical comparison of table-per-hierarchy and table-per-type inheritance mapping strategies in EF Core, with performance considerations.
Owned Entities vs Value Objects: Modelling DDD Concepts in EF Core
How to map domain-driven design value objects using EF Core's owned entity types, including single-table and table-splitting approaches.
Authorisation Policies and Requirements in ASP.NET Core
Build fine-grained authorisation using policies, requirements, and handlers in ASP.NET Core for claims-based, resource-based, and role-based access control.
stackalloc and Stack Allocation in C#
Allocate small buffers on the stack with stackalloc to avoid heap allocations entirely.
Shadow Properties in EF Core: Database Columns Without CLR Properties
How to use EF Core shadow properties to add database columns that don't appear on your entity classes, keeping your domain model clean.
Global Query Filters: Automatic WHERE Clauses in EF Core
How to use EF Core's global query filters for soft deletes, multi-tenancy, and other cross-cutting data filtering concerns.
Custom Authentication Handlers in ASP.NET Core
Build custom authentication handlers in ASP.NET Core for API key, HMAC, and token-based authentication schemes.
ArrayPool<T> and Memory Pooling in .NET
Use ArrayPool<T> and MemoryPool<T> to rent and return buffers, drastically cutting array allocations in high-throughput code.
Query Splitting: Taming the Cartesian Explosion in EF Core
How EF Core's split queries prevent cartesian explosion when loading multiple related collections, and when to use them.
OpenAPI and Swagger Generation in ASP.NET Core
Generate OpenAPI specifications from ASP.NET Core APIs using the built-in OpenAPI support and Swashbuckle, with customisation for schemas, security, and documentation.
Object Pooling with ObjectPool<T> in .NET
Reduce GC pressure and allocation overhead by reusing objects with Microsoft.Extensions.ObjectPool.
Change Tracking Deep Dive: How EF Core Knows What Changed
A deep dive into EF Core's change tracker, exploring how it detects modifications, the role of entity states, and strategies for optimising performance.
Minimal API Route Groups and Filters in ASP.NET Core
Organise minimal API endpoints with route groups and add cross-cutting behaviour with endpoint filters for validation, logging, and transformation.
Problem Details and RFC 9457 in ASP.NET Core
Use the Problem Details standard (RFC 9457) in ASP.NET Core to return consistent, machine-readable error responses from your APIs.
Custom Model Binders in ASP.NET Core
Build custom model binders in ASP.NET Core to handle non-standard parameter formats like comma-separated lists, composite keys, and smart parsing.
Content Negotiation in ASP.NET Core
How ASP.NET Core selects response formats using content negotiation, and how to add custom formatters for XML, CSV, and other media types.
API Versioning Strategies in ASP.NET Core
Implement URL, query string, header, and media type API versioning in ASP.NET Core using the Asp.Versioning packages.
Implicit Indexer Access in Object Initialisers
C# 13 allows the implicit 'from the end' index operator (^) inside object initialisers, completing index expression support.
Kestrel Configuration in ASP.NET Core
Configure Kestrel — ASP.NET Core's built-in web server — for endpoints, HTTPS, limits, and production readiness.
Polly Resilience Pipelines in ASP.NET Core
Build fault-tolerant HTTP calls using Polly v8 resilience pipelines with retry, circuit breaker, timeout, and rate limiter strategies.
Rate Limiting Middleware in ASP.NET Core
Protect your ASP.NET Core APIs from abuse using the built-in rate limiting middleware with fixed, sliding, token bucket, and concurrency limiters.
The \e Escape Sequence: First-Class Terminal Escape Codes in C#
C# 13 adds the \e escape sequence for the ESC character, making ANSI terminal formatting cleaner and less error-prone.
Typed HttpClient with HttpClientFactory in ASP.NET Core
Use IHttpClientFactory and typed clients to manage HTTP connections properly, avoiding socket exhaustion and DNS staling.
The Lock Object: A Purpose-Built Synchronisation Primitive
C# 13 introduces System.Threading.Lock, a dedicated type for the lock statement that improves performance and clarity.
Environment-Based Configuration in ASP.NET Core
Configure your ASP.NET Core application differently for Development, Staging, and Production using environment-aware settings.
Background Services with IHostedService and BackgroundService
Build long-running background tasks in ASP.NET Core using IHostedService and BackgroundService, with patterns for queued work, timed execution, and graceful shutdown.
Partial Properties: Completing the Partial Story
C# 13 extends partial members to include properties and indexers, enabling cleaner source generator patterns.
Response Compression Middleware in ASP.NET Core
Reduce bandwidth and improve load times by enabling response compression with Brotli and Gzip in ASP.NET Core.
Custom Middleware Patterns in ASP.NET Core
How to build convention-based and factory-based middleware in ASP.NET Core, including branching, short-circuiting, and testability patterns.
Output Caching in ASP.NET Core
Use ASP.NET Core's output caching middleware to cache entire responses and dramatically reduce server load.
Params Collections: Beyond Arrays with params
C# 13 extends the params keyword to work with any collection type including spans, lists, and custom collections.
Inline Arrays: Fixed-Size Buffers Without Unsafe Code
C# 12 inline arrays embed fixed-size buffers directly in structs, enabling stack-allocated collections without unsafe blocks.
Model Binding and Validation in ASP.NET Core
Learn how ASP.NET Core automatically maps request data to action parameters and validates input using data annotations.
Ref Readonly Parameters: Passing by Reference Without the Pitfalls
C# 12's ref readonly parameters offer a safe middle ground between in parameters and ref parameters for high-performance code.
Endpoint Routing in ASP.NET Core
Understand how ASP.NET Core's endpoint routing system matches requests to handlers and how to configure it effectively.
Request Pipeline Short-Circuiting in ASP.NET Core
Learn how to short-circuit the ASP.NET Core request pipeline to return early responses and improve performance.
Default Lambda Parameters: Optional Arguments in Anonymous Functions
C# 12 brings default parameter values to lambda expressions, aligning their capabilities with regular methods.
Alias Any Type: Using Directives Beyond Namespaces
C# 12 extends using aliases to support any type including tuples, arrays, pointers, and generics — not just named types.
Health Checks in ASP.NET Core
Implement health checks to monitor your ASP.NET Core application's dependencies and readiness for traffic.
Static Abstract Interface Members in C#
How static abstract interface members enable generic math, factory patterns, and type-level contracts in C# 11 and beyond.
Generic Math: Writing Numeric Algorithms That Work Across Types
C# 11's generic math interfaces let you write a single algorithm that works with int, double, decimal, and any other numeric type.
Structured Logging with ILogger in ASP.NET Core
Use ASP.NET Core's built-in ILogger abstraction effectively with structured logging, log levels, and filtering.
Raw String Literals in C# 11
How raw string literals eliminate escaping headaches for JSON, XML, SQL, regex, and any text containing special characters.
UTF-8 String Literals: Zero-Allocation Text for High-Performance Code
C# 11's UTF-8 string literals let you work with byte-based text representations without runtime encoding costs.
Configuration and the Options Pattern in ASP.NET Core
Master ASP.NET Core's layered configuration system and the Options pattern for strongly-typed settings.
Generics Constraints in C#: Writing Precise Generic Code
How generic constraints let you write flexible, reusable code while maintaining type safety and access to specific members.
Dependency Injection Lifetimes in ASP.NET Core
Learn the differences between transient, scoped, and singleton service lifetimes and when to use each one.
Required Members: Compile-Time Guarantees for Object Initialisation
How C# 11's required members enforce that callers set essential properties, closing a long-standing gap in object initialiser safety.
Using Declarations and Disposable Patterns in C#
A practical guide to resource management in C#, from using declarations to implementing IDisposable and IAsyncDisposable correctly.
The ASP.NET Core Middleware Pipeline Explained
Understand how the ASP.NET Core middleware pipeline processes requests and responses through a chain of delegates.
Collection Expressions Deep Dive: Beyond the Basics
A thorough exploration of C# 12 collection expressions, from syntax shortcuts to spread operators and performance considerations.
Ref Structs in C#: Stack-Only Types for High Performance
Understanding ref structs, the stack-only value types that power Span<T> and enable zero-allocation programming in C#.
Primary Constructors in C# 12
How primary constructors reduce boilerplate by letting classes and structs declare constructor parameters directly in the type declaration.
Switch Expressions: Concise Branching in C#
How switch expressions replace verbose switch statements with concise, expression-based branching that returns values directly.
Collection Expressions in C# 12
How C# 12 collection expressions unify collection initialisation with a concise, consistent syntax that works across arrays, lists, spans, and custom types.
String Interpolation and Performance in C#
How C# string interpolation works under the hood, and how the compiler optimises interpolated strings into high-performance code.
Value Types vs Reference Types in C#
Understanding the fundamental difference between stack-allocated value types and heap-allocated reference types, and how it affects your code's behaviour and performance.
Records vs Classes: Choosing the Right Type in C#
Understanding when to use records over classes, covering value equality, immutability, and the with-expression syntax.
Nullable Reference Types: Eliminating the Billion-Dollar Mistake
How C#'s nullable reference types help you catch null-related bugs at compile time and write more robust code.
Pattern Matching Deep Dive in C#
A comprehensive look at C# pattern matching, from type patterns to recursive and relational patterns that simplify complex conditional logic.
user@runtime:~/blog$ wc -l posts/*.md
355 posts across 2 years