miércoles, 9 de abril de 2014

Contructores, propiedades y coleccionde listas



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:

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; }
}

1 comentario:

  1. como seria en visual basic
    public class Galaxy
    {
    public string Name { get; set; }
    public int MegaLightYears { get; set; }
    }




    var theGalaxies = new List
    {
    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}
    };

    ResponderEliminar