Erklären Sie das Konzept der Delegation in C#

Wenn Sie ein C-Programmierer sind, können Sie sich einen Delegaten als Zeiger auf eine Funktion vorstellen. Allerdings ist ein Delegat in C# mehr als nur ein einfacher Funktionszeiger. In diesem Artikel wird das Konzept der Delegation und seine Verwendung in der alltäglichen Programmierung erläutert.

Im Wesentlichen bietet die Delegation eine gewisse Indirektion. Sie kapseln einen Codeabschnitt, der typsicher weitergegeben und ausgeführt werden kann. Anstatt das Verhalten sofort auszuführen, ist es in einem Objekt enthalten. Sie können für dieses Objekt mehrere Vorgänge ausführen, darunter auch die Ausführung eines enthaltenen Verhaltens.

Die Verwendung von Delegaten ermöglicht es uns, Funktionen höherer Ordnung zu schreiben, d. h. Funktionen, die Funktionen als Parameter empfangen oder Funktionen als Rückgabewerte zurückgeben können. Ein Delegattyp definiert die Methodensignatur, die ein Delegat darstellen kann, insbesondere den Rückgabetyp der Methode und ihre Parametertypen. Im folgenden Beispiel ist Transformer ein Delegat, der jede Methode darstellen kann, die eine Ganzzahl akzeptiert und zurückgibt.

delegate int Transformer(int x);

Wir können einer Transformer-Instanz jede Methode (einschließlich Lambda-, Instanz- oder statische Methoden) zuweisen, die die Signatur erfüllt. Zum Beispiel:

Transformer square = x => x * x;
Transformer cube = x => x * x * x;

Console.WriteLine(square(3)); // prints 9
Console.WriteLine(cube(5)); // prints 125

Wann sollte die Delegation verwendet werden?

Delegierte werden normalerweise verwendet, wenn der Code, der bestimmte Vorgänge ausführen möchte, die Details dieser Vorgänge nicht kennt, aber die Schnittstelle für diese Vorgänge kennt.

Beim Programmieren stoßen wir häufig auf Situationen, in denen wir eine bestimmte Operation ausführen müssen, aber nicht im Voraus wissen, welche Methode wir aufrufen müssen, um sie auszuführen. Delegierte helfen uns, dieses Problem zu lösen, indem sie das Verhalten durch einen Delegaten ersetzen und dann eine konkrete Instanz des Delegaten mit dem entsprechenden Verhalten übergeben, je nach Kontext und Situation.

Damit ein Delegat etwas tun kann, müssen vier Dinge passieren:

1) Der Delegate-Typ muss deklariert werden.

Ein Delegattyp ist im Wesentlichen die Definition der Funktion, die er darstellt, d. h. er besteht aus den Parametern, den Typen, die die Funktion akzeptiert, und dem Rückgabetyp, den sie zurückgibt.

Zum Beispiel könnte ein Delegattyp, der eine Methode darstellt, die zwei Zahlen als Eingabe akzeptiert und eine Zahl zurückgibt, als -

delegate int Processor(int numOne, int numTwo);

Ein Prozessor ist ein Typ, ähnlich den von Klassen erstellten Typen, deklariert werden. Um eine Instanz dieses Typs zu erstellen, benötigen Sie eine Methode, die zwei Zahlen als Eingabe akzeptiert und einen booleschen Wert zurückgibt.

2) Der auszuführende Code muss in der Methode enthalten sein.

Definieren Sie eine Methode mit genau der gleichen Signatur wie der oben genannte Delegate-Typ und machen Sie je nach Laufzeitsituation, was Sie wollen. Zum Erstellen einer Prozessorinstanz kann beispielsweise jede der folgenden Methoden verwendet werden, da sie alle zwei Zahlen annehmen und eine Zahl zurückgeben.

static int Add(int numOne, int numTwo){
   Return numOne + numTwo;
}
static int Subtract(int numOne, int numTwo){
   Return numOne - numTwo;
}

3) Eine Delegate-Instanz muss erstellt werden.

Da Sie nun einen Delegate-Typ und eine Methode mit der richtigen Signatur haben, können Sie eine Instanz dieses Delegate-Typs erstellen. Dabei weisen wir den C#-Compiler im Wesentlichen an, diese Methode auszuführen, wenn die Delegateninstanz aufgerufen wird.

