Tutorial CSharp: Constructores y destructores

Constructor por defecto

En C#, un constructor es un método especial dentro de una clase que se ejecuta automáticamente cuando se crea una instancia (objeto) de dicha clase. Su principal propósito es inicializar los atributos del objeto y prepararlo para su uso.

El constructor por defecto, también conocido como constructor sin parámetros, es aquel que no recibe ningún argumento. Este tipo de constructor es fundamental para entender cómo funcionan los objetos en C#.

Características del constructor por defecto

Un constructor por defecto tiene las siguientes características:

• Tiene el mismo nombre que la clase
• No especifica ningún tipo de retorno (ni siquiera void)
• No recibe parámetros

Cuando no defines explícitamente ningún constructor en tu clase, C# automáticamente proporciona un constructor por defecto invisible que inicializa:

• Los tipos de valor (int, double, bool, etc.) a sus valores predeterminados (0, 0.0, false)
• Los tipos de referencia (objetos, strings, arrays) a null

Sintaxis del constructor por defecto

public class Producto
{
    public string Nombre;
    public decimal Precio;
    
    // Constructor por defecto
    public Producto()
    {
        // Inicializaciones opcionales
        Nombre = "Sin nombre";
        Precio = 0;
    }
}

Uso del constructor por defecto

Para crear un objeto utilizando el constructor por defecto, simplemente usamos la palabra clave new seguida del nombre de la clase y paréntesis vacíos:

// Creación de un objeto usando el constructor por defecto
Producto miProducto = new Producto();

// Ahora miProducto.Nombre es "Sin nombre" y miProducto.Precio es 0
Console.WriteLine($"Nombre: {miProducto.Nombre}, Precio: {miProducto.Precio}");

Constructor por defecto implícito

Si no defines ningún constructor en tu clase, C# proporciona automáticamente un constructor por defecto implícito:

public class Cliente
{
    public string Nombre;
    public int Edad;
    
    // No hay constructor definido explícitamente
    // C# proporciona un constructor por defecto implícito
}

// Uso:
Cliente cliente = new Cliente(); // cliente.Nombre será null y cliente.Edad será 0

Cuándo se pierde el constructor por defecto implícito

Es importante entender que el constructor por defecto implícito solo existe si no defines ningún otro constructor. Si defines cualquier constructor (incluso uno con parámetros), el constructor por defecto implícito desaparece:

public class Empleado
{
    public string Nombre;
    public double Salario;
    
    // Constructor con parámetros
    public Empleado(string nombre)
    {
        Nombre = nombre;
        Salario = 1000;
    }
    
    // Ya no existe un constructor por defecto implícito
}

// Esto generará un error de compilación:
// Empleado emp = new Empleado(); 

// Esto funcionará:
Empleado emp = new Empleado("Ana");

Si quieres mantener la capacidad de crear objetos sin parámetros, debes definir explícitamente el constructor por defecto:

public class Empleado
{
    public string Nombre;
    public double Salario;
    
    // Constructor por defecto explícito
    public Empleado()
    {
        Nombre = "Sin asignar";
        Salario = 1000;
    }
    
    // Constructor con parámetros
    public Empleado(string nombre)
    {
        Nombre = nombre;
        Salario = 1000;
    }
}

// Ahora ambas formas funcionan:
Empleado emp1 = new Empleado();
Empleado emp2 = new Empleado("Ana");

Ejemplo práctico

Veamos un ejemplo más completo de una clase Persona con un constructor por defecto:

public class Persona
{
    // Atributos de la clase
    public string Nombre;
    public int Edad;
    public string Direccion;
    
    // Constructor por defecto
    public Persona()
    {
        Nombre = "Desconocido";
        Edad = 0;
        Direccion = "Sin dirección";
        Console.WriteLine("Se ha creado una nueva persona con valores predeterminados");
    }
    
