C# - Delegaten

C#-Delegates ähneln Zeigern auf Funktionen in C oder C++. Ein Delegierter ist eine Referenztypvariable, die den Verweis auf eine Methode enthält. Die Referenz kann zur Laufzeit geändert werden.

Delegaten werden insbesondere zum Implementieren von Ereignissen und der Callback-Methoden verwendet. Alle Delegaten werden implizit von System.Delegate abgeleitet Klasse.

Delegierte deklarieren

Die Delegatdeklaration bestimmt die Methoden, auf die der Delegat verweisen kann. Ein Delegierter kann auf eine Methode verweisen, die dieselbe Signatur wie die des Delegierten hat.

Betrachten Sie zum Beispiel einen Delegaten −

public delegate int MyDelegate (string s);

Der vorhergehende Delegat kann verwendet werden, um auf jede Methode zu verweisen, die eine einzelne Zeichenfolge hat -Parameter und gibt ein int zurück Typvariable.

Syntax für die Delegate-Deklaration ist −

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

Delegierte instanziieren

Sobald ein Delegattyp deklariert ist, muss ein Delegatobjekt mit dem neuen erstellt werden Schlüsselwort und einer bestimmten Methode zugeordnet werden. Beim Erstellen eines Delegaten wird das Argument an new übergeben Ausdruck wird ähnlich wie ein Methodenaufruf geschrieben, jedoch ohne die Argumente für die Methode. Zum Beispiel −

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

Das folgende Beispiel zeigt die Deklaration, Instanziierung und Verwendung eines Delegaten, der verwendet werden kann, um auf Methoden zu verweisen, die einen ganzzahligen Parameter annehmen und einen ganzzahligen Wert zurückgeben.

Live-Demo

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();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Value of Num: 35
Value of Num: 175

Multicasting eines Delegaten

Delegate-Objekte können mit dem "+"-Operator zusammengesetzt werden. Ein zusammengesetzter Delegierter ruft die zwei Delegierten auf, aus denen er zusammengesetzt wurde. Es können nur Delegierte des gleichen Typs zusammengesetzt werden. Der "-"-Operator kann verwendet werden, um einen Komponenten-Delegaten aus einem zusammengesetzten Delegaten zu entfernen.

Mit dieser Eigenschaft von Delegaten können Sie eine Aufrufliste von Methoden erstellen, die aufgerufen werden, wenn ein Delegat aufgerufen wird. Dies wird Multicasting genannt eines Delegierten. Das folgende Programm demonstriert das Multicasting eines Delegaten −

Live-Demo

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();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Value of Num: 75

Verwenden von Delegierten

Das folgende Beispiel veranschaulicht die Verwendung von Delegaten. Der Delegat printString kann verwendet werden, um auf eine Methode zu verweisen, die einen String als Eingabe nimmt und nichts zurückgibt.

Wir verwenden diesen Delegaten, um zwei Methoden aufzurufen, die erste gibt den String auf der Konsole aus und die zweite gibt ihn in eine Datei aus −

Live-Demo

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();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

The String is: Hello World