.NET Core Runtime Documentation

Understanding Garbage Collection in .NET Core

Garbage Collection (GC) is an automatic memory management process in the .NET Core runtime. Its primary responsibility is to reclaim memory that is no longer being used by an application, preventing memory leaks and improving overall application stability and performance.

The .NET GC is a generational, compacting garbage collector. This means it categorizes objects into generations based on their lifespan and periodically moves objects to reduce fragmentation and improve allocation speed.

Generations

The .NET GC uses a generational approach, dividing the managed heap into three generations:

• Generation 0 (Gen 0): This is where newly created objects are allocated. Most objects are short-lived and will be collected in Gen 0.
• Generation 1 (Gen 1): Objects that survive a Gen 0 collection are promoted to Gen 1. This generation acts as a buffer between Gen 0 and Gen 2.
• Generation 2 (Gen 2): Objects that survive a Gen 1 collection are promoted to Gen 2. This generation typically holds long-lived objects.

When a GC cycle occurs, it starts with the youngest generation (Gen 0). If the heap is still under memory pressure after collecting Gen 0, it proceeds to Gen 1, and then to Gen 2. This strategy is efficient because most objects are short-lived and can be collected quickly in Gen 0.

Compacting GC

The .NET GC is also a compacting collector. After identifying and reclaiming unreachable objects, the GC moves the remaining, reachable objects closer together in memory. This process:

• Reduces memory fragmentation: Contiguous blocks of memory are created, making it easier and faster to allocate new, larger objects.
• Improves locality of reference: Objects that reference each other are often placed closer together in memory, which can benefit CPU cache performance.

GC Modes

.NET Core supports different GC modes, which can be configured to optimize for various application scenarios:

• Workstation GC: This mode is the default for client applications. It prioritizes low latency by running the GC on a single thread and performing background collections.
• Server GC: This mode is the default for server applications. It uses multiple GC threads, one for each CPU core, to achieve higher throughput. It typically performs larger, more thorough collections.

You can configure the GC mode using the runtimeconfig.json file or environment variables.

// Example runtimeconfig.json snippet
{
  "runtimeOptions": {
    "configProperties": {
      "System.GC.Mode": "Server" // or "Workstation"
    }
  }
}
            

Manual GC Control

While the GC is automatic, developers have some limited ability to influence its behavior. The most common way is by explicitly triggering a garbage collection using GC.Collect().

However, it is generally not recommended to call GC.Collect() unless you have a very specific reason, such as managing unmanaged resources explicitly or for testing scenarios. Relying on the automatic GC is usually more efficient and less error-prone.

using System;

public class Example
{
    public static void Main(string[] args)
    {
        // ... perform some operations ...

        // Explicitly trigger a full, blocking garbage collection.
        // Use with caution!
        // GC.Collect();
        // GC.WaitForPendingFinalizers(); // Often called after GC.Collect()
    }
}
            

The GC.WaitForPendingFinalizers() method waits for any finalizers (destructors) to complete. This is often paired with GC.Collect().

Performance Considerations

To optimize GC performance in your .NET Core applications:

• Minimize object creation: Reuse objects where possible (e.g., using `struct` for small, short-lived data, object pooling).
• Dispose managed resources: Implement the `IDisposable` interface and use the using statement for objects that hold unmanaged resources or implement `IDisposable`. This ensures resources are released promptly.
• Understand object lifetimes: Be mindful of long-lived objects that are constantly promoted to higher generations, as they increase the cost of Gen 2 collections.
• Choose the right GC mode: Select Server GC for high-throughput server applications and Workstation GC for low-latency client applications.
• Avoid finalizers where possible: Finalizers are expensive. Prefer `IDisposable` for resource cleanup.