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.
SemaphoreSlim 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.
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.
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.
Blazor Custom Elements: Using Blazor Components Outside Blazor
Registering Blazor components as web custom elements for use in non-Blazor applications.
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.
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.
SynchronizationContext Demystified
Understand what SynchronizationContext is, how different .NET platforms implement it, and why it shapes async behaviour.
QuickGrid: High-Performance Data Grids in Blazor
Using the built-in QuickGrid component for sorting, filtering, and paginating tabular data.
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.
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.
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.