Tipos genéricos

La creación de tipos genéricos

Un tipo genérico se define en la declaración de la clase, indicando el parámetro T. Este parámetro especifica que el tipo lo elegirá el consumidor de la clase. Puede ser un tipo por valor o por referencia.

Cree una nueva clase ReportChangeList<T> en la carpeta Library del proyecto:

public class ReportChangeList<T>  
{  
} 

El parámetro T acepta un tipo, que se especificará durante la instanciación:

ReportChangeList<int> Ex1 = new ReportChangeList<int>();  
ReportChangeList<Object> Ex2 = new ReportChangeList<Object>(); 

Un tipo genérico también puede hacer referencia a varias clases:

public class ClaseGenerica<T, U> 

Los tipos genéricos se pueden sobrecargar, siempre que el número de sus parámetros de tipo no sea idéntico:

public class ClaseGenerica<T>  
public class ClaseGenerica<T, U> 

Si dos tipos genéricos tienen el mismo nombre y número de parámetros de tipo, el compilador devolverá un error:

public class ClaseGenerica<T>  
public class ClaseGenerica<U>         // No autorizado 

Los atributos genéricos también pueden crearse siguiendo los mismos principios:

public class AtributoGenerico<T> : Atributo { } 

El atributo podrá englobar...

public class ReportChangeList<T>: IReportChildrenChange where T:  
IReportChange 

public void MiMetodo<T>() where T: class  
{ } 

Las interfaces genéricas

Como para las listas, sería interesante poder hacer un bucle foreach sobre los elementos de nuestro tipo genérico. Para esto es suficiente con implementar la interfaz genérica IEnumerable<T>:

public class ReportChangeList<T>: IReportChildrenChange,   
IEnumerable<T> where T: IReportChange 

Esta interfaz genérica se comporta como una interfaz clásica, contiene las declaraciones de los miembros necesarios para su implementación y se puede utilizar la clase genérica como referencia.

Añada los miembros GetEnumerator() e IEnumerable.GetEnumerator() siguientes, para implementar la interfaz en la clase genérica ReportChangeList: 

public IEnumerator<T> GetEnumerator()  
{  
    for (int i = 0; i < this.children.Count; i++)  
    {  
        yield return this.children[i];  
    }  
}  
IEnumerator IEnumerable.GetEnumerator()  
{  
    return GetEnumerator();  
} 

La implementación de un enumerador consiste en hacer un bucle sobre los elementos de la lista y devolver cada uno de ellos a la llamada. La palabra clave yield return permite hacer un retorno a la llamada con el valor a devolver en función del valor anterior devuelto. El estado del método se mantiene de tal manera que puede continuar su ejecución hasta la siguiente llamada. El tiempo de vida de este estado está relacionado con el enumerador, el estado del método se elimina cuando la enumeración termina.

La creación de métodos genéricos

La declaración de los miembros de una clase genérica se hace de la misma manera que los miembros de clases clásicos. Además es posible usar el parámetro T para especificar el tipo de parámetro autorizado.

Añada el método Add a la clase ReportChangeList:

public void Add(T Child)  
{  
    IReportChange child = (IReportChange)Child;  
    child.Changed += new EventHandler(ChildChanged);  
    this.children.Add(Child);  
} 

El método Add recibe como parámetro un tipo que cumple las restricciones de la clase. El objeto que se pasa como parámetro al método implementa, por tanto, la interfaz IReportChange y se puede convertir al tipo de la interfaz, lo que permite al objeto de tipo ReportChangeList suscribirse al evento Changed del objeto que se pasa como parámetro antes de añadirlo a la lista children.

La lista va a contener muchos elementos, por lo que hay que implementar una técnica más elaborada para diferenciarlos y asegurar su unicidad. Vamos a agregar un indexador base a una clave de tipo string. En primer lugar, esto implica crear una interfaz IKey en la carpeta Library:

public interfaz IKey  
{  
    string Key  
    {  
       ...

return default(T); 

class Padre<T>  
{ }  
class Hija<T>: Padre<T>  
{ } 

class Hija: Padre<int>  
{ } 

class Hija<T, T2>: Padre<T>  
{ } 

class Hija<Tx, T2>: Padre<Tx>  
{ }