Tutorial CSharp: Constructores y destructores

Los constructores y destructores son conceptos fundamentales en la programación orientada a objetos en C#. Ambos son métodos especiales que se utilizan para inicializar y limpiar los objetos de una clase.

Constructores

Un constructor en C# es un método especial en una clase que se llama automáticamente cuando se crea una instancia de esa clase. Los constructores tienen el mismo nombre que la clase y no devuelven ningún valor, ni siquiera void.

Constructor predeterminado

Cuando no se define explícitamente un constructor para una clase, el compilador C# proporciona automáticamente un constructor predeterminado. Este constructor predeterminado no tiene parámetros y no realiza ninguna operación.

public class MiClase
{
    // El compilador agrega automáticamente un constructor predeterminado aquí
}

Constructor personalizado

Los programadores pueden definir sus propios constructores personalizados. Estos pueden tener parámetros, lo que permite inicializar los campos del objeto durante su creación.

public class Persona
{
    public string Nombre { get; set; }
    public int Edad { get; set; }

    // Constructor personalizado
    public Persona(string nombre, int edad)
    {
        Nombre = nombre;
        Edad = edad;
    }
}

// Uso del constructor personalizado
Persona persona = new Persona("Juan", 30);

Constructor estático

Un constructor estático, al contrario que los constructores de instancia, es un constructor especial que se usa para inicializar la clase misma en lugar de una instancia de la clase. Se llama automáticamente antes de que se cree la primera instancia de la clase o se acceda a cualquier miembro estático, una única vez. No toma parámetros.

public class MiClase
{
    static MiClase()
    {
        // Inicialización de la clase aquí
    }
}

Sobrecarga de constructores

En C#, un concepto importante y útil es la sobrecarga de constructores. La sobrecarga de constructores ocurre cuando una clase tiene más de un constructor, cada uno con un número diferente de parámetros o tipos de parámetros diferentes.

La sobrecarga de constructores permite crear instancias de la clase en varias formas, proporcionando diferentes tipos de inicialización dependiendo de las necesidades del objeto.

public class Persona
{
    public string Nombre { get; set; }
    public int Edad { get; set; }

    // Constructor sin parámetros
    public Persona()
    {
        Nombre = "Desconocido";
        Edad = 0;
    }

    // Constructor con un parámetro
    public Persona(string nombre)
    {
        Nombre = nombre;
        Edad = 0;
    }

    // Constructor con dos parámetros
    public Persona(string nombre, int edad)
    {
        Nombre = nombre;
        Edad = edad;
    }
}

// Uso de los constructores sobrecargados
Persona persona1 = new Persona();
Persona persona2 = new Persona("Juan");
Persona persona3 = new Persona("Ana", 25);

En este caso, si se crea una nueva Persona sin pasar ningún argumento al constructor, el primer constructor se invocará, asignando los valores predeterminados al Nombre y Edad. Si se pasa un solo argumento de tipo string, se invocará el segundo constructor, y si se pasan dos argumentos, se invocará el tercer constructor.

La sobrecarga de constructores proporciona una gran flexibilidad y hace que el código sea más legible y fácil de usar.

Destructores

Un destructor en C# es un método que se llama automáticamente cuando un objeto no está en uso, y por tanto, cuando el objeto está a punto de ser destruido por el recoletor de basura. Los destructores tienen el mismo nombre que la clase pero se preceden de una virgulilla (~) y no pueden tener parámetros ni modificadores.

En C#, el recolector de basura (garbage collector) se encarga automáticamente de liberar la memoria ocupada por los objetos cuando ya no están en uso. Sin embargo, si un objeto está utilizando recursos no administrados, como archivos o conexiones de red, es posible que se necesite liberar explícitamente esos recursos en el destructor.

public class MiClase
{
    // Destructor
    ~MiClase()
    {
        // Liberación de recursos no administrados aquí
    }
}

Debido a que la recolección de basura en C# puede manejar la mayoría de los escenarios de limpieza de memoria, el uso de destructores es menos común en C# que en algunos otros lenguajes, como C++. En la mayoría de los casos, es mejor utilizar el patrón dispose o implementar la interfaz IDisposable para liberar explícitamente los recursos no administrados.