Constructores en C#

En programación orientada a objetos, un constructor es un método especial que se ejecuta automáticamente cuando se crea un objeto de una clase en C#.

El constructor se utiliza para inicializar el objeto y establecer su estado inicial. Se utiliza para establecer valores iniciales en los campos y propiedades de la clase.

En C#, el nombre del constructor es el mismo que el nombre de la clase. Los constructores no tienen un tipo de valor de retorno y pueden tener parámetros.

Pueden ser sobrecargados, lo que significa que puede haber múltiples constructores con diferentes parámetros.

Por ejemplo, si tenemos una clase Persona con un constructor que imprime un mensaje por consola cuando se crea un objeto de esa clase:

class Persona {
    public Persona() {
        Console.WriteLine("Se ha creado una persona");
    }
}

Lenguaje del código: C# (cs)

Y luego creamos un objeto de esa clase en nuestro código:

Persona p = new Persona();

Lenguaje del código: C# (cs)

El constructor de la clase Persona se ejecutará automáticamente y se imprimirá el mensaje «Se ha creado una persona» por consola.

Parámetros del constructor

Los parámetros de constructor en C# son valores que se le pasan al constructor de una clase en el momento en que se crea una nueva instancia de la clase.

Estos parámetros se utilizan para establecer los valores de las propiedades de la clase y para realizar cualquier otra acción necesaria para inicializar la instancia de la clase.

En C#, es posible definir varios constructores para una clase, cada uno con diferentes parámetros.

Los constructores pueden tener parámetros opcionales y predeterminados, lo que permite que la creación de objetos de la clase sea más flexible y adaptada a las necesidades específicas del programa.

Aquí hay un ejemplo de un constructor de una clase de persona que acepta tres parámetros: nombre, edad y género:

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

    public Person(string name, int age, string gender)
    {
        this.Name = name;
        this.Age = age;
        this.Gender = gender;
    }
}

Lenguaje del código: C# (cs)

En este ejemplo, el constructor acepta tres parámetros: un nombre de tipo string, una edad de tipo int y un género de tipo string. Dentro del constructor, los valores de estos parámetros se asignan a las propiedades correspondientes de la clase.

Cuando se crea una nueva instancia de la clase Person con el constructor, se deben proporcionar valores para cada uno de los tres parámetros. Aquí hay un ejemplo de cómo se podría crear un objeto Person:

Person person = new Person("John", 30, "Male");

Lenguaje del código: C# (cs)

En este ejemplo, se crea un nuevo objeto Person con el nombre «John«, la edad 30 y el género «Male«.

Aquí te dejo un ejemplo de cómo se pueden definir varios constructores en una clase en C#, para permitir la creación de objetos de diferentes maneras.

Supongamos que queremos definir una clase Rectangulo que represente un rectángulo en un plano cartesiano.

Podríamos definir dos constructores: uno que acepta las coordenadas de los dos vértices opuestos del rectángulo, y otro que acepta el ancho y alto del rectángulo, junto con sus coordenadas.

Aquí está el código para definir la clase Rectangulo con estos dos constructores:

public class Rectangulo
{
    public double X1 { get; set; }
    public double Y1 { get; set; }
    public double X2 { get; set; }
    public double Y2 { get; set; }
    public double Ancho { get; set; }
    public double Alto { get; set; }

    public Rectangulo(double x1, double y1, double x2, double y2)
    {
        X1 = x1;
        Y1 = y1;
        X2 = x2;
        Y2 = y2;

        Ancho = Math.Abs(X2 - X1);
        Alto = Math.Abs(Y2 - Y1);
    }

    public Rectangulo(double x1, double y1, double ancho, double alto)
    {
        X1 = x1;
        Y1 = y1;
        Ancho = ancho;
        Alto = alto;

        X2 = X1 + ancho;
        Y2 = Y1 + alto;
    }
}

Lenguaje del código: C# (cs)

En este ejemplo, la clase Rectangulo tiene seis propiedades públicas para las coordenadas de los dos vértices opuestos (X1, Y1, X2, Y2), así como para el ancho y alto del rectángulo (Ancho y Alto).

El primer constructor acepta las coordenadas de los dos vértices opuestos del rectángulo, y calcula el ancho y alto a partir de ellas.

El segundo constructor acepta las coordenadas del vértice superior izquierdo del rectángulo, junto con el ancho y alto, y calcula las coordenadas del vértice inferior derecho a partir de ellas.

Ahora podemos crear objetos de la clase Rectangulo de dos maneras diferentes:

Rectangulo 
r1 = new Rectangulo(0, 0, 5, 10); // crea un rectángulo con vértices (0,0) y (5,10)
Rectangulo r2 = new Rectangulo(2, 3, 6, 4); // crea un rectángulo con vértices (2,3) y (6,4)
Rectangulo r3 = new Rectangulo(1, 2, 3, 4); // crea un rectángulo con vértices (1,2) y (4,6)

Lenguaje del código: C# (cs)

Aquí, r1 y r2 se crean usando el primer constructor, mientras que r3 se crea usando el segundo constructor. Cada uno de estos objetos Rectangulo tendrá sus propias propiedades X1, Y1, X2, Y2, Ancho y Alto, según cómo se hayan construido.