C# - Délégués

Les délégués C# sont similaires aux pointeurs vers des 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. La référence peut être modifiée au moment de l'exécution.

Les délégués sont surtout utilisés pour implémenter des événements et les méthodes de rappel. Tous les délégués sont implicitement dérivés du System.Delegate classe.

Déclarer des délégués

La déclaration de délégué détermine les méthodes qui peuvent être référencées par le délégué. Un délégué peut faire référence à une méthode qui a la même signature que celle du délégué.

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

public delegate int MyDelegate (string s);

Le délégué précédent peut être utilisé pour référencer n'importe quelle méthode qui a une seule chaîne paramètre et renvoie un int saisir une variable.

La syntaxe pour la déclaration déléguée est −

delegate <return type> <delegate-name> <parameter list>

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 nouveau mot-clé et être associé à une méthode particulière. Lors de la création d'un délégué, l'argument est passé au nouveau expression est écrite comme 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 illustre la déclaration, l'instanciation et l'utilisation d'un délégué qui peut être utilisé pour référencer des méthodes qui prennent un paramètre entier et renvoient une valeur entière.

Démo 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) {
         //create delegate instances
         NumberChanger nc1 = new NumberChanger(AddNum);
         NumberChanger nc2 = new NumberChanger(MultNum);
         
         //calling the methods using the delegate objects
         nc1(25);
         Console.WriteLine("Value of Num: {0}", getNum());
         nc2(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

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

Value of Num: 35
Value of 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é de composant d'un délégué composé.

En utilisant cette propriété de délégués, vous pouvez créer une liste d'invocation de méthodes qui seront appelées lorsqu'un délégué est invoqué. C'est ce qu'on appelle la multidiffusion d'un délégué. Le programme suivant illustre la multidiffusion d'un délégué −

Démo 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) {
         //create delegate instances
         NumberChanger nc;
         NumberChanger nc1 = new NumberChanger(AddNum);
         NumberChanger nc2 = new NumberChanger(MultNum);
         
         nc = nc1;
         nc += nc2;
         
         //calling multicast
         nc(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

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

Value of Num: 75

Utiliser des délégués

L'exemple suivant illustre l'utilisation de 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 renvoie rien.

Nous utilisons ce délégué pour appeler deux méthodes, la première imprime la chaîne sur la console et la seconde l'imprime dans un fichier −

Démo en direct

using System;
using System.IO;

namespace DelegateAppl {

   class PrintString {
      static FileStream fs;
      static StreamWriter sw;
      
      // delegate declaration
      public delegate void printString(string s);

      // this method prints to the console
      public static void WriteToScreen(string str) {
         Console.WriteLine("The String is: {0}", str);
      }
      
      //this method prints to a file
      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();
      }
      
      // this method takes the delegate as parameter and uses it to
      // call the methods as required
      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 −

The String is: Hello World