Constructors, Destructors and this in C#

In C#, classes and structs have special methods that define how objects are created and destroyed. A constructor runs when an object is created and assigns initial values. A destructor is called just before an object is removed from memory. The this keyword refers to the current instance of the class and is especially useful with parameters of the same name or for method chaining.

Constructor

A constructor is a special method with the same name as the class. It is executed automatically when a new object is created and is commonly used to assign initial values. It can take parameters and can be overloaded. If no constructor is defined, C# provides a default (parameterless) constructor.

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }

    // Parameterless constructor
    public Product()
    {
        Name = "Unknown";
        Price = 0;
    }

    // Parameterized constructor
    public Product(string name, decimal price)
    {
        Name = name;
        Price = price;
    }

    public void Print()
    {
        Console.WriteLine($"{Name} - {Price:0.00} USD");
    }
}

class Program
{
    static void Main()
    {
        var p1 = new Product(); // parameterless
        var p2 = new Product("Notebook", 45m); // with parameters

        p1.Print(); // Unknown - 0.00 USD
        p2.Print(); // Notebook - 45.00 USD
    }
}

Destructor

A destructor is defined by prefixing the class name with ~ and it cannot take parameters. It is called right before an object is cleaned up from memory by the Garbage Collector. While it can be used for cleanup operations like closing files or releasing memory, the .NET Garbage Collector usually makes manual destructors unnecessary.

public class Logger
{
    public Logger()
    {
        Console.WriteLine("Logger started.");
    }

    ~Logger()
    {
        Console.WriteLine("Logger cleaned up from memory.");
    }
}

class Program
{
    static void Main()
    {
        var log = new Logger();
        log = null;

        // Trigger Garbage Collector
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
}

The this Keyword

this refers to the current instance of a class. It is used to distinguish between parameters and properties with the same name, for method chaining, or to call another constructor within the same class.

public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }

    // Constructor with parameter names same as property names
    public Customer(string name, string email)
    {
        this.Name = name;   // assignment using this
        this.Email = email;
    }

    // Method chaining
    public Customer SetName(string name)
    {
        this.Name = name;
        return this;
    }

    public Customer SetEmail(string email)
    {
        this.Email = email;
        return this;
    }

    public void Print()
    {
        Console.WriteLine($"{Name} - {Email}");
    }
}

class Program
{
    static void Main()
    {
        var c = new Customer("John", "john@example.com")
                    .SetName("Michael")
                    .SetEmail("michael@example.com");

        c.Print(); // Michael - michael@example.com
    }
}

Calling a Constructor with this

You can call one constructor from another within the same class using this(...). This approach reduces repetitive code and centralizes shared initialization logic.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public Person(string name) : this(name, 0) // calls another constructor
    {
    }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public void Print()
    {
        Console.WriteLine($"{Name} ({Age})");
    }
}

class Program
{
    static void Main()
    {
        var p1 = new Person("Alice");
        var p2 = new Person("Mary", 25);

        p1.Print(); // Alice (0)
        p2.Print(); // Mary (25)
    }
}

TL;DR