Définition des délégués sous .NET/C#

Mise à jour, déménagement de tout le contenu vers le site:
http://www.while-true-do.com

Les articles ont été rénovés et de nouveaux ont été ajoutés.

1. Qu'est ce qu'un délégué?

Les délégués du C# sont équivalents aux pointeurs de fonction du C/C++ mais en plus sécurisé (type-safe). En simplifiant, on peut dire qu’un délégué est un pointeur vers une méthode mais c’est bien plus que cela.

Un délégué est un intermédiaire entre un émetteur et un récepteur, il permet d’établir un contrat entre eux. C’est un moyen de communication entre objets qui ne se connaissent pas forcément. Les délégués sont très utilisés dans l’environnement .NET, notamment le mécanisme de gestion des évènements qui est directement basé sur les délégués ; un évènement est d’ailleurs un délégué spécialisé.

La notion de délégué pourrait être comparé à celle d’interface puisque une interface est aussi un contrat entre classes sauf qu’un délégué n’établit son contrat qu’avec une méthode et non une classe. En quoi consiste le contrat d’un délégué? Il consiste lors de la déclaration de celui-ci à spécifier complètement une méthode: ses paramètres, leur nombre, leur type et le type de retour de la méthode.

2. Quel est l’intérêt d’utiliser un délégué ?
L’intérêt des délégués n’est pas forcément visible au premier abord. Cependant, ils répondent à un problème récurrent en programmation : Fournir un traitement via une méthode à un objet qui l’exécutera plus tard (traitement asynchrone), c'est-à-dire que l’objet appellera ce code au bon moment et ce sans forcément le connaître. Par exemple, une application exécute un objet chargé de gérer des communications via le réseau utilisera un délégué pour signaler qu’une donnée vient d’arriver et est disponible.

 

Ce mécanisme que les délégués utilisent de type « rappelle moi plus tard » (système de rappel, callback en Anglais) permet de gérer aisément les traitements asynchrones mais offre aussi d’autres avantages. Dans l’exemple précédent, la classe communication ne connaît rien de l’application qui l’utilise, le code de cette classe est indépendant et réutilisable dans d’autres situations sans aucune modification. De manière générale, l’utilisation des délégués permet de créer des classes, des contrôles ou composants utilisateurs indépendants les uns des autres (dit à couplage faible) ce qui facilite la réutilisation du code et tout ce qui en découle : maintenance, évolution & publication.

3. Utilisation d’un délégué ; exemple
La classe communication est chargée de gérer les communications réseaux, d’envoyer et de recevoir des données. La réception des données est indépendante du fonctionnement de l’objet, elle ne dépend que des émetteurs. Elle sera gérée par un délégué qui sera associé à une méthode dans l’application. Cette méthode affichera la donnée reçue.

Un délégué est un type, une signature de méthode, qu’il faut définir. Utiliser un délégué nécessite de déclarer une variable du type du délégué à utiliser. Le délégué déclaré ci-dessous défini une signature de méthode appelée DataReceived, pleinement précisée : la méthode comporte un paramètre de type chaîne de caractères, la valeur de retour est de type entier.

// définition d’un type délégué
delegate int DataReceivedHanlder(data);

// le délégué, initialisé à null  
DataReceivedHandler dataReceivedHandler=null;

L’utilisation d’un délégué passe par plusieurs phases : la connexion ou l’abonnement, le déclenchement puis la notification. L’abonnement consiste à instancier le délégué et à le relier à une méthode dans la classe qui utilise l’objet ayant le délégué.

// instancie l'objet pour communiquer
comm= new Communication();

// instancie le délégué et le relie à une méthode de l’application
comm.dataReceivedHandler= new Communication.DataReceivedHandler(this.DonneeRecue);

Le déclenchement du délégué consiste à l’appeler comme un simple appel de méthode lorsque c’est nécessaire. 

// appel délégué pour signaler présence donnée recue
if( dataReceivedHandler != null)  

// appel si délégué est connecté
dataReceivedHandler(data);

La notification est le fait que le délégué déclenche automatiquement lorsqu’il est appelé la méthode associée dans l’application.

//-----------------------------------------------------------
// déclenché par le délégué lorsque une donnée est recue
private void DonneeRecue(string data)
{ 
    // affiche le message recu 
    MessageBox.Show("donnée recue: "+data);
}

Le délégué a fait son travail d’intermédiaire, il relaye la notification à la méthode associé dans l’application.

4. Code de l’exemple Communication commenté
Ci-dessous, se trouve les extraits de codes principaux utilisé pour expliquer le fonctionnement des délégués.

Classe communication

//-----------------------------------------------------------
public class Communication
{  
       // déclaration type délégué  
       public delegate int DataReceivedHandler(string data);

       // variable du type délégué donnée recue 
       public DataReceivedHandler dataReceivedHandler=null;

       // ...

       //----------------------------------------------------------- 
       // traitement d'attente en réception des données 
       // effectué dans une boucle, exécuté par un thread 
       public void RunReceptionData() 
       { 
             string data= null;

             // boucle d'attente 
             while(true) 
             { 
                    // donnée en reception 
                    // ... remplir variable data 

                    // appel délégué pour signaler présence donnée recue 
                    if( dataReceivedHandler != null) 
                           dataReceivedHandler(data); 

                    // suite traitement ... 
            } 
       } 
}

Application principale:

//-----------------------------------------------------------
private void Form1_Load(object sender, System.EventArgs e)
{ 
       // instancie l'objet pour communiquer 
       comm= new Communication(); 

       // instancie le délégué 
       comm.dataReceivedHandler= new Communication.DataReceivedHandler(this.DonneeRecue);
}

//-----------------------------------------------------------
// déclenché par le délégué lorsque une donnée est recue
private void DonneeRecue(string data)
{
       // affiche le message recu 
       MessageBox.Show("donnée recue: "+data);                    
}

4. Bibliographie
C# : introduction aux délégués sur JDN développeurs publié le 16 fev 2005 , 1 page
Par Xavier Borderie
Présente ce que sont les délégués de manière générale
http://developpeur.journaldunet.com/tutoriel/csharp/050216-csharp-delegate-1.shtml

« Un évènement à ne pas oublier »
Un article très intéressant qui explique de manièe claire ce que sont les délégués et les évènements en C#
Par Eric Gunnerson de Microsoft.
http://msdn.microsoft.com/library/fre/default.asp?url=/library/FRE/dncscol/html/csharp04192001.asp

MSDN Les délégués, documentation technique , en français
chap 15, 15.1, 15.2 et 15.3
http://msdn.microsoft.com/library/fre/default.asp?url=/library/fre/csspec/html/vclrfcsharpspec_15.asp

C# versus Java
Article complet qui compare entre eux les caractéristiques des langages C# etJava
La partie B.14 sur les évènements aborde les délégués.
Par Alain Vizzini
http://alain.vizzini.free.fr/localcopy/csvsjava.htm