    // Método para mostrar información
    public void MostrarInformacion()
    {
        Console.WriteLine($"Nombre: {Nombre}");
        Console.WriteLine($"Edad: {Edad}");
        Console.WriteLine($"Dirección: {Direccion}");
    }
}

Ahora podemos usar esta clase en nuestro programa:

class Program
{
    static void Main(string[] args)
    {
        // Crear una persona usando el constructor por defecto
        Persona persona1 = new Persona();
        
        // Mostrar la información inicial
        Console.WriteLine("Información inicial:");
        persona1.MostrarInformacion();
        
        // Modificar los atributos
        persona1.Nombre = "Juan";
        persona1.Edad = 25;
        persona1.Direccion = "Calle Principal 123";
        
        // Mostrar la información actualizada
        Console.WriteLine("\nInformación actualizada:");
        persona1.MostrarInformacion();
    }
}

La salida de este programa sería:

Se ha creado una nueva persona con valores predeterminados
Información inicial:
Nombre: Desconocido
Edad: 0
Dirección: Sin dirección

Información actualizada:
Nombre: Juan
Edad: 25
Dirección: Calle Principal 123

Ventajas del constructor por defecto

El constructor por defecto ofrece varias ventajas:

• Inicialización consistente: Garantiza que todos los objetos tengan un estado inicial válido.
• Valores predeterminados personalizados: Permite establecer valores iniciales más significativos que los predeterminados del sistema.
• Código de inicialización centralizado: Evita repetir código de inicialización en múltiples partes del programa.
• Compatibilidad con frameworks: Muchos frameworks y bibliotecas requieren constructores por defecto para funcionar correctamente.

Buenas prácticas

Al trabajar con constructores por defecto, considera estas recomendaciones:

• Proporciona siempre un constructor por defecto explícito si defines otros constructores y necesitas crear objetos sin parámetros.
• Inicializa todos los campos a valores razonables para evitar errores por valores nulos o incorrectos.
• Mantén el constructor simple; evita operaciones complejas o que puedan fallar.
• Si necesitas realizar inicializaciones complejas, considera usar métodos separados que se llamen desde el constructor.

Constructores parametrizados

Los constructores parametrizados son métodos especiales que permiten inicializar un objeto con valores específicos en el momento de su creación. A diferencia del constructor por defecto, estos constructores reciben uno o más parámetros que se utilizan para establecer el estado inicial del objeto.

En C#, los constructores parametrizados son fundamentales para crear objetos con estados iniciales personalizados, lo que mejora la flexibilidad y usabilidad de nuestras clases.

Sintaxis básica

Un constructor parametrizado sigue estas reglas:

• Tiene el mismo nombre que la clase
• No especifica tipo de retorno
• Recibe uno o más parámetros

public class Producto
{
    public string Nombre;
    public decimal Precio;
    
    // Constructor parametrizado
    public Producto(string nombre, decimal precio)
    {
        Nombre = nombre;
        Precio = precio;
    }
}

Creación de objetos con constructores parametrizados

Para crear un objeto utilizando un constructor parametrizado, proporcionamos los argumentos necesarios entre paréntesis:

// Creación de un objeto usando el constructor parametrizado
Producto miProducto = new Producto("Teclado", 49.99m);

// El objeto ya está inicializado con los valores proporcionados
Console.WriteLine($"Nombre: {miProducto.Nombre}, Precio: {miProducto.Precio}");
// Salida: Nombre: Teclado, Precio: 49.99

Múltiples constructores parametrizados

Una clase puede tener varios constructores con diferentes parámetros, lo que se conoce como sobrecarga de constructores:

public class Estudiante
{
    public string Nombre;
    public int Edad;
    public string Carrera;
    
    // Constructor con un parámetro
    public Estudiante(string nombre)
    {
        Nombre = nombre;
        Edad = 18;
        Carrera = "No especificada";
    }
    
