Le Langage C# : Délégués et événements (cours 17)

0
Le Langage C#

Définition 

Un délégué est un type (référence) qui permet de stocker des références à des fonctions. Il est utilisé pour encapsuler une méthode d’une signature spécifique et la passer en paramètre.
Le délégué délègue la méthode associée pour réaliser son travail.
Les délégués sont utiles pour la gestion des événements. Ils sont déclarés de manière similaire aux
fonctions :
• Mot-clé delegate,
• Sans corps de fonction,
• Un type de retour et une liste de paramètres.
On peut déclarer une variable avec le type délégué. Cette variable sera initialisée comme une référence à toute fonction qui a le même type de retour et la même liste de paramètres que le délégué. On peut alors appeler cette fonction en utilisant la variable de type délégué comme s’il s’agissait d’une fonction.

Déclaration des délégués

Syntaxe : [modifiers] delegate result identifier ([parameters])
où:
modifiers : est une combinaison valide de modificateurs d’accès plus le modificateur new.
Result : est le type du délégué qui est le même que celui de la méthode encapsulée.
Identifier : est le nom du délégué.
Parameters : est une liste optionnelle de paramètres

Création du délégué

La création se fait selon les étapes suivantes :

1. Déclarer le délégué (dans un namespace ou une classe). Par exemple:

delegate void MonDelegue (object o1, object o2);

2. Déclarer la méthode qui lui sera associée. Exemple:

public static void MaMethode(object id, object nom){…}

Noter que les types de la valeur de retour et des paramètres sont identiques.

3. Créer un objet délégué :

MonDelegue delegObj = new MonDelegue(MaMethode);

Noter que le paramètre du délégué est le nom de la méthode encapsulée.
On peut aussi créer un objet délégué sans utiliser new:

MonDelegue delegObj = MaMethode;

Exemple

// Déclarer un délégué:

delegate void MonDelegue(int n, string s);

class MainClass
{ 
  static void Main() {

// Instancier la classe:
MaClasse obj = new MaClasse();
// Instancier le delegué:

MonDelegue x = new MonDelegue(obj.MaMethode);

// Invoquer le delegue:

obj.AppelDelegue(x);

  }

 }

class MaClasse
{
// Une méthode pour invoquer le delegué:
public void AppelDelegue(MonDelegue meth) {
     meth( 200, "Ben");
}
// La méthode encapsulée :
public void MaMethode(int id, string nom)
{
Console.WriteLine("ID = {0}\nNom = {1}", id, nom);
}
}

Les événements

L’une des utilisations les plus importantes des délégués est la programmation d’événements, notamment dans l’environnement Windows.

Un clic sur un bouton déclenche un événement pour lequel la réponse à cet événement peut prendre plusieurs formes.

Le programmeur doit écrire la réponse appropriée à cet événement.

Un événement est reçu (réception) ou émis (émission).

Plusieurs types d’évènements sont possibles :

– Modifier du texte dans une zone de texte,

– Passer à un autre contrôle, …

La réception de l’événement dépend totalement de l’application en développement.

L’utilisation des événements

On commence par déclarer un délégué à utiliser comme gestionnaire (ou récepteur) :
delegate void RightButtonDown(object sender, EventArgs e);
On utilise ensuite le nom du délégué (RightButtonDown) comme type de l’évènement déclaré avec le mot-clé event.
Par exemple, pour appeler l’évènement PressDown, on le définit comme suit:

event RightButtonDown PressDown;

Le mot clé event protège l’accès au délégué de la manière suivante :
• Il n’est plus possible d’utiliser l’affectation seule (opérateur =), il faut utiliser += ou -= ;
• L’ajout et le retrait sont réalisés de manière synchrone, c-à-d que chaque évènement
attend la fin du précédent pour s’exécuter. Si un évènement lance une exception, les
suivants ne seront pas exécutés;
• Il n’est pas possible d’appeler le delegate en dehors de la classe où l’event est
déclaré.

LAISSER UN COMMENTAIRE

Entrez votre commentaire!
Entrez votre nom ici