Constructores de instancias (Guía de programación de C#)Instance Constructors (C# Programming Guide)

Los constructores de instancias se usan para crear e inicializar las variables miembro de instancia cuando se usa la expresión new para crear un objeto de una clase.Instance constructors are used to create and initialize any instance member variables when you use the new expression to create an object of a class. Para inicializar una clase estática, o variables estáticas en una clase no estática, se debe definir un constructor estático.To initialize a static class, or static variables in a non-static class, you must define a static constructor. Para obtener más información, vea Static Constructors (Constructores estáticos [Guía de programación de C#]).For more information, see Static Constructors.

En el siguiente ejemplo se muestra un constructor de instancias:The following example shows an instance constructor:

class CoOrds
{
    public int x, y;

    // constructor
    public CoOrds()
    {
        x = 0;
        y = 0;
    }
}

Nota

Para mayor claridad, esta clase contiene campos públicos.For clarity, this class contains public fields. El uso de campos públicos no es una práctica de programación recomendada porque permite que cualquier método de cualquier parte de un programa obtenga acceso sin restricciones ni comprobaciones a los mecanismos internos de un objeto.The use of public fields is not a recommended programming practice because it allows any method anywhere in a program unrestricted and unverified access to an object's inner workings. Los miembros de datos generalmente deberían ser privados y solo se debería tener acceso a ellos a través de las propiedades y métodos de la clase.Data members should generally be private, and should be accessed only through class methods and properties.

Se llama a este constructor de instancias cada vez que se crea un objeto basado en la clase CoOrds.This instance constructor is called whenever an object based on the CoOrds class is created. Un constructor como este, que no toma ningún argumento, se denomina constructor predeterminado.A constructor like this one, which takes no arguments, is called a default constructor. Pero a menudo resulta útil proporcionar constructores adicionales.However, it is often useful to provide additional constructors. Por ejemplo, se puede agregar un constructor a la clase CoOrds que permita especificar los valores iniciales de los miembros de datos:For example, we can add a constructor to the CoOrds class that allows us to specify the initial values for the data members:

// A constructor with two arguments:
public CoOrds(int x, int y)
{
    this.x = x;
    this.y = y;
}

Esto permite crear objetos CoOrd con valores iniciales predeterminados o específicos, como este:This allows CoOrd objects to be created with default or specific initial values, like this:

CoOrds p1 = new CoOrds();
CoOrds p2 = new CoOrds(5, 3);

Si una clase no tiene un constructor, se genera automáticamente un constructor predeterminado y los valores predeterminados se usan para inicializar los campos del objeto.If a class does not have a constructor, a default constructor is automatically generated and default values are used to initialize the object fields. Por ejemplo, un int se inicializa en 0.For example, an int is initialized to 0. Para más información sobre los valores predeterminados, vea Tabla de valores predeterminados (Referencia de C#).For more information on default values, see Default Values Table. Por tanto, dado que el constructor predeterminado de la clase CoOrds inicializa todos los miembros de datos en cero, se puede quitar por completo sin cambiar el funcionamiento de la clase.Therefore, because the CoOrds class default constructor initializes all data members to zero, it can be removed altogether without changing how the class works. Más adelante en este tema se proporciona un ejemplo completo del uso de varios constructores en el Ejemplo 1 y en el Ejemplo 2 se proporciona un ejemplo de un constructor generado automáticamente.A complete example using multiple constructors is provided in Example 1 later in this topic, and an example of an automatically generated constructor is provided in Example 2.

Los constructores de instancias también se pueden usar para llamar a los constructores de instancias de las clases base.Instance constructors can also be used to call the instance constructors of base classes. El constructor de clase puede invocar el constructor de la clase base a través del inicializador, como sigue:The class constructor can invoke the constructor of the base class through the initializer, as follows:

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

En este ejemplo, la clase Circle pasa valores que representan el radio y el alto al constructor proporcionado por Shape desde el que se deriva Circle.In this example, the Circle class passes values representing radius and height to the constructor provided by Shape from which Circle is derived. Un ejemplo completo del uso de Shape y Circle aparece en este tema en el Ejemplo 3.A complete example using Shape and Circle appears in this topic as Example 3.

Ejemplo 1Example 1

En el ejemplo siguiente se muestra una clase con dos constructores de clase, uno sin argumentos y uno con dos argumentos.The following example demonstrates a class with two class constructors, one without arguments and one with two arguments.

class CoOrds
{
    public int x, y;

    // Default constructor:
    public CoOrds()
    {
        x = 0;
        y = 0;
    }

    // A constructor with two arguments:
    public CoOrds(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    // Override the ToString method:
    public override string ToString()
    {
        return $"({x},{y})";
    }
}

class MainClass
{
    static void Main()
    {
        CoOrds p1 = new CoOrds();
        CoOrds p2 = new CoOrds(5, 3);

        // Display the results using the overriden ToString method:
        Console.WriteLine("CoOrds #1 at {0}", p1);
        Console.WriteLine("CoOrds #2 at {0}", p2);
        Console.ReadKey();
    }
}
/* Output:
 CoOrds #1 at (0,0)
 CoOrds #2 at (5,3)        
*/

Ejemplo 2Example 2

En este ejemplo, la clase Person no tiene ningún constructor, en cuyo caso, se proporciona automáticamente un constructor predeterminado y los campos se inicializan en sus valores predeterminados.In this example, the class Person does not have any constructors, in which case, a default constructor is automatically provided and the fields are initialized to their default values.

public class Person
{
    public int age;
    public string name;
}

class TestPerson
{
    static void Main()
    {
        Person person = new Person();

        Console.WriteLine("Name: {0}, Age: {1}", person.name, person.age);
        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
// Output:  Name: , Age: 0

Observe que el valor predeterminado de age es 0 y el valor predeterminado de name es null.Notice that the default value of age is 0 and the default value of name is null. Para más información sobre los valores predeterminados, vea Tabla de valores predeterminados (Referencia de C#).For more information on default values, see Default Values Table.

Ejemplo 3Example 3

En el ejemplo siguiente se muestra cómo usar el inicializador de la clase base.The following example demonstrates using the base class initializer. La clase Circle se deriva de la clase general Shape y la clase Cylinder se deriva de la clase Circle.The Circle class is derived from the general class Shape, and the Cylinder class is derived from the Circle class. En cada clase derivada, el constructor usa su inicializador de clase base.The constructor on each derived class is using its base class initializer.

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()
    {
        return pi * x * x;
    }
}

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

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

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

        Circle ring = new Circle(radius);
        Cylinder tube = new Cylinder(radius, height);

        Console.WriteLine("Area of the circle = {0:F2}", ring.Area());
        Console.WriteLine("Area of the cylinder = {0:F2}", tube.Area());

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    Area of the circle = 19.63
    Area of the cylinder = 86.39
*/

Para obtener más ejemplos sobre cómo invocar los constructores de clase base, vea virtual, override y base.For more examples on invoking the base class constructors, see virtual, override, and base.

Vea tambiénSee Also