What happens during a Gen 0 allocation and collection in .NET, and how do you reduce Gen 0 GC frequency?

1. Allocation contexts in memory

Thread A context          Thread B context          unused Gen 0 budget
+--------------------+    +--------------------+    +----------------------+
|obj|obj|  free     |    |obj| free           |    |                      |
+--------------------+    +--------------------+    +----------------------+
        ^ptr      ^limit       ^ptr       ^limit

• Each thread bumps its own pointer, so there is no contention on the fast path.
• With Server GC, each heap has its own Gen 0 and threads are affinitised to heaps; the allocator balances across heaps when one becomes busy.
• Before handing out a context, the GC zeroes the memory. That is why new T() fields start at default without per-object work.

2. From C# to the allocation helper

var o = new Order(42);

IL:

ldc.i4.s   42
newobj     instance void Order::.ctor(int32)
stloc.0

The JIT turns newobj into a call to an allocation helper chosen per type (for example a fast helper for small, non-finalisable objects) followed by the constructor call. Types with finalisers use a slower helper because the object must also be registered on the finalisation queue, which is one reason finalisers make allocation more expensive.

The JIT can also eliminate allocations: since .NET 9/10 it performs limited object stack allocation (escape analysis) for some small objects that provably do not escape a method, and boxing in some patterns is removed. Do not design around it, but it explains why micro-benchmarks sometimes show zero bytes where you expected an allocation.

3. Hidden allocations in ordinary C#

4. The Gen 0 budget and promotion rate

The GC tracks survival rate per generation. If Gen 0 survival is high, collections are expensive and the GC may grow the budget; if low, collections are cheap and frequent.

What matters for you:

objects promoted per second ≈ allocation rate × Gen 0 survival rate

Cut either and Gen 1/Gen 2 work drops. Allocation rate is the one you can usually control directly.

5. Pinning in Gen 0

If a Gen 0 object is pinned (fixed, a pinned GCHandle, an in-flight native I/O buffer) during a GC, the GC cannot move it. It may leave it in place (sometimes demoting it so it stays in Gen 0), which fragments Gen 0 and makes allocation contexts smaller. Long-lived pins of fresh buffers in hot paths are a classic cause of Gen 0 fragmentation; use the POH or pooled buffers instead.

6. GC.AllocateUninitializedArray and [SkipLocalsInit]

• GC.AllocateUninitializedArray<T>(n) can skip zeroing (worthwhile for large arrays you fully overwrite).
• [SkipLocalsInit] only affects stack memory (stackalloc, locals); it does nothing for heap allocations.

7. Measuring allocations precisely

[MemoryDiagnoser]
public class ParseBench
{
    private const string Line = "2026-10-23,orders,42,19.95";

    [Benchmark(Baseline = true)]
    public int Split() => int.Parse(Line.Split(',')[2]);

    [Benchmark]
    public int Span()
    {
        ReadOnlySpan<char> s = Line;
        Span<Range> r = stackalloc Range[4];
        s.Split(r, ',');
        return int.Parse(s[r[2]]);
    }
}

The Allocated column is deterministic and much more stable than timing, which makes it a good regression test.

8. Version notes

9. Try it yourself

1. Run the code example; record bytes/op and Gen 0 GCs for both parsers.
2. Put the two parsers into BenchmarkDotNet with [MemoryDiagnoser] and compare Allocated and Gen0 columns.
3. Add a foreach over a List<int> cast to IEnumerable<int> in a loop and measure the enumerator boxing.
4. Run a small web API under load and watch dotnet-counters allocation rate; then add a ToList() in the hot path and watch it rise.
5. Capture dotnet-trace collect --profile gc-verbose, open it in PerfView, and use the "GC Heap Alloc Ignore Free" view to find top allocating stacks.
6. Compare GC.CollectionCount(0) for the same workload under Workstation and Server GC (<ServerGarbageCollector>).

const string line = "2026-10-23,orders,42,19.95";

Measure("Split + parse", () =>
{
    string[] parts = line.Split(',');          // allocates an array and four strings
    return int.Parse(parts[2]);
});

Measure("Span parse", () =>
{
    ReadOnlySpan<char> span = line;
    Span<Range> ranges = stackalloc Range[4];
    span.Split(ranges, ',');                   // no heap allocation
    return int.Parse(span[ranges[2]]);
});

static void Measure(string name, Func<int> parse)
{
    parse(); // warm up
    int gen0 = GC.CollectionCount(0);
    long before = GC.GetAllocatedBytesForCurrentThread();

    long sum = 0;
    for (int i = 0; i < 1_000_000; i++) sum += parse();

    long bytes = GC.GetAllocatedBytesForCurrentThread() - before;
    Console.WriteLine($"{name,-14} allocated {bytes / 1_000_000.0:N1} bytes/op, Gen 0 GCs: {GC.CollectionCount(0) - gen0}, sum {sum}");
}