Dotnet Perf

This:

ReadOnlySpan<char> input = "2026-03-01T14:30:00";
ReadOnlySpan<char> datePart = input[..10];   // slice, no allocation
ReadOnlySpan<char> timePart = input[11..];   // slice, no allocation
int year = int.Parse(input[..4]);            // parse directly from span

Key rules:

• Span<T> is stack-only (ref struct) — cannot live on the heap, no async
• Memory<T> is the heap-safe sibling — use across async boundaries
• ReadOnlySpan<T> for safe reads — prevents accidental mutation

// Memory<T> for async scenarios
async Task ProcessAsync(Memory<byte> buffer)
{
    int bytesRead = await stream.ReadAsync(buffer);
    Process(buffer.Span[..bytesRead]);
}

2. ArrayPool<T> and MemoryPool<T> — Rent, Don't Allocate

Not this:

byte[] buffer = new byte[4096];  // GC pressure in loops
int read = stream.Read(buffer);

This:

byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
try
{
    int read = stream.Read(buffer.AsSpan(0, 4096));
    ProcessData(buffer.AsSpan(0, read));
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer);  // ALWAYS return
}

Critical rules:

• Rented arrays may be larger than requested — always track actual length
• Always return in a finally block — leaked rentals defeat the purpose
• clearArray: true on Return if buffer held sensitive data

// MemoryPool<T> for IMemoryOwner with automatic disposal
using IMemoryOwner<byte> owner = MemoryPool<byte>.Shared.Rent(4096);
await stream.ReadAsync(owner.Memory[..4096]);

3. ObjectPool<T> — Pool Expensive Objects

Not this:

string FormatReport(IEnumerable<Item> items)
{
    var sb = new StringBuilder();  // new allocation every call
    foreach (var item in items)
        sb.AppendLine($"{item.Name}: {item.Value}");
    return sb.ToString();
}

This:

private static readonly ObjectPool<StringBuilder> _sbPool =
    new DefaultObjectPoolProvider().CreateStringBuilderPool();

string FormatReport(IEnumerable<Item> items)
{
    var sb = _sbPool.Get();
    try
    {
        foreach (var item in items)
            sb.AppendLine($"{item.Name}: {item.Value}");
        return sb.ToString();
    }
    finally
    {
        _sbPool.Return(sb);  // cleared and returned to pool
    }
}

ASP.NET DI: register DefaultObjectPoolProvider as singleton, then provider.Create(new StringBuilderPooledObjectPolicy()).

4. ref structs and stackalloc — Stay on the Stack

Not this:

byte[] temp = new byte[128];  // heap allocation for tiny buffer
Encoding.UTF8.GetBytes(input, temp);

This:

Span<byte> temp = stackalloc byte[128];
int written = Encoding.UTF8.GetBytes(input, temp);
ReadOnlySpan<byte> result = temp[..written];

Safety pattern — fall back to pool for large inputs:

int maxBytes = Encoding.UTF8.GetMaxByteCount(input.Length);
byte[]? rented = null;
Span<byte> buffer = maxBytes <= 256
    ? stackalloc byte[256]
    : (rented = ArrayPool<byte>.Shared.Rent(maxBytes));
try
{
    int written = Encoding.UTF8.GetBytes(input, buffer);
    Process(buffer[..written]);
}
finally
{
    if (rented is not null)
        ArrayPool<byte>.Shared.Return(rented);
}

ref struct constraints: Cannot be boxed, captured in closures, used in async, or stored as fields in classes.

5. String Performance — Death by a Thousand Allocations

Not this:

string result = "";
foreach (var item in items)
    result += item.Name + ", ";  // O(n^2) allocations

This:

string result = string.Join(", ", items.Select(i => i.Name));

// string.Create for pre-sized zero-intermediate-allocation formatting
string header = string.Create(37, guid, (span, g) =>
{
    "REQUEST-".AsSpan().CopyTo(span);
    g.TryFormat(span[8..], out _, "N");
});

Comparison traps:

// NOT THIS — culture-sensitive, slow, allocates
if (input.ToLower() == "admin") { }

// THIS — ordinal is 5-10x faster
if (input.Equals("admin", StringComparison.OrdinalIgnoreCase)) { }

Frozen collections for read-only lookups (.NET 8):

private static readonly FrozenDictionary<string, Handler> Handlers =
    new Dictionary<string, Handler>(StringComparer.OrdinalIgnoreCase)
    {
        ["GET"] = handleGet, ["POST"] = handlePost, ["PUT"] = handlePut,
    }.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);

6. Allocation Awareness — Know Where Bytes Come From

Boxing traps:

// NOT THIS — boxing int to object
void Log(object value) => Console.WriteLine(value);
Log(42);  // boxes int to heap

// THIS — generic avoids boxing
void Log<T>(T value) => Console.WriteLine(value);
Log(42);  // no boxing

Closure allocations: Lambdas that capture local variables allocate a closure object. In hot paths, use static lambdas with explicit state parameters to avoid the allocation.

