Document sans titre

Délégués

Principe

Les délégués en C#, ou signaux en C++/QT, ou GTK sont des notions ajoutées à la programmation objet afin d'aider le développeur à dialoguer entre les différents objets.

Fonctionnement

Afin d'éclaircir vos idées, prenons un exemple simple:
Vous créez une application Windows. Visual Studio génère donc la classe Form1. A partir de cette classe vous instanciez une classe fille que vous avez créé afin de créer l'objet fille1. Cet objet fille1 est assujetti à un évenement extérieur: click sur un bouton, réception d'un message via un socket ou autre..
La notion de délégué permet alors que l'objet fille1 puisse envoyer un signal à sa classe mère, Form1 dans notre exemple.

Exemple

Créons une application Windows, par défaut la classe de départ est Form1.
Ajoutons un nouvel élément, un forumailre Windows qui aura par défaut le nom Form2.
Enfin ajoutons un bouton à Form2
Dans Form2 ajoutons un délégué qui nous servira à définir l'évenement ButtonClick.
Ce délégué, étant déclaré entre le nom de l'espace et le nom de la classe, sera commun à tout le projet.

namespace délégué
{
     public delegate void EventHandler();
      /// <summary>
      /// Description résumée de Form2.
      /// <summary>
     public class Form2 : System.Windows.Forms.Form
     {

Déclarons maintenant l'évenement ButtonCick:
dans la classe Form2:

          public class Form2 : System.Windows.Forms.Form
          {
          public event EventHandler ButtonClick;

On double-clique sur de boutonForm2 pour y ajouter un code qui sera l'exécution de l'évenement ButtonClick déclaré précédemment:

          private void button1_Click(object sender, System.EventArgs e)
          {
               ButtonClick();
          }

Maintenant que nous pouvons créer un événement à partir de la classe Form2. Occupons nous de la classe Form1 afin qu'elle puisse dabord ouvrir le formulaire Form2 et intercepter ses événements:
Commençons par instancier le formulaire Form2 à travers la variable f2:

          public class Form1 : System.Windows.Forms.Form
          {
          private Form2 f2;

Maintenant affichons le fomulaire Form2:

          private void Form1_Load(object sender, System.EventArgs e)
          {
          f2 = new Form2();
          f2.Show();
          }

Le forulaire Form2 devrait donc se lancer à l'ouverture de Form1.
Il fait que maintenant Form1 intercepte l'événement ButtonClick de Form2 afin de lancer la méthode methode:

          private void Form1_Load(object sender, System.EventArgs e)
          {
          f2 = new Form2();
          f2.Show();
          f2.ButtonClick += new EventHandler(this.methode);
          }

On remarquera que l'interception est déclarée via le délégué EventHandler que nous avons déclaré précédemment.
Il ne reste plus qu'à créer une méthode methode qui nous affichera un message "coucou" pour nous prouver que l'événement a été intercepté: Comme tout autre événement nous pouvons transmettre une variable, pour communiquer un entier le délégué se

          private void methode()
          {
          MessageBox.Show("coucou");
          }

Notre application est maintenant terminée. Le programme executé ouvre deux forumaire Form1 et Form2. Sur Form2 se trouvera un bouton qui par un click ouvrira un dialogue ouvert par Form1.

Cet exemple assez simple nous montre un délégué sans variable, mais il est possible de lui en attribuer afin de transmettre des valeurs, par exemple:

namespace délégué
{
     public delegate void EventHandler(int,int);
      /// <summary>
      /// Description résumée de Form2.
      /// <summary>
     public class Form2 : System.Windows.Forms.Form
     {

Ce délégué transmettra deux entiers, il faut ensuite que la méthode "interceptrice" ait deux entiers en paramètre.