Constructores, Destructores y this en C#

En C#, las clases y las estructuras tienen métodos especiales que definen cómo se crean y destruyen los objetos. Un constructor se ejecuta cuando se crea un objeto y asigna valores iniciales. Un destructor se llama justo antes de que un objeto sea eliminado de la memoria. La palabra clave this hace referencia a la instancia actual de la clase y es especialmente útil con parámetros del mismo nombre o para el encadenamiento de métodos.

Constructor

Un constructor es un método especial que tiene el mismo nombre que la clase. Se ejecuta automáticamente cuando se crea un nuevo objeto y generalmente se utiliza para asignar valores iniciales. Puede aceptar parámetros y puede sobrecargarse. Si no se define ningún constructor, C# proporciona un constructor predeterminado (sin parámetros).

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

    // Constructor sin parámetros
    public Product()
    {
        Name = "Desconocido";
        Price = 0;
    }

    // Constructor con parámetros
    public Product(string name, decimal price)
    {
        Name = name;
        Price = price;
    }

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

class Program
{
    static void Main()
    {
        var p1 = new Product(); // sin parámetros
        var p2 = new Product("Cuaderno", 45m); // con parámetros

        p1.Print(); // Desconocido - 0.00 EUR
        p2.Print(); // Cuaderno - 45.00 EUR
    }
}

Destructor

Un destructor se define anteponiendo ~ al nombre de la clase y no puede aceptar parámetros. Se llama justo antes de que el recolector de basura (Garbage Collector) elimine el objeto de la memoria. Aunque puede usarse para operaciones de limpieza como cerrar archivos o liberar memoria, gracias al Garbage Collector de .NET rara vez es necesario definir destructores manualmente.

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

    ~Logger()
    {
        Console.WriteLine("Logger eliminado de la memoria.");
    }
}

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

        // Forzar al Garbage Collector
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
}

La palabra clave this

this hace referencia a la instancia actual de una clase. Se utiliza para distinguir entre parámetros y propiedades con el mismo nombre, para el encadenamiento de métodos (method chaining) o para llamar a otro constructor dentro de la misma clase.

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

    // Constructor con parámetros del mismo nombre que las propiedades
    public Customer(string name, string email)
    {
        this.Name = name;   // asignación con this
        this.Email = email;
    }

    // Encadenamiento de métodos (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("Miguel")
                    .SetEmail("miguel@example.com");

        c.Print(); // Miguel - miguel@example.com
    }
}

Llamar a un Constructor con this

Con this(...) se puede llamar a un constructor desde otro dentro de la misma clase. Este enfoque reduce la duplicación de código y centraliza la lógica de inicialización común.

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

    public Person(string name) : this(name, 0) // llama al otro 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("Alicia");
        var p2 = new Person("María", 25);

        p1.Print(); // Alicia (0)
        p2.Print(); // María (25)
    }
}

TL;DR