Garbage Collection Algorithm in C#

What is the Garbage Collection Algorithm in C#?

The Garbage Collection (GC) Algorithm in C# is an automatic memory management process that reclaims unused memory by identifying and removing objects that are no longer accessible. It improves application performance and prevents memory leaks.

Key Features of the Garbage Collection Algorithm

• Automatically frees up memory occupied by unreachable objects.
• Works in **three generations (Gen 0, Gen 1, Gen 2)** for optimization.
• Prevents memory fragmentation and improves performance.
• Runs in the background without interrupting application execution.

How Does the Garbage Collection Algorithm Work?

The GC algorithm follows a three-step process:

1. **Mark** - Identifies objects that are still in use.
2. **Sweep** - Removes objects that are no longer accessible.
3. **Compact** - Rearranges memory to optimize space.

Generational Garbage Collection

The garbage collector categorizes objects into three generations:

Example: Garbage Collection in Action

The following example demonstrates how the garbage collection algorithm works in C#.

Example: Demonstrating Generational Garbage Collection

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"Total Memory Before GC: {GC.GetTotalMemory(false)} bytes");

        for (int i = 0; i < 10000; i++)
        {
            object obj = new object(); // Allocated in Gen 0
        }

        Console.WriteLine($"Total Memory After Object Creation: {GC.GetTotalMemory(false)} bytes");

        GC.Collect(); // Force Garbage Collection
        GC.WaitForPendingFinalizers();

        Console.WriteLine($"Total Memory After GC: {GC.GetTotalMemory(false)} bytes");
        Console.WriteLine($"Current Generation of a new object: {GC.GetGeneration(new object())}");
    }
}

// Output (Example):
// Total Memory Before GC: 100000 bytes
// Total Memory After Object Creation: 200000 bytes
// Total Memory After GC: 100000 bytes
// Current Generation of a new object: 0
        

The GC.Collect() method triggers garbage collection, reclaiming unused memory.

Using Weak References with Garbage Collection

Weak references allow objects to be garbage-collected while still accessible in memory.

Example: Using WeakReference to Allow GC

using System;

class Program
{
    static void Main()
    {
        WeakReference weakRef = new WeakReference(new object());

        Console.WriteLine($"Is Object Alive: {weakRef.IsAlive}");
        GC.Collect();
        Console.WriteLine($"Is Object Alive After GC: {weakRef.IsAlive}");
    }
}

// Output:
// Is Object Alive: True
// Is Object Alive After GC: False
        

The WeakReference allows the object to be collected while still accessible.

Best Practices for Garbage Collection

• Avoid excessive use of GC.Collect() as it may impact performance.
• Use IDisposable for releasing unmanaged resources like file handles.
• Monitor memory usage with profiling tools to detect memory leaks.
• Use weak references to allow objects to be garbage-collected when necessary.