Constructors, Destructors & Garbage Collection in C#

Constructors, Destructors & Garbage Collection in C#

In C#, constructors and destructors manage object lifecycle, while garbage collection (GC) automatically frees memory when objects are no longer needed.

What is a Constructor?

A constructor is a special method that is automatically called when an object of a class is created. It initializes the object and can have parameters.

Example of a Constructor:

public class Car
{
    public string Model;
    public int Speed;

    // Constructor
    public Car(string model, int speed)
    {
        Model = model;
        Speed = speed;
    }

    public void ShowDetails()
    {
        Console.WriteLine($"Model: {Model}, Speed: {Speed} km/h");
    }
}

// Usage
Car car = new Car("Toyota", 120);
car.ShowDetails();  // Output: Model: Toyota, Speed: 120 km/h
        

In this example, the constructor initializes the Car object when it's created.

Types of Constructors

• Default Constructor: A constructor with no parameters.
• Parameterized Constructor: A constructor with parameters to initialize fields.
• Copy Constructor: A constructor that copies values from another object.
• Static Constructor: Initializes static members of a class.
• Private Constructor: Used in singleton patterns to restrict object creation.

What is a Destructor?

A destructor is a special method that is automatically called when an object is destroyed to free resources. Destructors have the same name as the class but are prefixed with a tilde (~).

Example of a Destructor:

public class Car
{
    public string Model;

    public Car(string model)
    {
        Model = model;
    }

    public void Display()
    {
        Console.WriteLine($"Car Model: {Model}");
    }

    // Destructor
    ~Car()
    {
        Console.WriteLine("Destructor called for " + Model);
    }
}

// Usage
Car myCar = new Car("Honda");
myCar.Display();  // Output: Car Model: Honda
// Destructor will be called automatically when object is destroyed
        

Destructors are automatically called when an object is no longer in use, typically when the program exits.

What is Garbage Collection?

The Garbage Collector (GC) in C# automatically frees memory occupied by objects that are no longer in use. It helps manage memory efficiently.

Example of Garbage Collection:

public class Program
{
    public static void Main()
    {
        for (int i = 0; i < 3; i++)
        {
            Car car = new Car($"Car {i}");
        }

        // Force garbage collection
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
}
        

In this example, multiple objects are created inside a loop, and garbage collection is forced using GC.Collect() to free memory.

Key Features of Garbage Collection

• Runs automatically but can be triggered manually using GC.Collect().
• Uses three generations (Gen 0, Gen 1, Gen 2) to optimize memory management.
• Reclaims memory occupied by unreachable objects.
• Does not guarantee immediate destructor execution.

Comparison: Constructors, Destructors & Garbage Collection