Processor processorOne = new Processor(Add);
Processor processorTwo = new Processor(Subtract);

Das obige Beispiel geht davon aus, dass die Add- und Subtract-Methoden in derselben Klasse definiert sind, in der wir die Delegate-Instanz erstellen. Wenn diese Methoden in verschiedenen Klassen definiert sind, benötigen wir eine Instanz dieser Klasse.

4) Die Delegate-Instanz muss aufgerufen werden.

Dies ruft einfach eine Methode für eine Delegate-Instanz auf, die wenig überraschend den Namen „Invoke“ trägt. Diese Methode auf der Delegate-Instanz verfügt über dieselbe Parameterliste und denselben Rückgabetyp wie in der Delegate-Typdeklaration angegeben. Durch den Aufruf von Invoke wird der Vorgang der Delegateninstanz ausgeführt.

int sum = processorOne.Invoke(3, 5);

Aber C# macht es viel einfacher. Sie können die Delegate-Instanz direkt aufrufen, als wäre sie selbst eine Methode. Zum Beispiel:

int difference = processorTwo(10, 6);

Kombinieren und Entfernen von Delegaten

Wenn wir eine Reihe unterschiedlicher Vorgänge mit einem einzigen Delegate-Instanzaufruf ausführen möchten, ermöglicht uns C# dies. System. Der Delegate-Typ verfügt über zwei statische Methoden namens Combine und Remove.

1. Zusammensetzung

Erstellt einen neuen Delegaten mit einer Anrufliste, die die Anrufliste des als Argument übergebenen Delegaten verkettet. Wenn eine neue Delegate-Instanz aufgerufen wird, werden alle ihre Vorgänge nacheinander ausgeführt.

public static Delegate Combine(params Delegate[] delegates); // OR
public static Delegate Combine(Delegate a, Delegate b);

Wenn eine Operation in der Anrufliste eine Ausnahme auslöst, wird die Ausführung nachfolgender Operationen verhindert.

2. Löschen

Entfernen Sie das letzte Vorkommen der Delegierten-Anrufliste aus der Anrufliste eines anderen Delegierten. Gibt einen neuen Delegaten zurück, der die Anrufliste enthält, die durch Übernahme der Quellanrufliste und Entfernen des letzten Vorkommens der Wertanrufliste erstellt wurde.

public static Delegate Remove(Delegate source, Delegate value);

Zusammenfassung

• Ein Delegat kapselt Verhalten mithilfe eines bestimmten Typs und Satzes von Parametern, ähnlich einer einzelnen Methodenschnittstelle.

• Die durch eine Delegate-Typdeklaration beschriebene Typsignatur bestimmt, welche Methoden zum Erstellen einer Delegate-Instanz verwendet werden können und welche Signatur die Aufrufe haben.

• Das Erstellen einer Delegateninstanz erfordert die Methode, die wir ausführen möchten, wenn der Delegat aufgerufen wird.

• Delegate-Instanzen sind unveränderlich, ähnlich wie Strings.

• Jede Delegate-Instanz enthält eine Liste von Aufrufen – eine Liste von Operationen.

• Delegate-Instanzen können kombiniert und voneinander gelöscht werden.

Beispiel

Echtzeitdemonstration

using System;
class Program{
   delegate int Transformer(int x);
   delegate int Processor(int numOne, int numTwo);
   static void Main(){
      Transformer square = x => x * x;
      Transformer cube = x => x * x * x;
      Console.WriteLine(square(3)); // prints 9
      Console.WriteLine(cube(5)); // prints 125
      Processor processorOne = new Processor(Add);
      Processor processorTwo = new Processor(Subtract);
      int sum = processorOne.Invoke(3, 5);
      Console.WriteLine(sum); // prints 8
      int difference = processorTwo(10, 6);
      Console.WriteLine(difference); // prints 4
   }
   static int Add(int numOne, int numTwo){
      return numOne + numTwo;
   }
   static int Subtract(int numOne, int numTwo){
      return numOne - numTwo;
   }
}

Ausgabe

9
125
8
4

Das obige ist der detaillierte Inhalt vonErklären Sie das Konzept der Delegation in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!