Les collections

3. Manipuler des collections par du code

3.1 Déclarer une collection

Tous les contrôles conteneurs définissent automatiquement une collection. Mais en C#, la notion de collection est beaucoup plus vaste, et toutes les collections ne sont pas définies par des contrôles conteneurs. Il est donc possible de créer une collection uniquement par du code, et d'y regrouper des contrôles et, plus généralement, toutes sortes de données.

Je n'aborderai pas véritablement ces techniques autrement que par la bande. Sachez simplement que si les ensembles définis par des contrôles conteneurs sont, comme on vient de le voir, des collections au sens général du terme, lorsqu'on va créer une collection par du code, on utilisera plutôt une des sous-classes de collections : les tableaux, bien sûr, mais aussi (et surtout ?), les list (listes).

3.2 Ajouter des éléments

L'instruction qui permet d'ajouter un élément à une collection, est la méthode Add. Celle-ci réclame un argument unique, à savoir le nom du contrôle qui doit être ajouté à la collection. On aura par exemple :

ensemble.Add(Textbox1)
ensemble.Add(Textbox2)
ensemble.Add(Label5)
etc.

3.3 Retirer des éléments

3.3.1 Les retirer un par un

Pour retirer un membre d'une collection, il existe deux méthodes :

• Remove qui demande en argument le nom du membre.
• RemoveAt qui demande en argument l'indice du membre.

Ainsi, pour retirer boutonAnnuler de la collection ensemble, dont il est le membre d'indice 4, on n'a que l'embarras du choix entre :

ensemble.Remove(boutonAnnuler)

et

ensemble.RemoveAt(4)

On choisira, bien sûr, ce qui nous arrange en fonction du contexte. Qu'importe le flacon pourvu qu'on ait l'ivresse.

3.3.2 Les retirer tous d'un coup

S'il s'agit de vider une collection, il y a un moyen beaucoup plus simple que de faire une boucle pour supprimer les membres un par un : la redoutable et dévastratrice méthode Clear. Pour purger ensemble de la totalité de son contenu, il suffira donc d'écrire :

Ensemble.Clear()

Remarque vertigineuse
Supprimer des éléments d'une collection au sein d'une boucle peut entraîner de redoutables migraines. En effet, C# gérant automatiquement les indices d'une collection, toute supression d'élément conduit à chaque fois à diminuer le plus grand indice de 1.
Si l'on n'y prend pas garde, cela fera donc planter une boucle for ou foreach, qui commençait « bêtement » à l'indice zéro pour finir au plus grand indice de la collection.
Pour éviter le problème, deux solutions :
– ne pas supprimer d'éléments au sein d'une boucle
– si on est obligé de supprimer des éléments au sein d'une boucle, construire la boucle à l'envers, en balayant à partir du dernier indice, afin que celui-ci « recule » toujours vers des éléments existants... ou supprimer toujours l'élément d'indice zéro, dont est certain qu'il existe.

4. Associer des événements à une procédure par du code

Tout le monde est encore avec moi ? Alors asseyez-vous confortablement, attachez bien vos ceintures, on va passer à la vitesse supérieure.

4.1 Avantages et limites de la méthode manuelle

Jusqu'ici, nous n'avons guère eu à réfléchir sur la manière dont nous pouvions associer la survenue d'un événement donné sur un contrôle à une procédure : la plupart du temps, cette association était faite automatiquement ou semi-automatiquement. Au mieux, il suffisait de faire un doucle-clic sur le contrôle pour voir apparaître la procédure avec le bon événement (celui qui, par défaut, est associé à la classe du contrôle). Au pire, il fallait d'abord passer par la fenêtre des événements pour préciser lequel on souhaitait gérer. Et au pire du pire, quand par exemple on avait créé une procédure commune à plusieurs événements, il fallait choisir, dans cette fenêtre des événements, la bonne procédure dans la liste déroulante pour chaque contrôle concerné.

Tout cela fonctionne à merveille... tant qu'on ne veut associer à une même procédure que deux, trois ou quatre événements. Mais imaginons une situation où il faille en associer plusieurs dizaines ou centaines, et on voit que le paradis se changera rapidement en enfer.

