How does the .NET managed heap allocate objects? Explain allocation contexts, generations, the large object heap and the pinned object heap.

1. Allocation and a gen 0 GC, drawn

gen 0 region
[ T1 context: obj obj obj | free ]  [ T2 context: obj obj | free ]  [ unused ... ]
                     ^ alloc pointer (bump)

budget exhausted -> gen 0 GC:
  1. suspend managed threads (at safe points)
  2. mark from roots: stacks, registers, statics, handles, card table (old -> young refs)
  3. compact or promote survivors into gen 1
  4. update references, resume threads
  gen 0 is empty again -> fast bump allocation continues

2. Why generational GC is cheap

Cost of a collection is roughly proportional to surviving objects, not garbage. If 95% of gen 0 objects are dead, a gen 0 GC copies 5% and is done in well under a millisecond for typical heaps. Problems start when objects live just long enough to be promoted (for example request-scoped objects held across a slow await), which is called a mid-life crisis: they're expensive to promote and then die in gen 2.

3. LOH threshold details

• The threshold is 85,000 bytes of object size, including the header. A byte[] of 84,976 bytes or more crosses it on 64-bit.
• A double[] of 1,000 elements is 8 KB (small object heap); of 10,700 elements it's on the LOH.
• string of about 42,500 characters is on the LOH (2 bytes per char).

4. Measuring allocations

5. Allocation-reduction toolbox

6. GC modes in one table

7. Try it yourself

1. Run a benchmark that allocates new byte[80_000] versus new byte[90_000] in a loop with [MemoryDiagnoser] and compare gen 2 counts.
2. Replace the 90,000-byte allocation with ArrayPool<byte>.Shared.Rent and Return, and compare again.
3. Watch dotnet-counters for an ASP.NET Core endpoint that reads a 500 KB response as a string, then change it to deserialise from the stream.
4. Use GC.GetGeneration(obj) before and after GC.Collect() calls in a small test to see promotion.

namespace ManagedHeap;

using System.Buffers;
using System.Net.Http.Json;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
public class LohBenchmarks
{
    [Benchmark(Baseline = true)]
    public int SmallObjectHeap() => new byte[80_000].Length;      // below the 85,000-byte threshold

    [Benchmark]
    public int LargeObjectHeap() => new byte[90_000].Length;      // LOH: collected with gen 2

    [Benchmark]
    public int Pooled()
    {
        byte[] buffer = ArrayPool<byte>.Shared.Rent(90_000);        // reused, no new allocation
        try { return buffer.Length; }
        finally { ArrayPool<byte>.Shared.Return(buffer); }
    }
}

public static class Program
{
    public static void Main()
    {
        var order = new object();
        Console.WriteLine(GC.GetGeneration(order));   // 0
        GC.Collect();
        Console.WriteLine(GC.GetGeneration(order));   // 1 (promoted)
        GC.Collect();
        Console.WriteLine(GC.GetGeneration(order));   // 2
        GC.KeepAlive(order);

        var pinned = GC.AllocateArray<byte>(64 * 1024, pinned: true);   // pinned object heap
        Console.WriteLine(GC.GetGeneration(pinned));

        BenchmarkRunner.Run<LohBenchmarks>();
    }
}

public sealed record Report(string Id, decimal Total);

public sealed class ReportClient(HttpClient http)
{
    // Deserialise from the stream instead of building a large string first.
    public Task<Report?> GetAsync(string id, CancellationToken ct) =>
        http.GetFromJsonAsync<Report>($"reports/{id}", ct);
}