params ReadOnlySpan<T> (C# 13):

// NOT THIS — params allocates an array every call
void Log(params string[] messages) { }

// THIS — zero heap allocation
void Log(params ReadOnlySpan<string> messages) { }

Struct vs class quick rule:

• Struct when: small (<= 16 bytes), immutable, frequently allocated, no boxing
• Class when: large, mutable, needs inheritance, shared references

7. BenchmarkDotNet — Trust Numbers, Not Instincts

[MemoryDiagnoser]  // Track allocations — the most important diagnoser
[SimpleJob(RuntimeMoniker.Net80)]
public class ParsingBenchmarks
{
    private string _input = "12345";

    [Benchmark(Baseline = true)]
    public int IntParse() => int.Parse(_input);

    [Benchmark]
    public int SpanParse() => int.Parse(_input.AsSpan());

    [Params(10, 100, 1000)]
    public int ItemCount { get; set; }

    [Benchmark]
    public string Concat()
    {
        string r = "";
        for (int i = 0; i < ItemCount; i++) r += i.ToString();
        return r;
    }

    [Benchmark]
    public string Builder()
    {
        var sb = new StringBuilder();
        for (int i = 0; i < ItemCount; i++) sb.Append(i);
        return sb.ToString();
    }
}

Reading results: Mean (avg time), Allocated (bytes/op, target 0 B), Gen0/Gen1/Gen2 (GC collections, Gen2 = bad). Always Release mode. Always [MemoryDiagnoser]. Run: dotnet run -c Release -- --filter '*Benchmarks*'

8. IMemoryCache — Cache Smart, Not Hard

Not this:

// Cache stampede — 100 concurrent misses all fetch
if (!_cache.TryGetValue(key, out Data data))
{
    data = await _db.FetchAsync(key);
    _cache.Set(key, data, TimeSpan.FromMinutes(5));
}

This:

private static readonly SemaphoreSlim _lock = new(1, 1);

public async Task<Data> GetDataAsync(string key)
{
    if (_cache.TryGetValue(key, out Data data))
        return data;

    await _lock.WaitAsync();
    try
    {
        if (_cache.TryGetValue(key, out data))  // double-check after lock
            return data;

        data = await _db.FetchAsync(key);
        _cache.Set(key, data, new MemoryCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5),
            SlidingExpiration = TimeSpan.FromMinutes(1),
            Size = 1
        });
        return data;
    }
    finally { _lock.Release(); }
}

9. Value Types Done Right

Structs help when:

public readonly record struct Color(byte R, byte G, byte B, byte A);  // 4 bytes
public readonly record struct Vector2(float X, float Y);              // 8 bytes

// Arrays: contiguous memory, no object headers, cache-friendly
Vector2[] positions = new Vector2[10_000];  // 80 KB contiguous
// Class equivalent: 240 KB scattered across heap

Structs hurt when:

// TOO LARGE — 40 bytes copied on every pass-by-value
public struct LargeStruct { decimal Price; decimal Quantity; DateTime Ts; }

// MUTABLE — modifies a copy, original unchanged
public struct MutablePoint { public int X, Y; }
var list = new List<MutablePoint> { new() { X = 1 } };
list[0].X = 5;  // ERROR: modifies a copy

// BOXED — defeats the purpose
IComparable c = new MyStruct();  // heap allocation

The struct checklist: <= 16 bytes? Immutable? No boxing? Frequently allocated? If any "no," use a class.

Anti-Patterns

Decision Framework

Need temporary buffer?
├── Small + sync → stackalloc + Span<T>
├── Variable size → ArrayPool<T>.Rent/Return
└── Async boundary → MemoryPool<T> + Memory<T>

Need string work?
├── Parsing/slicing → ReadOnlySpan<char>
├── Building output → StringBuilder (pooled) or string.Create
└── Comparing → StringComparison.Ordinal[IgnoreCase]

Need object reuse?
├── Arrays → ArrayPool<T>
├── StringBuilder → ObjectPool<StringBuilder>
└── Custom expensive objects → ObjectPool<T>

Struct or class?
├── <= 16 bytes + immutable + no boxing → readonly record struct
├── Large or mutable or inherited → class
└── Unsure → class (safer default)

Code Review Checklist

• No unnecessary allocations in hot paths? (new, concat, closures)
• ArrayPool for temporary buffers with try/finally Return?
• Span<T> for slicing instead of Substring/Array.Copy?
• stackalloc for small fixed buffers with pool fallback?
• String comparisons use Ordinal, not ToLower?
• Structs are readonly and <= 16 bytes?
• BenchmarkDotNet with [MemoryDiagnoser] validates claims?
• Cache has stampede protection (double-check + lock)?
• FrozenDictionary/FrozenSet for static lookups?
• No boxing in hot paths (generics over object)?

Source Material

• Sitnik, BenchmarkDotNet creator, "High-Performance .NET" talks
• Adams, ASP.NET Core / Kestrel performance contributions
• Watson, "Writing High-Performance .NET Code" (2nd Edition)
• .NET performance documentation (docs.microsoft.com)

"If you haven't measured it, you haven't optimized it — you've just guessed." — Adam Sitnik