What is the role of Gen 1 in the .NET GC, and what is the "mid-life crisis" problem?

1. Survival and promotion, numerically

For each generation the GC tracks survival rate = bytes surviving / bytes in the generation before the GC.

Gen 2 inflow per second ≈ allocation rate × Gen 0 survival × Gen 1 survival

Example: 500 MB/s allocation, 5% Gen 0 survival, 40% Gen 1 survival → 10 MB/s flowing into Gen 2. If those objects die minutes later, Gen 2 must be fully collected regularly just to keep up.

What to look at in a trace (dotnet-trace collect --profile gc-verbose, PerfView GCStats):

2. Why await creates mid-life objects

public async Task<int> ExportAsync(Stream output)
{
    List<Row> rows = await _db.Rows.ToListAsync();   // large
    await WriteHeaderAsync(output);                   // slow network write
    foreach (var r in rows) await WriteRowAsync(output, r);
    return rows.Count;
}

The compiler rewrites this into a state machine struct. When the method first awaits something incomplete, the state machine is boxed onto the heap and every local used after an await (rows, output) becomes a field. As long as the I/O is pending, the whole rows graph is reachable from that box. If writes take seconds, the rows are promoted to Gen 2 mid-export.

Streaming version:

public async Task<int> ExportAsync(PipeWriter output, CancellationToken ct)
{
    int count = 0;
    await foreach (Row r in _db.Rows.AsNoTracking().AsAsyncEnumerable().WithCancellation(ct))
    {
        WriteRow(output, r);            // synchronous formatting into the pipe
        if (++count % 1000 == 0)
            await output.FlushAsync(ct);
    }
    await output.FlushAsync(ct);
    return count;
}

Only the current row is alive at any time.

3. Finalisers and promotion

An object with a finaliser cannot be reclaimed in the GC that finds it dead. It is moved to the f-reachable queue, which is a root, so the object (and everything it references) survives and is promoted. Only after the finaliser thread runs it can a later GC reclaim it, often in Gen 2. That is why finalisable objects are a classic mid-life source.

4. Leak vs mid-life: telling them apart

Leak:                         Mid-life crisis:
Gen 2 after each full GC      Gen 2 after each full GC
  ^          ___/              ^   /|  /|  /|  /|
  |      ___/                  |  / | / | / | / |
  |  ___/                      | /  |/  |/  |/  |
  +--------------> time        +--------------> time
  baseline keeps rising        baseline stays flat, many full GCs

Take two gcdumps some minutes apart: in a leak the same types grow; in mid-life the types in Gen 2 change and dead objects are reclaimed.

5. Regions and DATAS

With regions (.NET 7+), Gen 1 promotion can sometimes reassign whole regions to Gen 2, and freed Gen 2 regions return to the pool more easily. DATAS (default with Server GC in .NET 9+) adapts heap count to load. Neither changes the core problem: if objects die in Gen 2, someone has to run a Gen 2 GC to reclaim them.

6. Tools that help

7. Version notes

8. Try it yourself

1. Run the code example and compare Gen 1 and Gen 2 counts for buffering vs streaming.
2. Add await Task.Delay(50) inside the buffering loop to mimic slow I/O, and watch Gen 2 counts rise further.
3. Capture a dotnet-trace of the buffering version and open it in PerfView GCStats; find Gen 1 GCs with large promoted MB.
4. Add a class with a finaliser that holds a 1 KB array, allocate a million of them, and compare Gen 2 growth with and without the finaliser.
5. Build a MemoryCache with a 30-second TTL holding 10 KB objects at 1,000 per second; watch the Gen 2 sawtooth with dotnet-counters.

Run("Buffer everything", buffer: true);
Run("Stream items", buffer: false);

static void Run(string name, bool buffer)
{
    GC.Collect(); // demo only: start from a clean state
    int g1 = GC.CollectionCount(1), g2 = GC.CollectionCount(2);

    long checksum = 0;
    for (int batch = 0; batch < 50; batch++)
    {
        if (buffer)
        {
            // Holds 200,000 rows until the batch ends: rows survive several GCs
            var rows = new List<Row>(200_000);
            for (int i = 0; i < 200_000; i++) rows.Add(new Row(i, $"Item {i}"));
            foreach (Row r in rows) checksum += r.Name.Length;
        }
        else
        {
            // Each row is used and dropped immediately: dies in Gen 0
            for (int i = 0; i < 200_000; i++) checksum += new Row(i, $"Item {i}").Name.Length;
        }
    }

    Console.WriteLine($"{name,-18} Gen 1 GCs: {GC.CollectionCount(1) - g1,4}, Gen 2 GCs: {GC.CollectionCount(2) - g2,3}, checksum {checksum}");
}

sealed record Row(int Id, string Name);