C#-Delegierte spielen eine wichtige Rolle, wenn wir ein Ereignis oder einen Rückruf in unserem Code verarbeiten möchten, oder wenn wir sagen können, dass eine Funktion mehr als einen Parameter eines anderen Datentyps hat, wir aber eine Funktion selbst und keinen Parameter übergeben möchten . In diesem Fall kommen Delegaten ins Spiel, weil sie wie ein Zeiger auf eine Funktion wirken, da es sich um einen Referenzdatentyp handelt und daher die Referenz der Methode enthält. Delegaten sind Teil der System.Delegates-Klasse in C#. Sie ähneln einem Funktionszeiger in der C- und C++-Programmierung.
Sehen wir uns die Syntax der Deklaration von Delegaten in C # an
<access modifier> delegate < return type > < delegate_name > ( <parameters>)
Erklärung: In der obigen Syntax muss der Zugriffsmodifikator vor der Deklaration von Delegaten deklariert werden, da er öffentlich, privat oder geschützt sein kann. Um nun einen Delegaten zu deklarieren, müssen wir das Schlüsselwort „delegate“ gefolgt vom Rückgabetyp der Funktion verwenden. Zum Beispiel
public delegate void Show ( char ch );
Der oben verwendete Show-Delegat wird verwendet, um auf jede Methode zu verweisen, die denselben Parameter und Rückgabetyp hat, der mit der Funktion Show () verknüpft ist.
Im Folgenden finden Sie die genannten BeispieleL
Code zur Demonstration der Funktionsweise von Single-Cast-Delegaten:
Code:
using System;
class Singlecast_Delegates
{
public delegate void Delete_func() ;
public class SD
{
public static void text_display()
{
Console.WriteLine ( " Hey hello ! , How are you " ) ;
}
public static void text_show()
{
Console.WriteLine ( " Hi ! How is everything ? " ) ;
}
public void print()
{
Console.WriteLine ( " Print " ) ;
}
}
static void Main(string[] args)
{
Delete_func del_var1 = SD.text_show ;
Delete_func del_var2 = new Delete_func ( SD.text_display ) ;
SD obj = new SD() ;
Delete_func del_var3 = obj.print ;
del_var1() ;
del_var2() ;
del_var3() ;
Console.ReadLine () ;
}
}Ausgabe:
Erklärung: Im obigen Code können Sie sehen, dass wir die statische Methode text_show() der Klasse SD zugewiesen haben, um Delete_func() zu delegieren, und dann haben wir die statische Methode text_display() der Klasse SD zugewiesen, um Delete_func zu delegieren () mit dem neuen Operator. Darüber hinaus können wir beide Möglichkeiten zur Zuweisung der Delegate-Funktion verwenden. Deshalb haben wir zunächst eine Instanz der Klasse SD erstellt und dem Delegaten die Methode print() zugewiesen, was bedeutet, dass er mit der Klasse delegiert. Am Ende haben wir das Objekt für die SD-Klasse erstellt, damit wir die Funktion, die wir in unserem Code erstellt haben, einzeln aufrufen können.
Code zur Demonstration der Funktionsweise von Double-Cast-Delegaten:
Code:
using System ;
namespace Educba {
// Here we are declaring the class with name " Edu "
class Edu {
// In this class we will declare the delegates
// Here the return type and parameter type must be same as the return and parameter type
// of the 2 methods
// "number_addition" and "number_substraction" are 2 given delegate names by user
public delegate void number_addition ( int x , int y ) ;
public delegate void number_substraction ( int x , int y ) ;
// here we are declaring the "total" method
public void total ( int x , int y )
{
Console.WriteLine( " (50 + 10) = {0} " , x + y ) ;
}
// here we are declaring the "substraction" method
public void substraction ( int x , int y )
{
Console.WriteLine( " ( 95 - 30 ) = {0} ", x - y ) ;
}
// Main Method declaration
public static void Main(String []args)
{
// creating an object " obj " for "Edu"
Edu obj = new Edu() ;
number_addition delegate1 = new number_addition ( obj.total ) ;
number_substraction delegate2 = new number_substraction( obj.substraction ) ;
// creating an object of the delegate class named as " delegate1 "
// for method "total" and "delegate2" for method "substraction" &
// pass the parameter of the 2 methods by class object "obj"
// by instantiating the delegates
// passing the below values to the methods by declared delegate object
delegate1( 50 , 10) ;
delegate2( 95 , 30);
}
}
}Ausgabe:
Erläuterung: Im obigen Code können Sie sehen, dass wir Double-Cast-Delegaten verwenden, was sich von den Single-Cast-Delegaten unterscheidet. Wir haben die Klasse mit dem Namen Edu deklariert und diese Klasse haben wir zwei Delegaten deklariert, von denen einer für die Addition von zwei Ganzzahlen und der andere für die Subtraktion von jeweils zwei gegebenen Ganzzahlen dient. Danach haben wir eine Methode „total“ zum Speichern der Ergebnisse von Additionsdelegaten deklariert. Auf die gleiche Weise haben wir eine weitere Methode zum Speichern des Ergebnisses von Subtraktionsdelegierten deklariert. In der Hauptklasse erstellen wir das Objekt der Edu-Klasse, damit wir die Delegaten aufrufen können, um eine Addition und Subtraktion für zwei beliebige Ganzzahlen durchzuführen. Wir übergeben den Wert und erhalten die Ergebnisse.
Code zur Demonstration der Arbeitsweise anonymer Delegaten:
Code:
using System;
// declaring delegate method Demo of void type
public delegate void Demo() ;
// creating a class for declaring a static method inside this class.
public class First_Program
{
static int Main()
{
Demo Display = delegate()
{ // displaying the output on the user screen
Console.WriteLine ( " Here is the Anonymous delegate method " ) ;
};
// Here we are calling the display function.
Display() ;
return 0 ;
}
}Ausgabe:
Immer wenn ein Programmierer eine Methode als Argument für andere Methoden übergeben muss, verwenden wir Delegaten oder wir können sagen, dass Delegaten eine Klasse sind, durch die wir eine Funktionssignatur kapseln können. Es ist eher so, als würde man einem Methodenparameter in C# einen Namen geben.
Das obige ist der detaillierte Inhalt vonC#-Delegierte. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
