C# 2.0 : Les class "Generic" : Ce qu’elles peuvent vous apporter

On a écrit beaucoup de chose sur les génériques et comme beaucoup d’autres
techniques, ils ont leurs défenseurs et leurs détracteurs. D’un coté il y a
les puristes de l’objet qui disent qu’ils ne respectent pas les règles du jeu
OO, mais de l’autre il y a les habitués des « Template » qui eux les trouvent
indispensable. Que peut-on donc nous en penser.

Personnellement j’essaye de rester pragmatique. J’y ai donc jeté un œil
attentif et j’ai essayé de voir comment je pouvais améliorer ma vie de
développeur avec ces class génériques.

<B>Introduction</b>

Les class génériques sont des squelettes de code ou le paramètre est un
type. Supposons que vous développiez une class contenant une liste d’entier.
Il serait pratique de pouvoir utiliser le même code pour définir une liste de
nombre décimaux.

Avec les génériques c’est plutôt facile. On commence par définir la classe
générique.

public class List<T>
{
private ArrayList list = new ArrayList();

public int Add(T input)
{
return this.list.Add(input);
}
public T this[int index]
{
get { return (T)list[index]; }
set { list[index] = value;}
}

}

Et puis pour l’utiliser avec un entier ou un nombre décimal on fait :

List<int> listentiers = new List<int>();
List<double> listdecimaux = new List<double>();

listentiers.Add(12);
listdecimaux.Add(12.3);

C’est aussi facile que ca.

Le paramètre <T> ne se limite pas, comme ici, à l’utilisation de type
simple. Notre générique peut être utilisé avec des types plus complexes tels
qu’une class ou une structure.

Voyons maintenant comment on peut en tirer profité dans notre vie de tous
les jours.

<b>Utilisation des classes génériques</B>
Lorsque j’ai besoin de créer une class qui représente une collection
d’entités, plusieurs choix s’offre à moi :

1. J’utilise une collection non typé comme ancêtre. L’inconvénient ici c’est
que la méthode me permettant d’ajouter des entités ne sera pas typée. Elle me
permettra d’ajouter des entités de n’importe qu’elle type. Bien sur je peux
faire des vérifications avant d’insérer l’élément et bien sur je peux ajouter
des méthodes d’ajout typé. Mais est-ce vraiment le plus pratique des moyens
?...
2. Je développe une class spécifique en incluant l’implémentation
d’interface de collection tels que « IEnumerable », « IList »… Je contrôle
donc tout l’implémentation ici mais je dois écrire pas mal de code.

Il existe d’autres moyens tels que créée sa propre class de collection
héritant de class comme « CollectionBase » et de faire hériter toutes vos
collections de cette nouvelle class… Mais ces moyens ne sont qu’une
combinaison des deux cas précédents.

Voyons comment les classes génériques peuvent nous faciliter la vie lors de
la création de collection typé.

Commençons par regarder quelques une des class génériques qui sont mises à
notre disposition avec le Framework .NET 2.0. On peut y voir :
• List<T>
• Dictionary<TKey,TValue>
• LinkedList<T>
• Queue<T>
• SortedDictionary<TKey,TValue>
• Stack<T>
• …

Concentrons nous sur List<T> pour construire une collection typé d’entité.
Soit « Personne » cette entité :
class Personne
{
private string prenom;
public string Prenom
{
get { return prenom; }
set { prenom = value; }
}
private string nomdefamille;
public string Nomdefamille
{
get { return nomdefamille; }
set { nomdefamille = value; }
}
}

Créons notre liste typé.

List<Personne> personnes = new List<Personne>();

Ajoutons un élément à cette liste :

personnes.Add(new Personne());
personnes[0].Prenom = "Albert";
personnes[0].Nomdefamille = "Einstein";

Pratique non ? Et on peut bien sur faire la même chose pour une pile, une
queue, une liste ordonnée…

Lorsque l’on veut parcourir une liste non typé en utilisant « foreach() » il
suffit que notre la liste implémente l’interface « IEnumerable » qui est non
typé.

Arraylist list = new ArrayList();
foreach (int i in list){...}
foreach (object o in list){...}
foreach (mauvaisobject o in list){...}

Fonctionnera parfaitement à la compilation…Mais lors de l’exécution on peut
avoir des surprises…

Pour remédier à ce problème, nous avons maintenant à notre disposition
l’interface « IEnumerable<> » Chaque class générique qui implémente cette
interface devient parcourable de manière typé !

//Fonctionne
foreach (Personne p in personnes){...}
//Erreur de compilation
foreach (int i in personnes){...}

Ce qui nous permet d’être certain lors de la compilation du type qui se
trouve réellement dans la liste.
Je ne sais pas pour vous mais je pense que rien que ca va me permettre de
rendre mon code plus solide.

Dans le namespace « System.Collection.Generic » nous pouvons aussi trouver
la version générique des interfaces suivantes :
• ICollection<>
• IDictionary<>
• IList<>
• IComparer<>
• IEnumerator<>
• IEqualityComparer<>

<b>Pour conclure</B>

Après avoir passé quelque temps sur les classes génériques je peux dire
maintenant qu’elles me feront gagner énormément de temps.
D’abord parce que le Framework contient certaines des classes du namespace
« System.Collection » implémenté avec des génériques me donnant ainsi un
moyen rapide et facile de les utiliser. Ensuite parce que je pense qu’une
bonne utilisation des classes génériques peut m’amener à un meilleur niveau
de réutilisation de code.