Performance, Span, Memory, GC & Caching Masterclass

⚡ C# 12 & .NET 8 🟢 Chapter 43 of 35 📂 Phase 16: Advanced .NET 📅 2026 Edition

📌 Covered in this chapter: GC Generations · Memory Allocation · Span · Memory · Zero-Copy Processing · IMemoryCache · Cache-Aside Pattern · BenchmarkDotNet · Profiling

Welcome to Phase 16 (Chapter 43): C# Performance Optimization — Span<T>, Memory<T>, GC, Caching & Profiling Masterclass! Performance in C# comes from understanding memory allocation, avoiding unnecessary GC pressure, using stack-based structures for hot paths, caching repeated computations, optimizing async I/O, and profiling to find real bottlenecks before optimizing. In this chapter, we master all key .NET performance tools and patterns.

1Garbage Collection & Memory Allocation

.NET Garbage Collector (GC) Generations: Gen 0 ← New objects (short-lived). Collected frequently (milliseconds). └── Survivors promoted to... Gen 1 ← Medium-lived objects. Collected less often. └── Survivors promoted to... Gen 2 ← Long-lived objects (singletons, caches). Collected rarely. LOH → Large Object Heap (objects > 85KB). Rarely collected!

Key Rule: Reduce heap allocations in hot paths to avoid Gen 0 GC pauses. Use Span<T>, stackalloc, ArrayPool<T>, and struct types to keep data on the stack instead of triggering heap allocation.

2Span<T> & Memory<T> — Zero-Copy Processing

C# — Span<T> Performance ▶ Run in Compiler

// SLOW: String.Substring allocates a NEW string object on the heap every call
string original = "Hello, World!";
string sub = original.Substring(7); // Heap allocation!

// FAST: Span<T> is a view into existing memory — ZERO heap allocation
ReadOnlySpan<char> span = original.AsSpan(7); // No allocation!
Console.WriteLine(span.ToString()); // "World!"

// Span over array slice — no copy
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Span<int> middle = numbers.AsSpan(3, 4); // Elements 4,5,6,7 — no copy
foreach (int n in middle) Console.Write(n + " ");

3In-Memory Caching & Distributed Cache

C# — IMemoryCache ▶ Run in Compiler

// Program.cs — Register IMemoryCache
builder.Services.AddMemoryCache();

// Service — Cache expensive database results
public class ProductService
{
    private readonly IMemoryCache _cache;
    private readonly AppDbContext _context;

    public ProductService(IMemoryCache cache, AppDbContext context)
    {
        _cache = cache; _context = context;
    }

    public async Task<List<Product>> GetAllProductsAsync()
    {
        const string cacheKey = "products:all";

        if (!_cache.TryGetValue(cacheKey, out List<Product>? products))
        {
            // Cache MISS — hit the database
            products = await _context.Products.ToListAsync();

            // Store in cache for 5 minutes
            _cache.Set(cacheKey, products, TimeSpan.FromMinutes(5));
        }

        return products!; // Cache HIT — no DB query!
    }
}

4Technical FAQs

Q1: When should I use Span<T> vs Memory<T>?

Span<T> is a ref struct that can only live on the stack — ideal for synchronous hot-path processing (parsing, slicing). Memory<T> can live on the heap and works across async method boundaries where Span<T> cannot be stored.

Q2: What is the best profiling tool for .NET performance?

Use dotnet-trace and dotnet-counters for CLI profiling, BenchmarkDotNet for micro-benchmarks, Visual Studio Profiler for CPU/memory analysis, and Application Insights / Datadog for production performance monitoring.