Memory: stack, heap and garbage collection

You never call delete in C#, yet memory is freed. This lesson explains how, because understanding memory is the key to fast, smooth software, especially in 3D and BIM tools that handle millions of objects.

Stack and heap

1void Calculate()2{3    int count = 3;                       // stack: the value 34    double[] loads = new double[count];  // stack: reference → heap: the array5    var beam = new Beam("B1");           // stack: reference → heap: the Beam object6    Point3 p = new Point3(1, 2, 3);      // struct local: stack, no heap allocation7}   // the frame is gone; the array and Beam are now unreachable garbage

How the garbage collector works

1. Mark: starting from the roots (local variables on every thread’s stack, static fields, CPU registers), follow every reference and mark each object reached.
2. Sweep / compact: everything not marked is garbage. Its memory is reclaimed, and surviving objects may be moved together to avoid gaps.
3. Promote: survivors move to an older generation.

Generations

Most objects die young: temporary strings, LINQ iterators, short-lived lists. So .NET collects generation 0 (new objects) very often and cheaply, generation 1 less often, and generation 2 (long-lived objects like your loaded model) rarely, because a gen-2 collection must examine much more memory. Objects larger than about 85 KB go straight to the Large Object Heap, collected with gen 2.

Why it matters for performance

While the GC works, your threads may pause. In a 3D viewport rendering 60 frames per second, each frame has about 16 ms; allocating lots of garbage every frame triggers frequent collections and visible stutter. Fewer allocations → fewer collections → smoother apps.

1// ✗ allocates a new list and an iterator every frame2void OnFrame()3{4    var visible = members.Where(m => m.IsVisible).ToList();5    Draw(visible);6}7 8// ✓ reuse one list; clear it instead of re-creating it9private readonly List<Member> _visible = new(capacity: 10_000);10void OnFrameFast()11{12    _visible.Clear();13    foreach (var m in members)14        if (m.IsVisible) _visible.Add(m);15    Draw(_visible);16}

Habits that reduce allocations

• Use StringBuilder instead of += in loops.
• Reuse collections in hot paths (Clear() instead of new). Give lists an initial capacity when you know the size.
• Use small structs for points and vectors stored in large arrays.
• Avoid boxing: use generic collections, not object or ArrayList.
• Use ArrayPool<T>.Shared and Span<T> (covered later) for temporary buffers.
• Measure first: Visual Studio’s Diagnostic Tools and the .NET profilers show allocations and GC pauses.

Memory leaks in a managed language

The GC frees only unreachable objects. If something still references an object you no longer need, it is never freed. Common causes: forgotten event subscriptions, static lists that only grow, caches without a size limit, and closures capturing big objects.

1private double[] _depths = Array.Empty<double>();2 3ReadOnlySpan<double> GetDepths(Member[] ms)4{5    if (_depths.Length < ms.Length)6        _depths = new double[ms.Length];        // grows rarely, then reused7 8    for (int i = 0; i < ms.Length; i++)9        _depths[i] = ms[i].Depth;10 11    return _depths.AsSpan(0, ms.Length);       // a view, no copy12}