Generics en C#

Il paraît que C# fait un tas de choses merveilleuses au niveau orienté-objet. Entre autres choses, il est capable de travailler avec des générics (le plus souvent des collections d'élements de type inconnu, plus ou moins précisé).

Utiliser les types génériques déjà fournis

C# propose déjà la plupart des collections génériques dont vous aurez besoin dans des programmes et algorithmes habituels.

List<T>

Ce type fournit une liste chaînée. T est une classe héritant d'Object (donc, n'importe quelle classe). Si T implémente ISortable, alors la List<t>sera triable.
Pour les méthodes, elles sont très explicites. Un exemple :

List<String> s = new List<String>(30);// ce constructeur initialise une liste à la contenance de 30 élements, par défaut
s.Add("toto"); // ajoute la chaîne toto, un objet sans référence autre que dans la liste, à s.
String st = "titi";
s.Add(st); // l'ajout se fait par référence, non pas par copie. Si on altère st, le contenu de la liste sera altéré
s.Add(1,"Ga"); // la chaîne Ga est ajoutée entre toto et titi
Console.WriteLine(s.Contains("Bu")); // affiche false
Console.WriteLine(s.Contains("Ga")); // affiche true
s.ExcessTrim() ;     // libère la mémoire non-utilisée par la liste.
                     // Penser à le faire une fois qu'elle est remplie,
                     // Il vaut mieux allouer en excès puis libérer la mémoire
                     // que devoir réallouer de la mémoire à chaque fois qu'on ajoute un élement
                     // (sauf contraintes particulières, du type systèmes embarqués)
Console.WriteLine(s.Count) ; // affiche 3
s.Clear(); //vide s
Console.WriteLine(s.Count) ; // affiche 0

Note : on peut aussi parcourir un dictionnaire avec foreach

foreach (T element in maListeGenerique)
{
    element.Squeeze();
}

Dictionary<T1,T2>

Ce type est le type Dictionnaire habituel : à une clé de type T1, on associe une valeur de type T2. Les clés de type T1 ne peuvent être dupliquées (i.e., deux clés ne peuvent être égales). Si on tente d'insérer deux élements avec la même clé, alors on une exception ArgumentException sera levée. A vous de la gérer dans vos programmes. Les méthodes sont encore une fois très explicites, je vous renvoie à la documentation MSDN pour quelques infos. On peut trier un Dictionary selon ses clés ou selon ses valeurs, pourvu que les clés ou les valeurs implément ISortable. Il suffira alors d'appeller monDictionnaire.Keys.Sort() ou monDictionnaire.Values.Sort() pour trier la collection (les joies de l'accès par référence).

Implémenter son propre type générique

Ici, on va supposer qu'on a besoin d'implémenter une pile (LIFO, donc, le dernier élement entré sera le premier à sortir) générique. Ne me demandez pas quel intérêt il y a à cela, à vous de le trouver ;-)

Pour ce faire, comme on ne cherche pas forcément la performance, on va simplement utiliser une liste en interne, que l'on va modifier. Notre pile pourra être énumérée, c'est à dire qu'on pourra la parcourir avec un foreach (qui poppera une valeur hors de la liste et la renverra).

namespace MesExperimentations{
  public class MaStack<T> : IEnumerable
  {
   private List<T> pListeInterne;
   public MaStack()
   {
    pListeInterne = new List<T>();
   }

   public MaStack(int capacity)
   {
    pListeInterne = new List<T>(capacity);
   }

   public T Pop()
   {
    T element = maListe[maListe.Count-1];
    maListe.RemoveAt(maListe.Count-1); // retire le dernier element de la liste
    return element;
   }

   public void Push(T element)
   {
    maListe.Insert(maListe.Count,element); // insère l'élement au bout de la liste
   }
   // ceci est la méthode à implémenter pour IEnumerable
   public IEnumerator<T> GetEnumerator()
   {
    int taille = maListe.Count;
    while (taille>=0)
    {
         taille --;
         yield return maListe[taille];
         // un raccourci de C# pour éviter une syntaxe plus lourde
         // le mot yield est un mot magique pour l'énumération.
         // il permet de faire des "return multiples" en un seul bloc de code,
         // sans devoir maintenir de variable globale
    }
   }
  }
}

Spécifier des contraintes sur T

Dans certains cas, faire une collection 100% générique n'est pas une bonne idée. Par exemple, on peut imaginer une liste qui se trie automatiquement à l'insertion. Donc, son type T devra implémenter ISortable. Je ne vais pas l'implémenter ici, je vous laisse le faire.

La première ligne de la classe sera :

public class ListeTriee<T> : List<T> where T: ISortable

Ici, la classe ListeTriee étend la classe List mais impose que le type T implémente l'interface ISortable (celle qui permet de trier).

Un dernier mot

Pour aller plus loin et plus en profondeur, comme toujours, rendez-vous sur MSDN library et faites des recherches sur Generics.