Partager via

Utilisation de délégués (Guide de programmation C#)

Un délégué est un type qui encapsule en toute sécurité une méthode, similaire à un pointeur de fonction en C et C++. Toutefois, à la différence des pointeurs de fonction C, les délégués sont orientés objet, de type sécurisé et sûrs. L’exemple suivant déclare un délégué nommé Callback qui peut encapsuler une méthode qui prend une chaîne en tant qu’argument et retourne void :

public delegate void Callback(string message);

Un objet délégué est normalement construit en fournissant le nom de la méthode que le délégué encapsule, ou avec une expression lambda. Un délégué peut être appelé une fois instancié de cette façon. Lorsqu'on invoque un délégué, cela appelle la méthode attachée à l’instance du délégué. Les paramètres passés au délégué par l’appelant sont passés à la méthode. Le délégué renvoie. le cas échéant, la valeur de retour de la méthode. Par exemple:

// Create a method for a delegate.
public static void DelegateMethod(string message)
{
    Console.WriteLine(message);
}

// Instantiate the delegate.
Callback handler = DelegateMethod;

// Call the delegate.
handler("Hello World");

Les types délégués sont dérivés de la Delegate classe dans .NET. Les types délégués sont scellés, ils ne peuvent pas être dérivés, et il n’est pas possible de dériver des classes personnalisées à partir de Delegate. Étant donné que le délégué instancié est un objet, il peut être passé comme argument, ou assigné à une propriété. Une méthode peut accepter un délégué en tant que paramètre et appeler le délégué ultérieurement. Il s’agit d’un rappel asynchrone et est une méthode courante d’notification d’un appelant lorsqu’un long processus se termine. Lorsqu’un délégué est utilisé de cette façon, le code utilisant le délégué n’a pas besoin de connaître l’implémentation de la méthode utilisée. Les fonctionnalités sont similaires aux interfaces d’encapsulation.

Une autre utilisation courante des rappels consiste à définir une méthode de comparaison personnalisée et à passer ce délégué à une méthode de tri. Il permet au code de l’appelant de faire partie de l’algorithme de tri. L’exemple de méthode suivant utilise le Callback type comme paramètre :

public static void MethodWithCallback(int param1, int param2, Callback callback)
{
    callback("The number is: " + (param1 + param2).ToString());
}

Vous pouvez ensuite transmettre le délégué créé dans l’exemple précédent à cette méthode :

MethodWithCallback(1, 2, handler);

et vous recevez le résultat suivant sur la console :

The number is: 3

MethodWithCallback n’a pas besoin d’appeler directement la console. La méthode ne doit pas nécessairement être associée à une console au moment de sa conception. Ce que MethodWithCallback fait, c'est préparer une chaîne et la passer à une autre méthode. Une méthode déléguée peut utiliser n’importe quel nombre de paramètres.

Lorsqu’un délégué est construit pour encapsuler une méthode d’instance, le délégué fait référence à la fois à l’instance et à la méthode. Un délégué ne connaît rien du type d'instance, hormis la méthode qu’il encapsule. Un délégué peut faire référence à n’importe quel type d’objet tant qu’il existe une méthode sur cet objet qui correspond à la signature du délégué. Lorsqu’un délégué est construit pour encapsuler une méthode statique, il référence uniquement la méthode. Tenez compte des déclarations suivantes :

public class MethodClass
{
    public void Method1(string message) { }
    public void Method2(string message) { }
}

En plus de la statique DelegateMethod affichée précédemment, nous avons maintenant trois méthodes que vous pouvez encapsuler dans une Del instance.

Un délégué peut appeler plusieurs méthodes lorsqu’il est appelé ; c’est ce qu'on appelle la multidiffusion. Pour ajouter une méthode supplémentaire à la liste des méthodes du délégué (liste d'invocation), il suffit d’ajouter un délégué à l’aide des opérateurs d’addition ou d’affectation par addition ('+' ou '+='). Par exemple:

var obj = new MethodClass();
Callback d1 = obj.Method1;
Callback d2 = obj.Method2;
Callback d3 = DelegateMethod;

//Both types of assignment are valid.
Callback allMethodsDelegate = d1 + d2;
allMethodsDelegate += d3;

Le allMethodsDelegate contient trois méthodes dans sa liste d’appel : Method1, Method2 et DelegateMethod. Les trois délégués d’origine, d1, d2et d3, restent inchangés. Quand allMethodsDelegate est invoqué, les trois méthodes sont appelées dans l’ordre. Si le délégué utilise des paramètres de référence, la référence est transmise séquentiellement à chacune des trois méthodes à son tour, et toutes les modifications apportées par une méthode sont visibles par la méthode suivante. Quand l'une des méthodes lève une exception qui n'est pas interceptée dans la méthode, cette exception est passée à l'appelant du délégué. Aucune méthode suivante dans la liste d’appel n’est appelée. Si le délégué a une valeur de retour et/ou des paramètres sortants, il retourne la valeur de retour et les paramètres de la dernière méthode appelée. Pour supprimer une méthode de la liste d'appel, utilisez les opérateurs de soustraction ou d'affectation par soustraction (- ou -=). Par exemple:

//remove Method1
allMethodsDelegate -= d1;

// copy AllMethodsDelegate while removing d2
Callback oneMethodDelegate = (allMethodsDelegate - d2)!;

Étant donné que les types délégués sont dérivés de System.Delegate, les méthodes et les propriétés définies par cette classe peuvent être appelées sur le délégué. Par exemple, pour rechercher le nombre de méthodes dans la liste d’appel d’un délégué, vous pouvez écrire :

int invocationCount = d1.GetInvocationList().GetLength(0);

Les délégués ayant plusieurs méthodes dans leur liste d'appels dérivent de MulticastDelegate, qui est une sous-classe de System.Delegate. Le code précédent fonctionne dans les deux cas, car les deux classes prennent en charge GetInvocationList.

Les délégués multicast sont largement utilisés dans la gestion des événements. Les objets sources d’événements envoient des notifications d’événements aux objets destinataires inscrits pour recevoir cet événement. Pour vous inscrire à un événement, le destinataire crée une méthode conçue pour gérer l’événement, puis crée un délégué pour cette méthode et transmet le délégué à la source d’événement. La source appelle le délégué lorsque l’événement se produit. Le délégué appelle ensuite la méthode de gestion d'événement sur le destinataire, en fournissant les données d'événement. La source d’événement définit le type de délégué pour un événement donné. Pour plus d’informations, consultez Événements.

La comparaison des délégués de deux types différents attribués au moment de la compilation entraîne une erreur de compilation. Si les instances de délégué sont statiquement du type System.Delegate, la comparaison est autorisée, mais retourne false au moment de l’exécution. Par exemple:

delegate void Callback1();
delegate void Callback2();

static void method(Callback1 d, Callback2 e, System.Delegate f)
{
    // Compile-time error.
    Console.WriteLine(d == e);

    // OK at compile-time. False if the run-time type of f
    // is not the same as that of d.
    Console.WriteLine(d == f);
}

Voir aussi