Types génériques

La création de types génériques

Un type générique est défini dans la déclaration de la classe en plaçant le paramètre T. Ce paramètre spécifie que le type sera choisi par le consommateur de la classe. Cela peut être un type valeur ou un type référence.

Créez une nouvelle classe ReportChangeList<T> dans le dossier Library du projet :

public class ReportChangeList<T> 
{ 
} 

Le paramètre T accepte un type qui sera spécifié au moment de l’instanciation :

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

Un type générique peut également faire référence à plusieurs classes :

public class ClasseGenerique<T, U> 

Les types génériques peuvent être surchargés tant que le nombre de leurs paramètres de type n’est pas identique :

public class ClasseGenerique<T> 
public class ClasseGenerique<T, U> 

Si deux types génériques ont le même nom et le même nombre de paramètres de type, le compilateur lèvera une erreur :

public class ClasseGenerique<T> 
public class ClasseGenerique<U>        // Non autorisé 

Les attributs génériques...

Les contraintes de type

Comme vu dans les accesseurs, l’interface IReportChange est utilisée pour accéder à la propriété HasChanged des éléments de la liste. Cela signifie que les éléments ajoutés doivent obligatoirement implémenter l’interface. Pour limiter les types qui pourront se substituer au paramètre générique T, des contraintes peuvent être appliquées.

Voici les contraintes existantes :

Ajoutez une contrainte sur l’interface IReportChange sur la classe générique ReportChangeList :

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

Les contraintes sont appliquées sur tous les paramètres de type définis, que ce soit dans les méthodes ou dans la définition de type.

Les contraintes de type peuvent également être définies au niveau des méthodes :

public void MaMethode<T>()...

Les interfaces génériques

Comme pour les listes, il serait intéressant de pouvoir effectuer une boucle foreach sur les éléments de notre type générique. Pour cela, il suffit d’implémenter l’interface générique IEnumerable<T> :

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

Cette interface générique se comporte comme une interface classique, elle contient les signatures des membres requis pour son implémentation et ceux-ci peuvent utiliser la classe générique comme référence.

Ajoutez les membres GetEnumerator() et IEnumerable.GetEnumerator() suivants pour implémenter l’interface dans la classe générique ReportChangeList :

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

L’implémentation d’un énumérateur consiste à effectuer une boucle sur les éléments de la liste et à retourner chacun d’eux à l’appelant. Le mot-clé yield return permet de faire un retour à l’appelant avec la valeur à retourner en fonction de la précédente valeur retournée. L’état de la méthode est maintenu de telle manière qu’elle peut continuer son exécution au prochain appel. La durée de vie de cet état est liée à l’énumérateur, l’état de la méthode est supprimé lorsque l’énumération est terminée.

La création de méthodes génériques

La déclaration des membres d’une classe générique se fait de la même manière que les membres de classes classiques avec en plus l’utilisation du paramètre T pour spécifier le type d’un paramètre qui est autorisé.

Ajoutez la méthode Add à la classe ReportChangeList :

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

La méthode Add prend en paramètre un type répondant aux contraintes de la classe. L’objet passé en paramètre à la méthode implémente donc l’interface IReportChange et il peut être converti dans le type de l’interface, ce qui permet à l’objet de type ReportChangeList de s’abonner à l’événement Changed de l’objet passé en paramètre avant de l’ajouter à la liste children.

La liste va contenir de nombreux éléments et il faut donc implémenter une technique plus élaborée pour les différencier et assurer l’unicité de ceux-ci. Nous allons créer un indexeur basé sur une clé de type...

return default(T); 

class Parent<T> 
{ } 
class Enfant<T> : Parent<T> 
{ } 

class Enfant : Parent<int> 
{ } 

class Enfant<T, T2> : Parent<T> 
{ } 

class Enfant<Tx, T2> : Parent<Tx> 
{ }