Role of Garbage Collector in C#

What is the Role of Garbage Collector in C#?

The Garbage Collector (GC) in C# is responsible for automatic memory management. It reclaims memory occupied by objects that are no longer accessible, ensuring efficient use of system resources and preventing memory leaks.

Key Features of Garbage Collector

• Automatically deallocates memory occupied by unreachable objects.
• Prevents memory leaks and fragmentation.
• Manages memory in three generations: Gen 0, Gen 1, and Gen 2.
• Optimizes performance by running in the background.

How Does Garbage Collection Work?

The Garbage Collector follows these steps to manage memory efficiently:

1. Identifies objects that are no longer reachable.
2. Releases memory occupied by these objects.
3. Compacts memory to optimize space allocation.

Generations in Garbage Collection

The .NET Garbage Collector organizes objects into three generations to optimize performance:

Example: Forcing Garbage Collection

The following example demonstrates how to manually trigger garbage collection using GC.Collect().

Example: Forcing Garbage Collection

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Creating objects...");
        for (int i = 0; i < 5; i++)
        {
            MyClass obj = new MyClass();
        }

        Console.WriteLine("Forcing garbage collection...");
        GC.Collect();
        GC.WaitForPendingFinalizers();
        Console.WriteLine("Garbage collection completed.");
    }
}

class MyClass
{
    ~MyClass()
    {
        Console.WriteLine("Finalizer called, object collected.");
    }
}

// Output (Finalizer messages may appear later):
// Creating objects...
// Forcing garbage collection...
// Finalizer called, object collected.
// Garbage collection completed.
        

The GC.Collect() method forces garbage collection, and the destructor (~MyClass()) confirms when an object is collected.

When Should You Use Garbage Collection Manually?

Although garbage collection is automatic, in certain cases, manually triggering it can be useful:

• When dealing with large temporary objects that consume a lot of memory.
• Before entering a performance-critical section of code.
• When ensuring memory cleanup before an application exits.

Using IDisposable to Manage Resources

The IDisposable interface allows explicit resource cleanup instead of relying on the garbage collector.

Example: Implementing IDisposable

using System;

class ResourceHandler : IDisposable
{
    public ResourceHandler()
    {
        Console.WriteLine("Resource acquired.");
    }

    public void Dispose()
    {
        Console.WriteLine("Resource released.");
    }
}

// Usage
class Program
{
    static void Main()
    {
        using (ResourceHandler handler = new ResourceHandler())
        {
            Console.WriteLine("Using resource...");
        } // Automatically calls Dispose() here

        Console.WriteLine("End of program.");
    }
}

// Output:
// Resource acquired.
// Using resource...
// Resource released.
// End of program.
        

The using statement ensures Dispose() is called automatically, cleaning up resources.

Best Practices for Garbage Collection

• Allow the GC to manage memory automatically in most cases.
• Use IDisposable for unmanaged resources like file streams and database connections.
• Avoid excessive use of GC.Collect() as it can impact performance.
• Use using blocks to ensure resource cleanup.
• Monitor memory usage with profiling tools when optimizing performance.