Garbage Collection in .NET

The managed heap maintains a pointer to the address where the next object in the heap will be allocated. Initially, this pointer is set to the managed heap’s base address.

All reference types are allocated on the managed heap.

When the garbage collector performs a collection, it releases the memory for objects that are no longer being used by the application by examining the application’s roots.

The garbage collector examines the managed heap, and uses a memory-copying function to compact the reachable objects in memory, freeing up the blocks of address spaces allocated to unreachable objects.

To improve performance, the runtime allocates memory for large objects in a separate heap, the large object heap (LOH).

It’s faster to compact the memory for a portion of the managed heap than for the entire managed heap.

Newer objects have shorter lifetimes, and older objects have longer lifetimes.

Newer objects tend to be related to each other and accessed by the application around the same time.

The garbage collector stores new objects in generation 0.

Objects created early in the application’s lifetime that survive collections are promoted and stored in generations 1 and 2.

However, if they’re large objects, they go on the large object heap (LOH), which is sometimes referred to as generation 3.

Most objects are reclaimed for garbage collection in generation 0 and don’t survive to the next generation.

After the garbage collector performs a collection of generation 0, it compacts the memory for the reachable objects and promotes them to generation 1.

If a collection of generation 0 doesn’t reclaim enough memory for the application to create a new object, the garbage collector can perform a collection of generation 1 and then generation 2.

Objects in generation 2 that survive a collection remain in generation 2 until they’re determined to be unreachable in a future collection.

Objects on the large object heap (which is sometimes referred to as generation 3) are also collected in generation 2.

A generation 2 garbage collection is also known as a full garbage collection because it reclaims objects in all generations (that is, all objects in the managed heap).

Objects that survive a generation 0 garbage collection are promoted to generation 1.

Objects that survive a generation 1 garbage collection are promoted to generation 2.

Objects that survive a generation 2 garbage collection remain in generation 2.

For unmanaged resources, they requires to be explicitly cleanup.

The most common type of unmanaged resource is an object that wraps an operating system resource, such as a file handle, window handle, network connection, or database connections.

While often used to cascade dispose calls for IDisposable members to release unmanaged resources, it can also be used for other cleanup tasks, for example, to free memory that was allocated, remove an item that was added to a collection, or signal the release of a lock that was acquired.

The .NET garbage collector doesn’t handle unmanaged memory, so the dispose pattern is crucial for managing these resources that implement the IDisposable interface.

A well-written Dispose method should be idempotent (callable multiple times without errors), with subsequent calls doing nothing.

string filePath = "example.txt";
string textToWrite = "Hello, this is a test message!";

// Use the using statement to ensure the StreamWriter is properly disposed of
using (StreamWriter writer = new StreamWriter(filePath))
{
    writer.WriteLine(textToWrite);
}

To enable the deterministic release of unmanaged resources, provide an IDisposable.Dispose dispose pattern implementation.

public void Dispose()
{
    // Dispose of unmanaged resources.
    Dispose(true);
    // Suppress finalization.
    GC.SuppressFinalize(this);
}

// Any non-sealed class should have an Dispose(bool) overload method.
// If the method call comes from a finalizer, only the code that frees
// unmanaged resources should execute.
protected virtual void Dispose(bool disposing)
{
    if (_disposed)
    {
        return;
    }

    if (disposing)
    {
        // TODO: dispose managed state (managed objects).
    }

    // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
    // TODO: set large fields to null.

    _disposed = true;
}

~Disposable() => Dispose(false); // finalizer

protected virtual void Dispose(bool disposing)
{
    if (_disposed) return;

    if (disposing) // Deterministic call (from IDisposable.Dispose or using)
    {
        // Dispose managed resources:
        if (_managedResource != null)
        {
            _managedResource.Dispose(); // Safe to access managed objects
            _managedResource = null;
        }
    }

    // Free unmanaged resources:
    if (_unmanagedResource != IntPtr.Zero)
    {
        CloseHandle(_unmanagedResource); // Always release unmanaged resources
        _unmanagedResource = IntPtr.Zero;
    }

    _disposed = true;
}

~Disposable() => Dispose(false); // Non-deterministic call (from finalizer)

To enable the non-deterministic release of unmanaged resources when the consumer of a type fails to call IDisposable.Dispose.

Workstation garbage collection (GC), which is designed for client apps.

Server garbage collection, which is intended for server applications that need high throughput and scalability.