C# - Afgevaardigden

C#-afgevaardigden zijn vergelijkbaar met verwijzingen naar functies, in C of C++. Een afgevaardigde is een referentietypevariabele die de verwijzing naar een methode bevat. De referentie kan tijdens runtime worden gewijzigd.

Delegates worden vooral ingezet voor het implementeren van events en de call-back methodes. Alle afgevaardigden zijn impliciet afgeleid van de System.Delegate klasse.

Afgevaardigden declareren

Gedelegeerde declaratie bepaalt de methoden waarnaar kan worden verwezen door de gedelegeerde. Een afgevaardigde kan verwijzen naar een methode die dezelfde handtekening heeft als die van de afgevaardigde.

Overweeg bijvoorbeeld een afgevaardigde −

public delegate int MyDelegate (string s);

De voorgaande gedelegeerde kan worden gebruikt om naar elke methode te verwijzen die een enkele tekenreeks . heeft parameter en retourneert een int type variabele.

Syntaxis voor gedelegeerde declaratie is −

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

Afgevaardigden aanwijzen

Zodra een gemachtigdetype is gedeclareerd, moet een gemachtigdeobject worden gemaakt met de nieuwe trefwoord en worden geassocieerd met een bepaalde methode. Bij het aanmaken van een gemachtigde werd het argument doorgegeven aan de nieuwe expressie wordt op dezelfde manier geschreven als een methodeaanroep, 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, concretisering en gebruik van een gemachtigde die kan worden gebruikt om te verwijzen naar methoden die een integer-parameter nemen 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) {
         //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();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Value of Num: 35
Value of Num: 175

Multicasting van een afgevaardigde

Gedelegeerde objecten kunnen worden samengesteld met de operator "+". Een samengestelde afgevaardigde roept de twee afgevaardigden op waaruit hij is samengesteld. Alleen afgevaardigden van hetzelfde type kunnen worden samengesteld. De operator "-" kan worden gebruikt om een ​​afgevaardigde van een component te verwijderen van een samengestelde afgevaardigde.

Met behulp van deze eigenschap van gedelegeerden kunt u een oproeplijst maken met methoden die worden aangeroepen wanneer een gedelegeerde wordt aangeroepen. Dit heet multicasting van een afgevaardigde. Het volgende programma demonstreert multicasting van een afgevaardigde −

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Value of Num: 75

Gedelegeerden gebruiken

Het volgende voorbeeld demonstreert het gebruik van delegate. De afgevaardigde printString kan worden gebruikt om te verwijzen naar een methode die een string als invoer neemt en niets teruggeeft.

We gebruiken deze gemachtigde om twee methoden aan te roepen, de eerste drukt de string af naar de console en de tweede drukt deze af naar een bestand −

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

The String is: Hello World