Constructores de instancias (guía de programación de C#)

Un constructor de instancia se declara para especificar el código que se ejecuta al crear una instancia de un tipo con la expresión new. Para inicializar una clase estática, o variables estáticas en una clase no estática, puede definir un constructor estático.

Como se muestra en el ejemplo siguiente, puede declarar varios constructores de instancia en un tipo:

class Coords
{
    public Coords()
        : this(0, 0)
    {  }

    public Coords(int x, int y)
    {
        X = x;
        Y = y;
    }

    public int X { get; set; }
    public int Y { get; set; }

    public override string ToString() => $"({X},{Y})";
}

class Example
{
    static void Main()
    {
        var p1 = new Coords();
        Console.WriteLine($"Coords #1 at {p1}");
        // Output: Coords #1 at (0,0)

        var p2 = new Coords(5, 3);
        Console.WriteLine($"Coords #2 at {p2}");
        // Output: Coords #2 at (5,3)
    }
}

En el ejemplo anterior, el primer constructor, sin parámetros, llama al segundo constructor con los dos argumentos igual a 0. Para hacerlo, use la palabra clave this.

Al declarar un constructor de instancia en una clase derivada, puede llamar a un constructor de una clase base. Para ello, use la palabra clave base, como se muestra en el ejemplo siguiente:

abstract class Shape
{
    public const double pi = Math.PI;
    protected double x, y;

    public Shape(double x, double y)
    {
        this.x = x;
        this.y = y;
    }

    public abstract double Area();
}

class Circle : Shape
{
    public Circle(double radius)
        : base(radius, 0)
    {  }

    public override double Area() => pi * x * x;
}

class Cylinder : Circle
{
    public Cylinder(double radius, double height)
        : base(radius)
    {
        y = height;
    }

    public override double Area() => (2 * base.Area()) + (2 * pi * x * y);
}

class Example
{
    static void Main()
    {
        double radius = 2.5;
        double height = 3.0;

        var ring = new Circle(radius);
        Console.WriteLine($"Area of the circle = {ring.Area():F2}");
        // Output: Area of the circle = 19.63
        
        var tube = new Cylinder(radius, height);
        Console.WriteLine($"Area of the cylinder = {tube.Area():F2}");
        // Output: Area of the cylinder = 86.39
    }
}

Constructores sin parámetros

Si una clase no tiene constructores de instancia explícitos, C# proporciona un constructor sin parámetros que puede usar para crear instancias de una instancia de esa clase, como se muestra en el ejemplo siguiente:

public class Person
{
    public int age;
    public string name = "unknown";
}

class Example
{
    static void Main()
    {
        var person = new Person();
        Console.WriteLine($"Name: {person.name}, Age: {person.age}");
        // Output:  Name: unknown, Age: 0
    }
}

Ese constructor inicializa los campos de instancia y las propiedades según los inicializadores correspondientes. Si un campo o una propiedad no tiene ningún inicializador, su valor se establece en el valor predeterminado del tipo de la propiedad o del campo. Si declara al menos un constructor de instancia en una clase, C# no proporciona un constructor sin parámetros.

Un tipo de estructura siempre proporciona un constructor sin parámetros, como se muestra a continuación:

Vea también