Constructores
Cada vez que se crea una clase o struct, se llama a su constructor. Una clase o struct puede tener varios
constructores que toman argumentos diferentes. Los constructores permiten al
programador establecer valores predeterminados, limitar la creación de
instancias y escribir código flexible y fácil de leer.
Si no se proporciona un constructor para el objeto, C# creará uno de forma predeterminada que cree instancias del objeto y establezca las variables miembro en los valores predeterminados.
Las clases y structs estáticos también pueden tener constructores.
Cuando se crea clase o struct, se llama al constructor. Los constructores tienen el mismo nombre que la clase o struct, e inicializan normalmente los miembros de datos del nuevo objeto.
En el ejemplo siguiente, una clase denominada Taxi se define mediante un constructor simple.
Esta clase crea instancias con el operador new. El operador new invoca el constructor Taxi inmediatamente después de asignar la memoria al nuevo objeto.
C#
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 predeterminado. Los constructores predeterminados se
invocan cada vez que se crea una instancia de un objeto mediante el operador
new y no se proporciona ningún argumento a new.
A menos que la clase sea estática, a las clases sin constructores se les asigna un constructor público predeterminado a través del compilador de C# con el fin de habilitar la creación de instancias de clases.
Es posible evitar que se creen instancias de una clase mediante la conversión del constructor a privado, como se muestra a continuación:
C#
class NLog
{
// Private
Constructor:
private
NLog() { }
public static
double e = Math.E; //2.71828...
}
Los constructores para los tipos struct son similares a los constructores de clases, pero los tipos structs no
pueden contener un constructor predeterminado explícito porque el compilador
proporciona uno automáticamente. Este constructor inicializa cada campo del
tipo struct con los valores predeterminados. Sin embargo, este constructor
predeterminado sólo se invoca si se crean instancias del tipo struct con new.
Por ejemplo, en este código se utiliza el constructor predeterminado para Int32, lo que garantiza la inicialización del tipo entero:
int i = new int();
Console.WriteLine(i);
Sin embargo, el código siguiente genera un error del compilador porque no usa new e intenta utilizar un objeto que no se ha inicializado:
int i;
Console.WriteLine(i);
Como alternativa, se pueden inicializar objetos basados en structs (incluidos todos los tipos numéricos integrados) o asignarse y, a continuación, utilizarse 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);
En consecuencia no se requiere llamar al constructor predeterminado para un tipo de valor.
Tanto las clases como las structs pueden definir constructores que acepten parámetros. Se debe llamar a constructores que toman parámetros a través de una instrucción new o base. Las clases y las structs también pueden definir varios constructores y no se requiere ninguno para definir un constructor predeterminado. Por ejemplo:
C#
public class Employee
{
public int
salary;
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:
C#
Employee e1 = new Employee(30000);
Employee e2 = new Employee(500, 52);
Cualquier constructor puede utilizar la
palabra clave base para llamar al constructor de una clase base. Por ejemplo:
C#
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 se puede utilizar con o sin parámetros. Cualquier parámetro del
constructor se puede utilizar como parámetro de base o como parte de una
expresión.
En una clase derivada, si no se llama explícitamente al constructor de la clase base mediante la palabra clave base, se llamará implícitamente al constructor predeterminado, si existe alguno.
Esto significa que las siguientes declaraciones del constructor son efectivamente las mismas:
C#
public Manager(int initialdata)
{
//Add
further instructions here.
}
C#
public Manager(int initialdata)
: base()
{
//Add further instructions here.
}
Si una clase base no proporciona un
constructor predeterminado, la clase derivada debe realizar una llamada
explícita a un constructor base mediante base.
Un constructor puede invocar a otro constructor en el mismo objeto mediante la palabra clave this. Al igual que base, this se puede utilizar con o sin parámetros y cualquier parámetro en el constructor está disponible como parámetro para this o como parte de una expresión. Por ejemplo, el segundo constructor del ejemplo anterior se puede rescribir con this:
C#
public Employee(int weeklySalary, int numberOfWeeks)
:
this(weeklySalary * numberOfWeeks)
{
}
El uso de la palabra clave this en el ejemplo
anterior hace que se llame a este constructor:
C#
public Employee(int annualSalary)
{
salary
= annualSalary;
}
Los constructores se pueden marcar como public, private, protected, internal o protectedinternal. Estos modificadores de acceso definen cómo los
usuarios de la clase pueden construir la clase. Un constructor se puede
declarar como estático mediante la palabra clave static. Se llama automáticamente a los constructores estáticos de forma
inmediata antes de que se tenga acceso a cualquier campo estático, y,
generalmente, se utilizan para inicializar los miembros de clase estáticos.
Propiedades
Las propiedades proporcionan la comodidad de utilizar miembros de datos
públicos sin los riesgos que implica el acceso no protegido y sin control ni
comprobación a los datos de un objeto. Esto se logra a través de los descriptores de acceso: métodos especiales que asignan y recuperan los valores del miembro de datos subyacente. El descriptor de acceso set permite asignar los miembros de datos y el descriptor de acceso get recupera los valores de los miembros de datos.
Este ejemplo muestra una clase Person con dos propiedades: Name (cadena) y Age (entero).
Ambas propiedades proporcionan descriptores de acceso get y set, por lo que se consideran propiedades de lectura y escritura.
C#
class Person
{
private string name = "N/A";
private int age = 0;
// Declare a Name property of type string:
public string Name
{
get
{
return name;
}
set
{
name = value;
}
}
// Declare an Age property of type int:
public int Age
{
get
{
return age;
}
set
{
age = value;
}
}
public override string ToString()
{
return "Name = " + Name + ", Age = " + Age;
}
}
class TestPerson
{
static void Main()
{
// Create a new Person object:
Person person = new Person();
// Print out the name and the age associated with the person:
Console.WriteLine("Person details - {0}", person);
// Set some values on the person object:
person.Name = "Joe";
person.Age = 99;
Console.WriteLine("Person details - {0}", person);
// Increment the Age property:
person.Age += 1;
Console.WriteLine("Person details - {0}", person);
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
/* Output:
Person details - Name = N/A, Age = 0
Person details - Name = Joe, Age = 99
Person details - Name = Joe, Age = 100
*/
En el ejemplo anterior, las propiedades Name y Age son public e incluyen un descriptor de acceso get y set. Esto permite que cualquier objeto lea y escriba estas propiedades. Sin embargo, a veces es conveniente excluir uno de los descriptores de acceso. Por ejemplo, al omitir el descriptor de acceso set, la propiedad pasa a ser de sólo lectura:
C#
public string Name
{
get
{
return name;
}
}
Opcionalmente, se puede exponer públicamente un descriptor de acceso pero
definir el otro como private o protected.
Una vez declaradas las propiedades, se pueden utilizar como si fueran campos de la clase. Esto permite una sintaxis muy natural, tanto para obtener como para establecer el valor de una propiedad, como se muestra en las siguientes instrucciones:
C#
person.Name = "Joe";
person.Age = 99;
Observe que, en un método set de una propiedad, se
dispone de una variable especial value.
Esta variable contiene el valor especificado por el usuario, por ejemplo:
Esta variable contiene el valor especificado por el usuario, por ejemplo:
C#
name = value;
Observe la sintaxis tan simple que se utiliza para incrementar la propiedad
Age de un objeto Person:
C#
person.Age += 1;
Si se utilizaron métodos set y get independientes para modelar las propiedades, el código equivalente tendría
el siguiente aspecto:
person.SetAge(person.GetAge() + 1);
En el siguiente ejemplo, el método ToString se reemplaza:
C#
public override string ToString()
{
return "Name = " + Name + ", Age = " + Age;
}
Observe que ToString no se utiliza explícitamente en el programa. Se invoca de forma predeterminada mediante las
llamadas WriteLine.
Colecciones Listas (List)
En muchas aplicaciones se desea poder crear y administrar grupos de objetos
relacionados. Existen dos formas de agrupar objetos: mediante la creación de
matrices de objetos y mediante la creación de colecciones de objetos.
Las matrices son muy útiles para crear y trabajar con un número fijo de objetos fuertemente tipados.
Las colecciones proporcionan un método más flexible para trabajar con grupos de objetos. A diferencia de las matrices, el grupo de objetos con el que trabaja puede aumentar y reducirse dinámicamente a medida que cambian las necesidades de la aplicación. Para algunas colecciones, puede asignar una clave a cualquier objeto que incluya en la colección para que pueda recuperar rápidamente el objeto con la clave asignada.
Una colección es una clase, de modo que antes de poder agregar elementos a una nueva colección, debe declararla.
Si su colección se limita a elementos de solo un tipo de datos, puede utilizar una de las clases en el espacio de nombres System.Collections.Generic. Una colección genérica cumple la seguridad de tipos para que ningún otro tipo de datos se pueda agregar a ella. Cuando recupera un elemento de una colección genérica, no tiene que determinar su tipo de datos ni convertirlo.
Los ejemplos de esta sección usan la clase genérica List<T>, que permite trabajar con una lista de objetos fuertemente tipados.
En el ejemplo siguiente se crea una lista de cadenas y a continuación se itera a través de las cadenas mediante una instrucción For Each… Next (Visual Basic) o foreach (C#).
C#
// Create a list of strings.
var salmons = new List<string>();
salmons.Add("chinook");
salmons.Add("coho");
salmons.Add("pink");
salmons.Add("sockeye");
// Iterate through the list.
foreach (var salmon in salmons)
{
Console.Write(salmon + " ");
}
// Output: chinook coho pink sockeye
Si el contenido de una colección se conoce de antemano, puede utilizar un inicializador de colección para inicializar la colección.
El ejemplo siguiente es igual al ejemplo anterior, excepto que se utiliza un inicializador de colección para agregar elementos a la colección.
C#
// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };
// Iterate through the list.
foreach (var salmon in salmons)
{
Console.Write(salmon + " ");
}
// Output: chinook coho pink sockeye
Puede utilizar una expresión For… Next (Visual Basic) o for (C#) en lugar de una instrucción For Each para recorrer en
iteración una colección. Esto se consigue al obtener acceso a los elementos de
la colección mediante el índice de posición. El índice de los elementos comienza en 0 y finaliza
en el número de elementos menos 1.
El ejemplo siguiente recorre en iteración los elementos de una colección utilizando For…Next en lugar de For Each.
C#
// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };
for (var index = 0; index < salmons.Count; index++)
{
Console.Write(salmons[index] + " ");
}
// Output: chinook coho pink sockeye
El ejemplo siguiente elimina un elemento de la colección especificando el
objeto que se va a eliminar.
C#
// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };
// Remove an element from the list by specifying
// the object.
salmons.Remove("coho");
// Iterate through the list.
foreach (var salmon in salmons)
{
Console.Write(salmon + " ");
}
// Output: chinook pink sockeye
El ejemplo siguiente elimina elementos de una lista genérica. En lugar de
una instrucción For Each, se utiliza una expresión For… Next (Visual Basic) o for (C#) que itera en orden descendente. Esto ese debe a que el método RemoveAt hace que los elementos que hay después del elemento eliminado tengan un
valor de índice más bajo.
C#
var numbers = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
// Remove odd numbers.
for (var index = numbers.Count - 1; index >= 0; index--)
{
if (numbers[index] % 2 == 1)
{
// Remove the element by specifying
// the zero-based index in the list.
numbers.RemoveAt(index);
}
}
// Iterate through the list.
// A lambda expression is placed in the ForEach method
// of the List(T) object.
numbers.ForEach(
number => Console.Write(number + " "));
// Output: 0 2 4 6 8
Para el tipo de elementos en List<T>, también puede definir su propia clase. En el ejemplo siguiente, la clase Galaxy utilizada por List<T> se define en el código.
C#
private void IterateThroughList()
{
var theGalaxies = new List<Galaxy>
{
new Galaxy() { Name="Tadpole", MegaLightYears=400},
new Galaxy() { Name="Pinwheel", MegaLightYears=25},
new Galaxy() { Name="Milky Way", MegaLightYears=0},
new Galaxy() { Name="Andromeda", MegaLightYears=3}
};
foreach (Galaxy theGalaxy in theGalaxies)
{
Console.WriteLine(theGalaxy.Name + " " + theGalaxy.MegaLightYears);
}
// Output:
// Tadpole 400
// Pinwheel 25
// Milky Way 0
// Andromeda 3
}
public class Galaxy
{
public string Name { get; set; }
public int MegaLightYears { get; set; }
}