High-Performance .NET: Techniques That Actually Matter

Reduce Allocations in Hot Paths#

Allocation reduction pays off twice: less time spent allocating and zeroing memory, and fewer garbage collections for the whole process, including threads that did not allocate. Focus on code that runs per request, per message or per item in a large loop. Allocations during startup do not matter.

Rent Buffers from ArrayPool Instead of Allocating Them#

Temporary buffers are the classic waste. ArrayPool<T>.Shared hands out arrays from per-core caches and takes them back when you are done:

using System.Buffers;

public static async Task<long> CountLinesAsync(Stream stream, CancellationToken ct)
{
    byte[] buffer = ArrayPool<byte>.Shared.Rent(64 * 1024);
    try
    {
        long lines = 0;
        int read;
        while ((read = await stream.ReadAsync(buffer.AsMemory(), ct)) > 0)
        {
            lines += buffer.AsSpan(0, read).Count((byte)'\n');   // vectorized in .NET 8+
        }
        return lines;
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

Three rules keep pooling safe. Rent may return a larger array than you asked for, so always track the valid length yourself. Never touch an array after returning it, because another thread may already own it. Pass clearArray: true to Return when the buffer held secrets or personal data. For small buffers of known size, stackalloc into a Span<T> avoids even the pool; the Span and Memory guide explains the safety rules.

Build Strings Without Intermediate Copies#

Strings are immutable, so every Substring, concatenation and ToUpper call allocates. Three tools remove most of that churn:

• Spans slice without copying. text.AsSpan(start, length) gives a view, and span-based parsing APIs such as int.Parse(ReadOnlySpan<char>) and the span Split methods added in .NET 8 and 9 keep it that way.
• Interpolated strings compile to DefaultInterpolatedStringHandler since C# 10, which formats value types without boxing them into a rented buffer.
• string.Create allocates the final string once and lets you write its characters in place.

public static string MaskCardNumber(string cardNumber)
{
    ArgumentOutOfRangeException.ThrowIfLessThan(cardNumber.Length, 4);

    // One allocation: the result string. The static lambda cannot capture state by accident.
    return string.Create(cardNumber.Length, cardNumber, static (span, source) =>
    {
        span.Fill('*');
        source.AsSpan(source.Length - 4).CopyTo(span[^4..]);
    });
}

Pool Expensive Objects with ObjectPool#

For objects that are costly to construct, Microsoft.Extensions.ObjectPool provides a thread-safe pool; ASP.NET Core uses it internally to reuse StringBuilder instances. Types that implement IResettable (.NET 8 and later) clean themselves up when they return to the pool:

using System.Text;
using Microsoft.Extensions.ObjectPool;

// Program.cs registrations
builder.Services.AddSingleton<ObjectPoolProvider, DefaultObjectPoolProvider>();
builder.Services.AddSingleton(sp =>
    sp.GetRequiredService<ObjectPoolProvider>().CreateStringBuilderPool());
builder.Services.AddSingleton(sp =>
    sp.GetRequiredService<ObjectPoolProvider>().Create<ReportBuffer>());

public sealed class ReportBuffer : IResettable
{
    public List<decimal> Totals { get; } = new(capacity: 1_024);

    public bool TryReset()
    {
        Totals.Clear();   // keep the capacity, drop the contents
        return true;      // returning false tells the pool to discard this instance
    }
}

public sealed class ReportRenderer(ObjectPool<StringBuilder> builders)
{
    public string Render(IEnumerable<(string Sku, int Quantity)> lines)
    {
        StringBuilder sb = builders.Get();
        try
        {
            foreach (var (sku, quantity) in lines)
            {
                sb.Append(sku).Append(';').Append(quantity).AppendLine();
            }
            return sb.ToString();
        }
        finally
        {
            builders.Return(sb);
        }
    }
}

Pooling is not automatically a win. Getting an object from a pool costs more than allocating a small, cheap object, and pooled objects live until the pool dies, which pushes them into gen2. Note also that the default pool limits how many objects it retains, not how many it creates. Pool when construction is expensive or the object holds a large buffer, and prove the benefit with a benchmark.

Avoid Boxing and Hidden Closures#

Two allocation sources hide in innocent-looking code. Boxing happens when a value type is converted to object or to an interface: passing a struct through an IComparable parameter, calling a params object[] API, or storing value types in non-generic collections. Closures happen when a lambda captures a local variable, a parameter or this: the compiler allocates an object to hold the captured state, plus a new delegate each time the lambda expression is evaluated.

// Captures tenantId: allocates a closure and a delegate on every call, even on cache hits
decimal price = _prices.GetOrAdd(sku, key => LoadPrice(key, tenantId));

// Passes state explicitly; 'static' turns an accidental capture into a compile error
decimal cached = _prices.GetOrAdd(
    sku, static (key, tenant) => LoadPrice(key, tenant), tenantId);

// Struct keys: the default ValueType.Equals can box and fall back to reflection.
// A record struct generates IEquatable<T>, so dictionary lookups stay allocation-free.
public readonly record struct PriceKey(int TenantId, string Sku);

Other common traps are logging calls that box their arguments (the [LoggerMessage] source generator avoids this), string.Format with value types, and interface-typed parameters where a generic constraint such as where T : IComparable<T> would let the JIT generate specialized, non-boxing code for each value type. .NET 10's escape analysis can stack-allocate some delegates and closures that never leave their method, but treat that as a bonus rather than a design strategy: it only applies when the JIT can prove the delegate does not escape, which excludes anything stored in a field or passed to a method that is not inlined.