Methodengruppen in C#

1. Methodengruppe in C#
2. Delegates in C#
3. Konvertierung von Methodengruppen mit DELEGATE in C#
4. Einfaches benutzerdefiniertes Delegieren für Methodengruppen in C#
5. Verwendung von Funktionszeiger für Methodengruppen in C#

Dieser Artikel befasst sich mit Methodengruppen in C#.

Methodengruppe in C#

Wir begegnen manchmal einem Fall, in dem eine Funktion mehr als eine Implementierung haben kann. Es kann eine andere Definition mit einem völlig anderen Parametersatz oder -typ haben oder wird normalerweise als überladene Funktion bezeichnet.

Syntax:

void print(int x) {
  ///...code
}

void print(int x, int y) {
  ///...code for x and y
}

Solche Funktionen oder Methoden werden METHODENGRUPPEN genannt.

Delegates in C#

DELEGATES sind Zeiger auf erstellte Funktionen. Neben dem Verweis auf die Funktion definiert es auch den Rückgabetyp der Funktionen und ihrer Parameter.

Ein Delegat namens LAPTOP, sagen wir, kann als Rückgabetyp void und als Parameter USERNAME (String) haben. Wir haben eine weitere Funktion namens PC, die ebenfalls den gleichen Rückgabetyp und Parametertyp wie LAPTOP hat.

In diesem Szenario können wir PC vom Delegierten LAPTOP aufrufen.

Code-beispiel:

delegate void LAPTOP(string username);

static void PC(string username) {
  Console.WriteLine("USER: " + username + " has logged in!");
}

static void Main() {
  LAPTOP lap1 = PC;
  lap1("Hydrogen");
}

Sie können feststellen, dass wir die Instanz LAPTOP mit PC instanziiert haben und ein späterer Aufruf dazu führt, dass wir den von der Methode PC übergebenen Benutzernamen drucken. So funktionieren DELEGATES.

Konvertierung von Methodengruppen mit DELEGATE in C#

Wir betrachten eine der häufigsten Verwendungen von Methodengruppen und wie sie beim Aufrufen behandelt werden. Wir haben besprochen, dass Methodengruppen überladene Funktionen einer Basismethode sind, und wir können Methodengruppen nach Belieben verwenden, indem wir DELEGATES verwenden.

Nehmen wir in unserem Beispiel an, dass wir eine Methode namens CAR haben, von der aus wir mehrere andere Methoden wie DASHBOARD, WHEEL, LIGHTS usw. ansprechen möchten. Wir werden der Einfachheit halber nur zwei Methoden verwenden: LIGHTS und MIRRORS.

Codebeispiel:

delegate void CAR(bool start);

static void MIRROR(bool start) {
  if (start)
    Console.WriteLine("Mirror is now working!");
  else
    Console.WriteLine("Mirror is not stopped/closed");
}

static void LIGHTS(bool start) {
  if (start)
    Console.WriteLine("Lights are now working!");
  else
    Console.WriteLine("Lights have stopped/closed");
}

Nachdem wir nun die Methoden definiert haben, implementieren wir die Methode MAIN, bei der wir Delegaten verwenden, um diese Methodengruppen zu handhaben.

CAR car = MIRROR;
car(true);

car = LIGHTS;
car(false);

Sie können bemerken, dass das Objekt CAR auf den MIRROR, aber später wird es auf LIGHTS verweisen. Der Aufruf der Methode ruft dann die Funktion auf, auf die sie zeigt.

Der Name der Funktion wird dem Objekt CAR zugeordnet. Das Ändern des DELEGATE-Zeigers, um auf verschiedene Methoden in seiner Gruppe zu zeigen, wird METHOD GROUP CONVERSION genannt, und in diesem Szenario sind LIGHTS, MIRRORS und CAR alle Teil derselben Methodengruppe.

Einfaches benutzerdefiniertes Delegieren für Methodengruppen in C#

Eine einfache Möglichkeit, ein DELEGATE zu erstellen, das auf METHOD GROUPS zeigen kann, ist etwas so Einfaches wie das Folgende.

Func<string> f_test = "AA".ToString;
Console.WriteLine(f_test());

Der obige Aufruf gibt als Ergebnis den String AA aus. F_TEST zeigt auf die Methode ToString und ruft diese auf.

Sie können auch feststellen, dass diese Funktion auf die Adresse der Methode ToString verweist und nicht auf die Funktion selbst. So funktionieren Zeiger.

Nachfolgend finden Sie ein weiteres Beispiel, um METHODENGRUPPEN richtig zu verstehen.

Func<string, int> f_test = Convert.ToInt32;
Console.WriteLine(f_test("435"));

Syntax:

Func<param1, param2> name;
//param1 is the parameter passed in the function/method pointed to
//param 2 is the return type of that function/method that the delegate points to

Da Convert.ToInt32 einen Rückgabetyp von INT und 18 hat, gibt es verschiedene Überladungen. Es ist zwingend erforderlich, den Parametertyp zu definieren, da wir F_TEST mit einem String "435" aufrufen wollen und PARAM2 als STRING definieren.

Die Definition von PARAM2 ist wichtig, auch wenn nur eine Überladung einer Funktion vorhanden ist; Da METHOD GROUPS kompilierte Zeitkonstrukte sind, müssen sie für eine einzelne Überladung ausgewählt werden. Es ist darauf zu achten, dass PARAM2 mindestens eine Überladung enthält.

Sie können den Cast in LINQ auch entfernen, wenn Sie die List.Select(MethodGroup) in einer Funktion aufrufen. Wir werden auf LINQ-Kontexte nicht im Detail eingehen, da sich dieser Artikel auf METHODENGRUPPEN konzentriert.

Verwendung von Funktionszeiger für Methodengruppen in C#

Das Zeigen auf verschiedene Funktionen von einem Delegierten ist nur erforderlich, wenn Sie in METHODENGRUPPEN arbeiten. Sie müssen sicherstellen, dass die Rückgabetypen und Parameter unter solchen Umständen übereinstimmen.

C# stellt bereits ein FUNC-Schlüsselwort bereit, um auf verschiedene Funktionen zu zeigen. So wie Zeiger funktionieren, indem sie auf Adressen von Objekten und Variablen zeigen und diese dann aufrufen, können Sie sich Delegaten auf die gleiche Weise vorstellen.

Zeiger neigen auch dazu, den gleichen Rückgabetyp zu haben wie die Objekte, die sie adressieren. Delegierte müssen sich aufgrund von Funktionsanforderungen auch um Parameter kümmern.

Das Zeigen auf Funktionen ist erforderlich, wenn Sie beispielsweise Funktionen in einem Array speichern und dynamisch für Ihren Code aufrufen oder die Funktionen an andere aufzurufende Funktionen übergeben möchten. LAMBDA-Funktionen dienen ebenfalls der gleichen Anforderung.

METHOD GROUPS sind jedoch gängige Cluster mit überladenen Funktionen, die einem grundlegenden Rückgabe- und Parametertyp folgen.