    // Constructor con dos parámetros
    public Estudiante(string nombre, int edad)
    {
        Nombre = nombre;
        Edad = edad;
        Carrera = "No especificada";
    }
    
    // Constructor con tres parámetros
    public Estudiante(string nombre, int edad, string carrera)
    {
        Nombre = nombre;
        Edad = edad;
        Carrera = carrera;
    }
}

Ahora podemos crear estudiantes de diferentes maneras:

Estudiante est1 = new Estudiante("Ana");
Estudiante est2 = new Estudiante("Carlos", 20);
Estudiante est3 = new Estudiante("Elena", 22, "Informática");

Parámetros opcionales en constructores

C# permite definir parámetros opcionales en los constructores, lo que puede reducir la necesidad de múltiples sobrecargas:

public class Configuracion
{
    public bool ModoDebug;
    public string RutaArchivo;
    public int TiempoEspera;
    
    // Constructor con parámetros opcionales
    public Configuracion(bool modoDebug = false, string rutaArchivo = "config.xml", int tiempoEspera = 30)
    {
        ModoDebug = modoDebug;
        RutaArchivo = rutaArchivo;
        TiempoEspera = tiempoEspera;
    }
}

Esto nos permite crear objetos con diferentes combinaciones de parámetros:

// Usando todos los valores predeterminados
Configuracion config1 = new Configuracion();

// Especificando solo el primer parámetro
Configuracion config2 = new Configuracion(true);

// Especificando el primero y el tercero (usando parámetros nombrados)
Configuracion config3 = new Configuracion(modoDebug: true, tiempoEspera: 60);

// Especificando todos los parámetros
Configuracion config4 = new Configuracion(false, "settings.xml", 45);

Validación de parámetros

Una práctica recomendada es validar los parámetros recibidos en el constructor para asegurar que el objeto se inicialice con valores válidos:

public class Cuenta
{
    public string Titular;
    public decimal Saldo;
    
    public Cuenta(string titular, decimal saldoInicial)
    {
        // Validación de parámetros
        if (string.IsNullOrEmpty(titular))
        {
            throw new ArgumentException("El titular no puede estar vacío");
        }
        
        if (saldoInicial < 0)
        {
            throw new ArgumentException("El saldo inicial no puede ser negativo");
        }
        
        Titular = titular;
        Saldo = saldoInicial;
    }
}

Ejemplo práctico: Clase Libro

Veamos un ejemplo más completo con una clase Libro que utiliza constructores parametrizados:

public class Libro
{
    // Propiedades
    public string Titulo;
    public string Autor;
    public int Paginas;
    public string ISBN;
    public int AnioPublicacion;
    
    // Constructor con parámetros esenciales
    public Libro(string titulo, string autor)
    {
        Titulo = titulo;
        Autor = autor;
        Paginas = 0;
        ISBN = "Desconocido";
        AnioPublicacion = 0;
    }
    
    // Constructor completo
    public Libro(string titulo, string autor, int paginas, string isbn, int anioPublicacion)
    {
        Titulo = titulo;
        Autor = autor;
        Paginas = paginas;
        ISBN = isbn;
        AnioPublicacion = anioPublicacion;
    }
    
    // Método para mostrar información
    public void MostrarInformacion()
    {
        Console.WriteLine($"Título: {Titulo}");
        Console.WriteLine($"Autor: {Autor}");
        Console.WriteLine($"Páginas: {Paginas}");
        Console.WriteLine($"ISBN: {ISBN}");
        Console.WriteLine($"Año: {AnioPublicacion}");
    }
}

Uso de la clase:

class Program
{
    static void Main(string[] args)
    {
        // Crear un libro con información básica
        Libro libro1 = new Libro("Don Quijote", "Miguel de Cervantes");
        
        // Crear un libro con información completa
        Libro libro2 = new Libro(
            "Cien años de soledad", 
            "Gabriel García Márquez", 
            471, 
            "978-0307474728", 
            1967
        );
        
        // Mostrar información
        Console.WriteLine("Libro 1:");
        libro1.MostrarInformacion();
        
        Console.WriteLine("\nLibro 2:");
        libro2.MostrarInformacion();
    }
}

