Utilizar constructores (Guía de programación de C#)
Cuando se crea una instancia de una class o un struct, se llama a su constructor. Los constructores tienen el mismo nombre que la class o el struct y suelen inicializar los miembros de datos del nuevo objeto.
En el ejemplo siguiente, una clase denominada Taxi se define mediante un constructor simple. Luego, se crea una instancia de la clase con el operador new. El constructor Taxi se invoca con el operador new inmediatamente después de asignar memoria para el nuevo objeto.
public class Taxi
{
public bool IsInitialized;
public Taxi()
{
IsInitialized = true;
}
}
class TestTaxi
{
static void Main()
{
Taxi t = new Taxi();
Console.WriteLine(t.IsInitialized);
}
}
Un constructor que no toma ningún parámetro se denomina constructor sin parámetros. Los constructores sin parámetros se invocan cada vez que se crea una instancia de un objeto mediante el operador new y no se especifica ningún argumento en new. Para obtener más información, vea Instance Constructors (Constructores de instancias [Guía de programación de C#]).
A menos que la clase sea static, las clases sin constructores tienen un constructor público sin parámetros por el compilador de C# con el fin de habilitar la creación de instancias de clase. Para más información, vea Clases estáticas y sus miembros.
Puede impedir que se cree una instancia de una clase convirtiendo el constructor en privado, de la manera siguiente:
class NLog
{
// Private Constructor:
private NLog() { }
public static double e = Math.E; //2.71828...
}
Para obtener más información, vea Private Constructors (Constructores privados [Guía de programación de C#]).
Los constructores de tipos struct son similares a los constructores de clases, pero los structs no pueden contener un constructor sin parámetros explícito porque el compilador proporciona uno automáticamente. Este constructor inicializa cada campo del struct en los valores predeterminados. Pero este constructor sin parámetros solo se invoca si las instancias de struct se crean con new. Por ejemplo, este código usa el constructor sin parámetros para Int32, por lo que se tiene la certeza de que el entero se inicializa:
int i = new int();
Console.WriteLine(i);
Nota
A partir de C# 10, un tipo de estructura puede contener un constructor sin parámetros explícito. Para más información, consulte la sección Inicialización de estructuras y valores predeterminados del artículo Tipos de estructuras.
Sin embargo, el siguiente código genera un error del compilador porque no usa new y porque intenta usar un objeto que no se ha inicializado:
int i;
Console.WriteLine(i);
También puede inicializar o asignar los objetos basados en structs (incluidos todos los tipos numéricos integrados) y luego usarlos como en el ejemplo siguiente:
int a = 44; // Initialize the value type...
int b;
b = 33; // Or assign it before using it.
Console.WriteLine("{0}, {1}", a, b);
Así que no es necesario llamar al constructor sin parámetros para un tipo de valor.
Tanto las clases como los structs pueden definir constructores que toman parámetros. Los constructores que toman parámetros deben llamarse mediante una instrucción new o base. Las clases y structs también pueden definir varios constructores y no es necesario definir un constructor sin parámetros. Por ejemplo:
public class Employee
{
public int Salary;
public Employee() { }
public Employee(int annualSalary)
{
Salary = annualSalary;
}
public Employee(int weeklySalary, int numberOfWeeks)
{
Salary = weeklySalary * numberOfWeeks;
}
}
Esta clase se puede crear mediante cualquiera de las siguientes instrucciones:
Employee e1 = new Employee(30000);
Employee e2 = new Employee(500, 52);
Un constructor puede usar la palabra clave base para llamar al constructor de una clase base. Por ejemplo:
public class Manager : Employee
{
public Manager(int annualSalary)
: base(annualSalary)
{
//Add further instructions here.
}
}
En este ejemplo, se llama al constructor de la clase base antes de ejecutar el bloque del constructor. La palabra clave base puede usarse con o sin parámetros. Los parámetros del constructor se pueden usar como parámetros en base o como parte de una expresión. Para obtener más información, vea base.
En una clase derivada, si un constructor de clase base no se llama explícitamente con la palabra clave base, se llama implícitamente al constructor sin parámetros, si hay alguno. Esto significa que las siguientes declaraciones del constructor son en efecto iguales:
public Manager(int initialData)
{
//Add further instructions here.
}
public Manager(int initialData)
: base()
{
//Add further instructions here.
}
Si una clase base no proporciona un constructor sin parámetros, la clase derivada debe realizar una llamada explícita a un constructor base mediante base.
Un constructor puede invocar otro constructor en el mismo objeto mediante la palabra clave this. Igual que base, this puede usarse con o sin parámetros. Además, los parámetros del constructor están disponibles como parámetros en this o como parte de una expresión. Por ejemplo, el segundo constructor del ejemplo anterior se puede reescribir con this:
public Employee(int weeklySalary, int numberOfWeeks)
: this(weeklySalary * numberOfWeeks)
{
}
El uso de la palabra clave this en el ejemplo anterior llama a este constructor:
public Employee(int annualSalary)
{
Salary = annualSalary;
}
Los constructores se pueden marcar como public, private, protected, internal, protected internal o private protected. Estos modificadores de acceso definen cómo los usuarios de la clase pueden construir la clase. Para obtener más información, consulte Modificadores de acceso.
Un constructor puede declararse estático mediante la palabra clave static. Los constructores estáticos se llaman automáticamente, inmediatamente antes de acceder a los campos estáticos y, por lo general, se usan para inicializar miembros de clase estática. Para obtener más información, vea Static Constructors (Constructores estáticos [Guía de programación de C#]).
Especificación del lenguaje C#
Para obtener más información, vea las secciones Constructores de instancia y Constructores estáticos de la Especificación del lenguaje C#. La especificación del lenguaje es la fuente definitiva de la sintaxis y el uso de C#.