Comprendre les délégués C# : Guide des références de fonctions et des événements

Les délégués C# sont similaires aux pointeurs de fonctions en C ou C++. Un délégué est une variable de type référence qui contient la référence à une méthode. Cette référence peut être modifiée à l'exécution.

Les délégués sont particulièrement utilisés pour implémenter les événements et les méthodes de rappel. Tous les délégués sont implicitement dérivés de la classe System.Delegate.

Déclaration des délégués

La déclaration d'un délégué détermine les méthodes qui peuvent être référencées par celui-ci. Un délégué peut référencer une méthode qui a la même signature que le délégué.

Par exemple, considérons un délégué :

public delegate int MonDelegue(string s);

Ce délégué peut être utilisé pour référencer toute méthode qui possède un unique paramètre string et retourne une variable de type int.

Syntaxe pour la déclaration d'un délégué :

delegate <type de retour> <nom-du-délégué> <liste de paramètres>

Instanciation des délégués

Une fois qu'un type délégué est déclaré, un objet délégué doit être créé avec le mot-clé new et associé à une méthode particulière. Lors de la création d'un délégué, l'argument passé à l'expression new s'écrit de manière similaire à un appel de méthode, mais sans les arguments de la méthode. Par exemple :

public delegate void printString(string s); 
... 
printString ps1 = new printString(WriteToScreen); 
printString ps2 = new printString(WriteToFile);

L'exemple suivant montre la déclaration, l'instanciation et l'utilisation d'un délégué qui peut référencer des méthodes prenant un paramètre entier et retournant une valeur entière.

Démonstration en direct

using System; 
delegate int NumberChanger(int n); 
namespace DelegateAppl { 
    class TestDelegate { 
        static int num = 10; 
        public static int AddNum(int p) { 
            num += p; 
            return num; 
        } 
        public static int MultNum(int q) { 
            num *= q; 
            return num; 
        } 
        public static int getNum() { 
            return num; 
        } 
        static void Main(string[] args) { 
            // Création d'instances de délégués 
            NumberChanger nc1 = new NumberChanger(AddNum); 
            NumberChanger nc2 = new NumberChanger(MultNum); 
            // Appel des méthodes via les objets délégués 
            nc1(25); 
            Console.WriteLine("Valeur de Num: {0}", getNum()); 
            nc2(5); 
            Console.WriteLine("Valeur de Num: {0}", getNum()); 
            Console.ReadKey(); 
        } 
    } 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Valeur de Num: 35 
Valeur de Num: 175

Multidiffusion d'un délégué

Les objets délégués peuvent être composés à l'aide de l'opérateur "+". Un délégué composé appelle les deux délégués dont il est composé. Seuls les délégués du même type peuvent être composés. L'opérateur "-" peut être utilisé pour supprimer un délégué composant d'un délégué composé.

En utilisant cette propriété des délégués, vous pouvez créer une liste d'invocation de méthodes qui seront appelées lorsque le délégué est invoqué. C'est ce qu'on appelle la multidiffusion (multicasting) d'un délégué. Le programme suivant montre la multidiffusion d'un délégué :

Démonstration en direct

using System; 
delegate int NumberChanger(int n); 
namespace DelegateAppl { 
    class TestDelegate { 
        static int num = 10; 
        public static int AddNum(int p) { 
            num += p; 
            return num; 
        } 
        public static int MultNum(int q) { 
            num *= q; 
            return num; 
        } 
        public static int getNum() { 
            return num; 
        } 
        static void Main(string[] args) { 
            // Création d'instances de délégués 
            NumberChanger nc; 
            NumberChanger nc1 = new NumberChanger(AddNum); 
            NumberChanger nc2 = new NumberChanger(MultNum); 
            nc = nc1; 
            nc += nc2; 
            // Appel du délégué multidiffusé 
            nc(5); 
            Console.WriteLine("Valeur de Num: {0}", getNum()); 
            Console.ReadKey(); 
        } 
    } 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Valeur de Num: 75

Utilisation des délégués

L'exemple suivant montre l'utilisation d'un délégué. Le délégué printString peut être utilisé pour référencer une méthode qui prend une chaîne en entrée et ne retourne rien.

Nous utilisons ce délégué pour appeler deux méthodes : la première affiche la chaîne dans la console, la seconde l'écrit dans un fichier :

Démonstration en direct

using System; 
using System.IO; 
namespace DelegateAppl { 
    class PrintString { 
        static FileStream fs; 
        static StreamWriter sw; 
        // Déclaration du délégué 
        public delegate void printString(string s); 
        // Cette méthode affiche dans la console 
        public static void WriteToScreen(string str) { 
            Console.WriteLine("La chaîne est : {0}", str); 
        } 
        // Cette méthode écrit dans un fichier 
        public static void WriteToFile(string s) { 
            fs = new FileStream("c:\\message.txt", FileMode.Append, FileAccess.Write); 
            sw = new StreamWriter(fs); 
            sw.WriteLine(s); 
            sw.Flush(); 
            sw.Close(); 
            fs.Close(); 
        } 
        // Cette méthode prend le délégué comme paramètre et l'utilise pour 
        // appeler les méthodes selon les besoins 
        public static void sendString(printString ps) { 
            ps("Hello World"); 
        } 
        static void Main(string[] args) { 
            printString ps1 = new printString(WriteToScreen); 
            printString ps2 = new printString(WriteToFile); 
            sendString(ps1); 
            sendString(ps2); 
            Console.ReadKey(); 
        } 
    } 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

La chaîne est : Hello World