La salida sería:

Libro 1:
Título: Don Quijote
Autor: Miguel de Cervantes
Páginas: 0
ISBN: Desconocido
Año: 0

Libro 2:
Título: Cien años de soledad
Autor: Gabriel García Márquez
Páginas: 471
ISBN: 978-0307474728
Año: 1967

Reutilización de código entre constructores

Para evitar la duplicación de código entre constructores, podemos hacer que un constructor llame a otro utilizando la palabra clave this:

public class Empleado
{
    public string Nombre;
    public string Departamento;
    public decimal Salario;
    
    // Constructor principal
    public Empleado(string nombre, string departamento, decimal salario)
    {
        Nombre = nombre;
        Departamento = departamento;
        Salario = salario;
    }
    
    // Constructor que llama al principal
    public Empleado(string nombre, string departamento) 
        : this(nombre, departamento, 1000m)
    {
        // No es necesario código adicional, ya que this() llama al otro constructor
    }
    
    // Otro constructor que también llama al principal
    public Empleado(string nombre) 
        : this(nombre, "General")
    {
        // Este constructor llama al segundo, que a su vez llama al principal
    }
}

Ahora podemos crear empleados de diferentes maneras:

Empleado emp1 = new Empleado("Juan");  // Departamento: General, Salario: 1000
Empleado emp2 = new Empleado("Ana", "Ventas");  // Salario: 1000
Empleado emp3 = new Empleado("Carlos", "IT", 1500m);  // Valores completos

Consideraciones importantes

• Los constructores parametrizados no eliminan la necesidad de un constructor por defecto. Si necesitas ambos tipos, debes definirlos explícitamente.
• Cuando defines cualquier constructor (parametrizado o no), el constructor por defecto implícito desaparece.
• Es recomendable ordenar los parámetros de manera que los más importantes o frecuentemente utilizados aparezcan primero.
• Los parámetros opcionales deben colocarse al final de la lista de parámetros.

Buenas prácticas

• Proporciona constructores significativos: Diseña constructores que faciliten la creación de objetos válidos y útiles.
• Valida los parámetros: Asegúrate de que los valores recibidos sean válidos antes de asignarlos.
• Evita la lógica compleja: Los constructores deben centrarse en la inicialización; mueve la lógica compleja a métodos separados.
• Considera la inmutabilidad: Para objetos que no deben cambiar después de su creación, inicializa todos los campos en el constructor y hazlos de solo lectura.
• Documenta el propósito: Especialmente cuando tienes múltiples constructores, documenta el propósito de cada uno.

Inicializadores de objeto

Los inicializadores de objeto son una característica de C# que proporciona una forma concisa y elegante de crear e inicializar objetos en una sola expresión. Esta sintaxis permite asignar valores a las propiedades o campos públicos de un objeto inmediatamente después de su creación, sin necesidad de hacerlo en líneas separadas.

La sintaxis de inicializadores de objeto se introdujo para simplificar el código y hacerlo más legible, especialmente cuando necesitamos crear objetos con múltiples propiedades inicializadas.

Sintaxis básica

La sintaxis de un inicializador de objeto consiste en:

1. La creación del objeto con new y el constructor
2. Un bloque de llaves { } que contiene pares de Propiedad = valor separados por comas

// Sintaxis básica de inicializador de objeto
NombreClase objeto = new NombreClase() { Propiedad1 = valor1, Propiedad2 = valor2 };

Ejemplo práctico

Supongamos que tenemos una clase Estudiante con varias propiedades:

public class Estudiante
{
    public string Nombre { get; set; }
    public int Edad { get; set; }
    public string Curso { get; set; }
    public double Promedio { get; set; }
    
