Constructores en C#: Tipos, ejemplos y patrones avanzados

Constructores en C#

Descubre cómo los constructores inicializan objetos en C#, cubriendo todos los tipos de constructores, patrones y mejores prácticas.

En C#, un constructor es un método especial invocado automáticamente cuando se crea una nueva instancia de una clase. A diferencia de los métodos regulares, los constructores:

• comparten el mismo nombre que la clase
• no devuelven un valor

---

Creando un constructor en C#

Define un constructor dentro de una clase usando el nombre de la clase:

class Car {
    // constructor
    Car() {
        // código de inicialización
    }
}

Aquí, Car() es el constructor. Se invoca usando la palabra clave new:

new Car();

Por ejemplo:

Car car1 = new Car();

Ver también: Clases y objetos en C#.

---

Tipos de constructores

Las categorías típicas de constructores incluyen:

• Constructor sin parámetros (por defecto)
• Constructor con parámetros
• Constructor de copia
• Constructor privado
• Constructor estático

---

1. Constructor sin parámetros

Un constructor sin parámetros se llama constructor sin parámetros o por defecto. Ejemplo:

using System;
namespace ConstructorDemo {
    class Car {
        // constructor sin parámetros
        Car() {
            Console.WriteLine("Car Constructor");
        }
        static void Main(string[] args) {
            new Car();
            Console.ReadLine();
        }
    }
}

Salida

Car Constructor

---

2. Constructor con parámetros

Los constructores pueden aceptar argumentos para inicializar campos de instancia:

using System;
namespace ConstructorDemo {
    class Car {
        string brand;
        int price;
        // constructor con parámetros
        Car(string theBrand, int thePrice) {
            brand = theBrand;
            price = thePrice;
        }
        static void Main(string[] args) {
            Car car1 = new Car("Bugatti", 50000);
            Console.WriteLine("Brand: " + car1.brand);
            Console.WriteLine("Price: " + car1.price);
            Console.ReadLine();
        }
    }
}

Salida

Brand: Bugatti
Price: 50000

---

3. Constructor por defecto

Si omites un constructor, el compilador proporciona un constructor sin parámetros implícito que inicializa los campos a sus valores por defecto. Ejemplo:

using System;
namespace ConstructorDemo {
    class Program {
        int a;
        static void Main(string[] args) {
            Program p1 = new Program();
            Console.WriteLine("Default value of a: " + p1.a);
            Console.ReadLine();
        }
    }
}

Salida

Default value of a: 0

Los campos numéricos valen 0 por defecto, mientras que strings y objetos valen null.

---

4. Constructor de copia

Un constructor de copia crea una nueva instancia copiando el estado de otro objeto:

using System;
namespace ConstructorDemo {
    class Car {
        string brand;
        // constructor principal
        Car(string theBrand) {
            brand = theBrand;
        }
        // constructor de copia
        Car(Car c1) {
            brand = c1.brand;
        }
        static void Main(string[] args) {
            Car car1 = new Car("Bugatti");
            Console.WriteLine("Brand of car1: " + car1.brand);
            Car car2 = new Car(car1);
            Console.WriteLine("Brand of car2: " + car2.brand);
            Console.ReadLine();
        }
    }
}

Salida

Brand of car1: Bugatti
Brand of car2: Bugatti

---

5. Constructor privado

Marcar un constructor private previene la instanciación externa, útil para patrones singleton o clases de utilidad.

Ejemplo

using System;
namespace ConstructorDemo {
    class Car {
        private Car() {
            Console.WriteLine("Private Constructor");
        }
    }
    class CarDrive {
        static void Main(string[] args) {
            // Car car1 = new Car(); // error en tiempo de compilación
            Console.ReadLine();
        }
    }
}

El error:

error CS0122: 'Car.Car()' is inaccessible due to its protection level

Nota: Cuando un constructor es privado, todos los miembros de la clase deben ser estáticos para permitir acceso vía nombre de clase.

---

6. Constructor estático

Un constructor estático se ejecuta una vez por tipo, antes de que se acceda a cualquier miembro de instancia o estático. No puede ser llamado directamente y no debe tener parámetros.

using System;
namespace ConstructorDemo {
    class Car {
        static Car() {
            Console.WriteLine("Static Constructor");
        }
        Car() {
            Console.WriteLine("Default Constructor");
        }
        static void Main(string[] args) {
            Car car1 = new Car();
            Car car2 = new Car();
            Console.ReadLine();
        }
    }
}

Salida

Static Constructor
Default Constructor
Default Constructor

Nota: Solo un constructor estático por clase; no puede tener parámetros ni modificadores de acceso.

---

Sobrecarga de constructores en C#

Define múltiples constructores con listas de parámetros diferentes para proporcionar creación de objetos flexible. Ejemplo:

using System;
namespace ConstructorOverloadDemo {
    class Car {
        Car() {
            Console.WriteLine("Car constructor");
        }
        Car(string brand) {
            Console.WriteLine("Car constructor with one parameter");
            Console.WriteLine("Brand: " + brand);
        }
        static void Main(string[] args) {
            Car car = new Car();
            Console.WriteLine();
            Car car2 = new Car("Bugatti");
            Console.ReadLine();
        }
    }
}

Salida

Car constructor
Car constructor with one parameter
Brand: Bugatti

El compilador selecciona el constructor coincidente basado en la cuenta y tipos de argumentos. Aprende más en Sobrecarga de constructores en C#.