.NET Core Concepts

How Garbage Collection Works

The .NET Core GC operates based on a generational garbage collector. This means that objects are grouped into generations based on their age. New objects are allocated in the youngest generation (Generation 0). If an object survives a GC cycle, it is promoted to the next generation (Generation 1), and so on. The GC typically starts by collecting Generation 0, as it contains the most recently allocated objects, which are more likely to be garbage.

• Allocation: Objects are allocated on the managed heap.
• Marking: The GC identifies all objects that are still reachable by the application (i.e., those that are being used). This is done by starting from root objects (like static fields, threads' stack variables) and traversing the object graph.
• Sweeping/Compacting: Unreachable objects (considered garbage) are reclaimed. The GC may also compact the memory to reduce fragmentation, which involves moving surviving objects to contiguous memory blocks.

Generations

The .NET Core GC utilizes three managed object generations:

• Generation 0: Contains newly allocated objects. This generation is collected most frequently.
• Generation 1: Contains objects that have survived a Generation 0 collection.
• Generation 2: Contains objects that have survived a Generation 1 collection. This is the oldest generation and is collected least frequently.

This generational approach optimizes performance because most objects have a short lifespan. Collecting Generation 0 is much faster than collecting the entire heap.

GC Modes

The .NET Core GC can operate in different modes:

• Workstation GC: Designed for client applications, optimizing for low latency. It prioritizes responsiveness.
• Server GC: Designed for server applications, optimizing for throughput. It can utilize multiple processors more effectively to increase the rate of garbage collection.

The default mode depends on the application type and environment. You can configure the GC mode using the runtimeconfig.json file or environment variables.

Manual GC Control (Use with Caution)

While the GC is automatic, you can manually trigger a garbage collection using the GC.Collect() method. However, this is generally not recommended as it can interfere with the GC's optimized scheduling and potentially degrade performance.

using System;

public class Example
{
    public static void Main(string[] args)
    {
        // Create some objects
        object obj1 = new object();
        object obj2 = new object();

        // ... perform operations ...

        // Manually trigger a full GC (generally not recommended)
        GC.Collect();
        GC.WaitForPendingFinalizers(); // Wait for finalizers to complete

        Console.WriteLine("Manual garbage collection triggered.");
    }
}
                

GC.WaitForPendingFinalizers() is often used after GC.Collect() to ensure that any objects with finalizers that have been collected have had their finalizers run.

Finalizers and `IDisposable`

Objects that hold unmanaged resources (like file handles, network connections) should implement the IDisposable interface. This provides an explicit way to release these resources. A finalizer (a method named with a tilde, e.g., ~MyClass()) can be used as a fallback to ensure unmanaged resources are released if Dispose() is not called, but relying solely on finalizers is less efficient and deterministic.

public class ResourceUser : IDisposable
{
    private IntPtr nativeResource; // Example of an unmanaged resource

    public ResourceUser()
    {
        nativeResource = AllocateNativeResource();
    }

    // Explicit Dispose method
    public void Dispose()
    {
        ReleaseNativeResource(nativeResource);
        nativeResource = IntPtr.Zero;
        GC.SuppressFinalize(this); // Tell the GC not to finalize this object
    }

    // Finalizer (used as a fallback)
    ~ResourceUser()
    {
        Dispose(); // Ensure resources are cleaned up even if Dispose() is not called
    }

    private IntPtr AllocateNativeResource() { /* ... */ return IntPtr.Zero; }
    private void ReleaseNativeResource(IntPtr resource) { /* ... */ }
}
                

It's best practice to use the using statement with objects implementing IDisposable to ensure proper resource management.