    // Constructor por defecto
    public Estudiante()
    {
        // No es necesario inicializar aquí
    }
}

Podemos crear e inicializar un objeto Estudiante de dos formas:

Forma tradicional (sin inicializadores):

// Creación e inicialización tradicional
Estudiante est1 = new Estudiante();
est1.Nombre = "María";
est1.Edad = 20;
est1.Curso = "Programación";
est1.Promedio = 8.5;

Usando inicializadores de objeto:

// Creación e inicialización con inicializador de objeto
Estudiante est2 = new Estudiante() 
{
    Nombre = "Carlos",
    Edad = 22,
    Curso = "Bases de Datos",
    Promedio = 9.2
};

Como puedes ver, la segunda forma es más concisa y mantiene toda la información de inicialización agrupada junto a la creación del objeto.

Simplificación de la sintaxis

En C#, podemos simplificar aún más la sintaxis omitiendo los paréntesis vacíos cuando usamos el constructor por defecto:

// Sintaxis simplificada (omitiendo paréntesis)
Estudiante est3 = new Estudiante 
{
    Nombre = "Ana",
    Edad = 19,
    Curso = "Algoritmos",
    Promedio = 8.7
};

Inicializadores con constructores parametrizados

Los inicializadores de objeto también pueden usarse con constructores parametrizados. En este caso, primero se ejecuta el constructor y luego se aplican las asignaciones del inicializador:

public class Producto
{
    public string Nombre { get; set; }
    public decimal Precio { get; set; }
    public string Categoria { get; set; }
    public bool Disponible { get; set; }
    
    // Constructor parametrizado
    public Producto(string nombre, decimal precio)
    {
        Nombre = nombre;
        Precio = precio;
        Disponible = true; // Valor predeterminado
    }
}

// Uso con inicializador de objeto
Producto prod = new Producto("Teclado", 45.99m) 
{
    Categoria = "Periféricos",
    Disponible = false  // Sobrescribe el valor establecido en el constructor
};

En este ejemplo, el constructor establece Nombre, Precio y Disponible, pero el inicializador sobrescribe Disponible y establece Categoria.

Inicializadores anidados

Una característica potente de los inicializadores de objeto es la capacidad de anidarlos para inicializar objetos complejos:

public class Direccion
{
    public string Calle { get; set; }
    public string Ciudad { get; set; }
    public string CodigoPostal { get; set; }
}

public class Cliente
{
    public string Nombre { get; set; }
    public Direccion DireccionEnvio { get; set; }
    public Direccion DireccionFacturacion { get; set; }
}

// Creación con inicializadores anidados
Cliente cliente = new Cliente
{
    Nombre = "Juan Pérez",
    DireccionEnvio = new Direccion
    {
        Calle = "Calle Principal 123",
        Ciudad = "Madrid",
        CodigoPostal = "28001"
    },
    DireccionFacturacion = new Direccion
    {
        Calle = "Avenida Comercial 45",
        Ciudad = "Barcelona",
        CodigoPostal = "08001"
    }
};

Este código crea un cliente con dos direcciones diferentes, todo en una sola expresión.

Inicializadores con colecciones

Los inicializadores de objeto son especialmente útiles cuando trabajamos con colecciones. C# proporciona una sintaxis específica para inicializar colecciones:

// Inicializador de lista
List<string> frutas = new List<string> { "Manzana", "Banana", "Naranja", "Pera" };

// Inicializador de diccionario
Dictionary<string, int> edades = new Dictionary<string, int>
{
    { "Juan", 25 },
    { "María", 30 },
    { "Carlos", 22 }
};

// Sintaxis alternativa para diccionarios (C# 6.0+)
Dictionary<string, int> precios = new Dictionary<string, int>
{
    ["Teclado"] = 45,
    ["Ratón"] = 25,
    ["Monitor"] = 150
};

Combinando inicializadores de objeto y colecciones

