The LoggerMessage Source Generator: High-Performance Logging
How the LoggerMessage source generator eliminates boxing, string allocation, and reflection in .NET logging for maximum throughput.
SignalR Performance Tuning in .NET
Optimise SignalR for high-throughput scenarios with transport selection, buffer tuning, serialisation choices, and connection management strategies.
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.
The Regex Source Generator Explained
How .NET 7's GeneratedRegex attribute uses source generation to compile regular expressions at build time for better performance.
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.
MessagePack Protocol for SignalR: Faster, Smaller Messages
Switch SignalR from JSON to MessagePack for smaller payloads and faster serialisation in performance-sensitive applications.
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.
Virtualisation in Blazor: Rendering Large Lists Efficiently
Using the Virtualize component to render thousands of items without destroying performance.
QuickGrid: High-Performance Data Grids in Blazor
Using the built-in QuickGrid component for sorting, filtering, and paginating tabular data.
Enhanced Navigation and Form Handling in Blazor
How Blazor's enhanced navigation intercepts link clicks for SPA-like transitions without full page reloads.
Blazor Sections and Streaming Rendering in .NET 8
Using SectionOutlet and streaming rendering to build responsive pages that load progressively.
Sealed Classes and Devirtualisation in .NET
How marking classes as sealed enables the JIT to devirtualise method calls, eliminating virtual dispatch overhead.
Profile-Guided Optimisation (PGO) in .NET
How dynamic and static PGO let the JIT compiler make smarter optimisation decisions based on real runtime behaviour.
ValueTask vs Task: When to Use Which
Understand when ValueTask<T> offers genuine performance benefits over Task<T> and when it introduces unnecessary risk.
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.
Struct Layout and Padding in .NET
Understand how the CLR lays out struct fields in memory and how padding affects performance and memory usage.
GC Generations and the Large Object Heap Explained
How .NET's generational garbage collector works, and why the Large Object Heap deserves special attention.
GC Workstation vs Server Mode in .NET
Understand the difference between workstation and server garbage collection modes and when to use each.
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.
Frozen Collections in .NET 8
FrozenDictionary and FrozenSet trade construction time for dramatically faster lookups in read-heavy scenarios.
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.
stackalloc and Stack Allocation in C#
Allocate small buffers on the stack with stackalloc to avoid heap allocations entirely.