Or, depuis que nous savons ce qu'est une collection, nous savons aussi qu'il est possible de parcourir ces dizaines, ou ces centaines de contrôles, par une boucle. Jusque-là, celles-ci ne nous ont servi qu'à tripatouiller les propriétés de nos contrôles. Mais, vous me voyez venir avec mes gros sabots, il est tout à fait possible de faire par du code ce que nous faisions jusque là par des clics de souris – qui, en fait, écrivaient du code caché. Autrement dit, il est tout à fait possible, par des instructions, de rattacher des événements à des procédures ou, inversement, de détacher des événements de procédures. Wow.

4.2 Branchements en cours d'exécution

Pour accomplir cet exploit, il va falloir créer (instancier) un nouvel objet, EventHandler, le « gestionnaire d'événements ». Ainsi, pour qu'un clic sur boutonOK déclenche la procédure appelée validation, on écrira :

boutonOK.Click += new EventHandler(validation);

Décryptage : on a instancié un nouvel objet, de la classe « gestionnaire d'événements », qu'on a affecté à l'événement boutonOK.Clic, en précisant qu'il fallait effectuer le branchement sur la procédure validation. Au fond, ce n'est pas si compliqué.

Du coup, et tant qu'on y est, vous avez tout de suite deviné quelle instruction permet, inversement, de « débrancher » en cours d'exécution un événement donné d'une procédure. Là, même pas besoin d'instancier un nouvel EventHandler, il suffit de dire en quelque sorte qu'on retire la procédure de l'événement :

boutonOK.Click -= validation;

Imaginons ainsi que ma collection ensemble soit composée d'une série de boutons, et que je veuille brancher le clic sur tous ces boutons sur une procédure appelée shiva. Cela donnera le code suivant :

foreach (Button monBouton in ensemble.Controls)
{
   monBouton.Click += new EventHandler(shiva);
}

Une question simple, mais capitale est celle de savoir à quel endroit du code il faut procéder à de tels branchements, individuels ou en série. Cela va sans dire (mais cela va mieux en le disant), elle doit obligatoirement être exécutée avant qu'on ait besoin des effets du branchement (on branche l'ampoule avant d'allumer la lumière, sinon on ne s'étonne pas que l'interrupteur ne fonctionne pas...). Autrement dit, les instructions qui procèdent aux branchements d'événements doivent toujours être placées dans une procédure qui sera exécutée avant les événements concernés. A priori, et sauf raison contraire (nous en verrons une excellente très bientôt), une solution pratique est de placer cette instruction quelque part dans la procédure Form.Load, dont on sait qu'elle se déclenchera dès le lancement de l'application.

Remarque « le fil rouge sur le bouton rouge »
Lorsqu'on branche un événement sur une procédure, il est essentiel de s'assurer que cette procédure a bien, au départ, été créée pour gérer le même type d'événements que celui qu'on est en train de brancher. En effet, dans le cas contraire, il risque d'y avoir non-correspondance entre le type du paramètre en entrée e attendu et celui qui aura été déclaré... et par conséquent, paf, une erreur.

4.3 Un indice pour identifier le coupable

Si nous avons, à la main ou par une boucle, branché plusieurs contrôles différents sur une même procédure (par exemple, des tas de boutonMachin.click vers shiva), il se posera évidemment le problème, à chaque exécution de shiva, de savoir lequel, parmi tous ces boutons, vient de recevoir le clic.

Nous savons depuis longtemps récupérer son nom : puisque la variable sender pointe sur le contrôle en question, son nom nous est donné par la propriété sender.Name.

Cela est bel et bon, sauf que bien souvent, son nom ne nous est guère utile, alors qu'en revanche, on aurait bien davantage besoin de connaître son indice dans la collection dont il fait partie.

Pas de problème. La méthode IndexOf permet précisément de récupérer l'indice d'un élément dans une collection à partir de son nom. Illustration :

private void shiva(object sender, EventArgs e)
{
   Control leBouton = (Control)sender;
   int indice = ensemble.Controls.IndexOf(leBouton);
   string texte = Convert.ToString(indice);
   MessageBox.Show("Vous avez cliqué sur le bouton d'indice " + texte);
}

Bon, et si on se faisait quelques exos histoire de faire infuser tout cela ?