Cómo llamar a un constructor desde otro en C#: soluciones simples

Por qué es importante: un constructor está bien, pero dos es mejor

¿Alguna vez has escrito una clase en C# y notaste que tienes varios constructores que hacen casi lo mismo? Por ejemplo, uno acepta nombre y edad, otro solo el nombre, y un tercero no acepta nada. En lugar de copiar el mismo código en cada constructor, C# ofrece una solución elegante: llamar a un constructor desde otro. Esto no solo ahorra tiempo, sino que hace que el código sea más limpio, comprensible y fácil de mantener. Hoy exploraremos este tema con ejemplos reales, como si te hubieras topado con una pregunta popular en Stack Overflow. ¡Vamos allá!

Cómo funciona la llamada de un constructor desde otro en C#

En C#, puedes llamar a un constructor desde otro usando las palabras clave this y base. Esto se llama "cadena de constructores" (constructor chaining). Analicemos ambas opciones.

1. La palabra clave this — llamar a un constructor en la misma clase

Cuando tienes varios constructores en una misma clase, puedes usar this para pasar el control a uno de ellos. Esto es especialmente útil cuando un constructor es una "generalización" de otro.

Un ejemplo simple: la clase Person, que almacena nombre y edad. El constructor por defecto establece valores estándar, mientras que el constructor parametrizado permite sobrescribirlos.

public class Person\n{\n    public string Name { get; set; }\n    public int Age { get; set; }\n\n    // Constructor por defecto\n    public Person() : this("Invitado", 18)\n    {\n        // No escribimos nada aquí — todo lo hace la cadena\n    }\n\n    // Constructor con parámetros\n    public Person(string name, int age)\n    {\n        Name = name;\n        Age = age;\n    }\n}

En este código, el punto clave es : this("Invitado", 18). Cuando creas un objeto con new Person(), se llama al constructor sin parámetros, pero este inmediatamente pasa el control al constructor con dos parámetros, enviándole los valores "Invitado" y 18. De esta manera, toda la lógica de inicialización está en un solo lugar.

2. La palabra clave base — llamar al constructor de la clase base

Si tu clase hereda de otra clase, puedes llamar al constructor de la clase base mediante base. Esto garantiza que la parte base del objeto se inicialice correctamente.

Ejemplo: la clase base Animal y la clase derivada Dog.

public class Animal\n{\n    public string Species { get; set; }\n\n    public Animal(string species)\n    {\n        Species = species;\n    }\n}\n\npublic class Dog : Animal\n{\n    public string Breed { get; set; }\n\n    // El constructor de Dog llama al constructor de Animal\n    public Dog(string breed) : base("Perro")\n    {\n        Breed = breed;\n    }\n}

Aquí, : base("Perro") le dice al compilador: "Primero ejecuta el constructor de la clase base Animal con el argumento 'Perro', y luego continúa con la inicialización de Dog". Sin esto, obtendrías un error de compilación, ya que Animal no tiene un constructor por defecto.

Ejemplo real: una pregunta popular de Stack Overflow

Imagina que estás trabajando en una aplicación para una tienda en línea. Tienes una clase Order que puede crearse de diferentes maneras: con un identificador de cliente, con un conjunto completo de datos, o sin parámetros (para pruebas).

public class Order\n{\n    public int OrderId { get; set; }\n    public int CustomerId { get; set; }\n    public decimal TotalAmount { get; set; }\n    public DateTime CreatedDate { get; set; }\n\n    // Constructor sin parámetros — para pruebas\n    public Order() : this(0, 0, 0)\n    {\n    }\n\n    // Constructor con datos mínimos\n    public Order(int customerId, decimal totalAmount) : this(0, customerId, totalAmount)\n