C# Delegates verstehen: Ein Leitfaden zu Funktionsreferenzen und Events

Was sind Delegates in C#?

C#-Delegates ähneln Funktionszeigern in C oder C++. Ein Delegate ist eine Referenztyp-Variable, die einen Verweis auf eine Methode hält. Dieser Verweis kann zur Laufzeit geändert werden.

Delegates werden insbesondere für die Implementierung von Events und Callback-Methoden verwendet. Alle Delegates werden implizit von der Klasse System.Delegate abgeleitet.

Deklaration von Delegates

Die Delegate-Deklaration bestimmt, welche Methoden vom Delegate referenziert werden können. Ein Delegate kann auf eine Methode verweisen, die dieselbe Signatur wie der Delegate selbst aufweist.

Betrachten wir als Beispiel folgenden Delegate:

public delegate int MyDelegate(string s);

Dieser Delegate kann verwendet werden, um jede Methode zu referenzieren, die einen einzelnen string-Parameter akzeptiert und einen int-Wert zurückgibt.

Die Syntax für die Delegate-Deklaration lautet:

delegate <Rückgabetyp> <delegate-name> <parameter-liste>

Instanziierung von Delegates

Nachdem ein Delegate-Typ deklariert wurde, muss ein Delegate-Objekt mit dem Schlüsselwort new erstellt und mit einer bestimmten Methode verknüpft werden. Bei der Erstellung eines Delegates wird das Argument, das an den new-Ausdruck übergeben wird, ähnlich wie ein Methodenaufruf geschrieben, jedoch ohne die Methodenargumente. Zum Beispiel:

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

Das folgende Beispiel demonstriert die Deklaration, Instanziierung und Verwendung eines Delegates, der Methoden referenzieren kann, die einen ganzzahligen Parameter akzeptieren und einen ganzzahligen Wert zurückgeben.

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) {
            // Delegate-Instanzen erstellen
            NumberChanger nc1 = new NumberChanger(AddNum);
            NumberChanger nc2 = new NumberChanger(MultNum);
            // Methoden über die Delegate-Objekte aufrufen
            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 folgendes Ergebnis:

Value of Num: 35
Value of Num: 175

Multicasting von Delegates

Delegate-Objekte können mit dem "+"-Operator zusammengesetzt werden. Ein zusammengesetzter Delegate ruft die beiden Delegates auf, aus denen er besteht. Nur Delegates desselben Typs können zusammengesetzt werden. Der "-"-Operator kann verwendet werden, um einen Komponenten-Delegate aus einem zusammengesetzten Delegate zu entfernen.

Mit dieser Eigenschaft von Delegates können Sie eine Aufrufliste von Methoden erstellen, die aufgerufen werden, wenn ein Delegate aufgerufen wird. Dies wird als Multicasting eines Delegates bezeichnet. Das folgende Programm demonstriert dies:

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) {
            // Delegate-Instanzen erstellen
            NumberChanger nc;
            NumberChanger nc1 = new NumberChanger(AddNum);
            NumberChanger nc2 = new NumberChanger(MultNum);
            nc = nc1;
            nc += nc2;
            // Multicast aufrufen
            nc(5);
            Console.WriteLine("Value of Num: {0}", getNum());
            Console.ReadKey();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er folgendes Ergebnis:

Value of Num: 75

Verwendung von Delegates

Das folgende Beispiel demonstriert die Verwendung von Delegates. Der Delegate printString kann verwendet werden, um Methoden zu referenzieren, die einen String als Eingabe akzeptieren und nichts zurückgeben.

Wir verwenden diesen Delegate, um zwei Methoden aufzurufen: Die erste gibt den String auf der Konsole aus, die zweite schreibt ihn in eine Datei:

using System;
using System.IO;
namespace DelegateAppl {
    class PrintString {
        static FileStream fs;
        static StreamWriter sw;
        // Delegate-Deklaration
        public delegate void printString(string s);
        // Diese Methode druckt auf die Konsole
        public static void WriteToScreen(string str) {
            Console.WriteLine("The String is: {0}", str);
        }
        // Diese Methode druckt in eine Datei
        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();
        }
        // Diese Methode nimmt den Delegate als Parameter und verwendet ihn,
        // um die Methoden nach Bedarf aufzurufen
        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 folgendes Ergebnis:

The String is: Hello World