C# Delegates Begrijpen: Handleiding voor Functiereferenties en Events

Wat zijn Delegates?

C# delegates zijn vergelijkbaar met functiepointers in C of C++. Een delegate is een referentietypevariabele die een referentie naar een methode bevat. Deze referentie kan tijdens runtime worden gewijzigd.

Delegates worden met name gebruikt voor het implementeren van events en callback-methoden. Alle delegates zijn impliciet afgeleid van de System.Delegate klasse.

Delegates Declareren

De declaratie van een delegate bepaalt welke methoden door de delegate kunnen worden gerefereerd. Een delegate kan verwijzen naar een methode die dezelfde handtekening heeft als de delegate zelf.

Bijvoorbeeld, overweeg de volgende delegate:

public delegate int MyDelegate(string s);

Deze delegate kan gebruikt worden om elke methode te refereren die een enkele string parameter accepteert en een int retourneert.

De syntaxis voor het declareren van een delegate is:

delegate <retourtype> <delegate-naam> <parameterlijst>

Delegates Instantiëren

Zodra een delegatetype is gedeclareerd, moet een delegate-object worden aangemaakt met het new sleutelwoord en gekoppeld aan een specifieke methode. Bij het aanmaken van een delegate wordt het argument dat aan de new expressie wordt doorgegeven, geschreven alsof het een methodeaanroep is, maar zonder de argumenten voor de methode. Bijvoorbeeld:

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

Het volgende voorbeeld demonstreert declaratie, instantieering en gebruik van een delegate die methodes kan refereren die een integer parameter accepteren en een integer waarde retourneren.

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 instanties aanmaken
            NumberChanger nc1 = new NumberChanger(AddNum);
            NumberChanger nc2 = new NumberChanger(MultNum);
            // Methodes aanroepen via de delegate objecten
            nc1(25);
            Console.WriteLine("Waarde van Num: {0}", getNum());
            nc2(5);
            Console.WriteLine("Waarde van Num: {0}", getNum());
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

Waarde van Num: 35
Waarde van Num: 175

Multicasting van een Delegate

Delegate-objecten kunnen worden samengesteld met de + operator. Een samengestelde delegate roept de twee delegates aan waaruit deze samengesteld is. Alleen delegates van hetzelfde type kunnen worden samengesteld. De - operator kan gebruikt worden om een component-delegate uit een samengestelde delegate te verwijderen.

Met deze eigenschap van delegates kun je een aanroepelijst van methoden maken die worden uitgevoerd wanneer een delegate wordt aangeroepen. Dit heet multicasting van een delegate. Het volgende programma demonstreert multicasting:

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 instanties aanmaken
            NumberChanger nc;
            NumberChanger nc1 = new NumberChanger(AddNum);
            NumberChanger nc2 = new NumberChanger(MultNum);
            nc = nc1;
            nc += nc2;
            // Multicast aanroepen
            nc(5);
            Console.WriteLine("Waarde van Num: {0}", getNum());
            Console.ReadKey();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

Waarde van Num: 75

Delegates Gebruiken

Het volgende voorbeeld demonstreert het gebruik van een delegate. De delegate printString kan gebruikt worden om een methode te refereren die een string als invoer accepteert en niets retourneert.

We gebruiken deze delegate om twee methoden aan te roepen: de eerste print de string naar de console, de tweede schrijft deze naar een bestand:

using System;
using System.IO;
namespace DelegateAppl {
    class PrintString {
        static FileStream fs;
        static StreamWriter sw;
        // Delegate declaratie
        public delegate void printString(string s);
        // Deze methode print naar de console
        public static void WriteToScreen(string str) {
            Console.WriteLine("De String is: {0}", str);
        }
        // Deze methode print naar een bestand
        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();
        }
        // Deze methode neemt de delegate als parameter en gebruikt deze
        // om de methoden aan te roepen zoals nodig
        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();
        }
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert dit het volgende resultaat:

De String is: Hello World