Podemos combinar inicializadores de objeto con inicializadores de colección para crear estructuras de datos complejas:

// Lista de estudiantes usando inicializadores
List<Estudiante> estudiantes = new List<Estudiante>
{
    new Estudiante { Nombre = "Ana", Edad = 19, Curso = "Programación", Promedio = 8.7 },
    new Estudiante { Nombre = "Luis", Edad = 21, Curso = "Redes", Promedio = 7.9 },
    new Estudiante { Nombre = "Elena", Edad = 20, Curso = "Bases de Datos", Promedio = 9.1 }
};

Ejemplo práctico: Sistema de gestión de biblioteca

Veamos un ejemplo más completo que muestra cómo los inicializadores de objeto pueden simplificar el código en un escenario real:

public class Autor
{
    public string Nombre { get; set; }
    public string Nacionalidad { get; set; }
}

public class Libro
{
    public string Titulo { get; set; }
    public Autor Autor { get; set; }
    public int AnioPublicacion { get; set; }
    public string ISBN { get; set; }
    public List<string> Categorias { get; set; }
}

public class Biblioteca
{
    public string Nombre { get; set; }
    public List<Libro> Catalogo { get; set; }
    
    public void MostrarCatalogo()
    {
        Console.WriteLine($"Catálogo de la biblioteca {Nombre}:");
        foreach (var libro in Catalogo)
        {
            Console.WriteLine($"- {libro.Titulo} ({libro.AnioPublicacion}) por {libro.Autor.Nombre}");
        }
    }
}

// Uso de inicializadores para crear una biblioteca completa
Biblioteca biblioteca = new Biblioteca
{
    Nombre = "Biblioteca Municipal",
    Catalogo = new List<Libro>
    {
        new Libro
        {
            Titulo = "Don Quijote de la Mancha",
            Autor = new Autor { Nombre = "Miguel de Cervantes", Nacionalidad = "Española" },
            AnioPublicacion = 1605,
            ISBN = "978-8420412146",
            Categorias = new List<string> { "Clásico", "Novela", "Aventura" }
        },
        new Libro
        {
            Titulo = "Cien años de soledad",
            Autor = new Autor { Nombre = "Gabriel García Márquez", Nacionalidad = "Colombiana" },
            AnioPublicacion = 1967,
            ISBN = "978-0307474728",
            Categorias = new List<string> { "Realismo mágico", "Ficción" }
        }
    }
};

// Mostrar el catálogo
biblioteca.MostrarCatalogo();

Este ejemplo muestra cómo podemos crear una estructura de datos compleja (una biblioteca con libros, autores y categorías) en una sola expresión utilizando inicializadores anidados.

Ventajas de los inicializadores de objeto

• Concisión: Permiten crear e inicializar objetos en una sola expresión.
• Legibilidad: Agrupan toda la información de inicialización junto a la creación del objeto.
• Flexibilidad: Funcionan con constructores por defecto y parametrizados.
• Expresividad: Hacen que el código sea más declarativo y menos imperativo.

Limitaciones

• Solo pueden inicializar propiedades y campos públicos.
• No pueden llamar a métodos durante la inicialización (excepto a través de propiedades).
• No pueden usar lógica condicional directamente en el inicializador.

Buenas prácticas

• Usa inicializadores para objetos inmutables: Son ideales para crear objetos que no cambiarán después de su creación.
• Formatea adecuadamente: Coloca cada asignación en una línea separada para mejorar la legibilidad.
• Combina con constructores: Usa constructores para la inicialización obligatoria y los inicializadores para la opcional.
• Evita inicializadores muy anidados: Si la anidación es excesiva, considera dividir la inicialización en pasos separados.

Los inicializadores de objeto son una herramienta valiosa en C# que permite escribir código más limpio y expresivo. Al dominar esta característica, podrás crear e inicializar objetos de manera más eficiente y legible.