Instanziieren und Aufrufen von Delegattypen

10 Minuten

Stellvertretungstypen werden mithilfe des folgenden Prozesses implementiert:

Deklarieren Sie den Delegaten: Definieren Sie einen Delegattyp mit einer bestimmten Signatur, die den Rückgabetyp und die Parameter enthält.
Instanziieren Sie den Delegaten: Erstellen Sie eine Instanz des Delegatentyps, und geben Sie die methode an, die aufgerufen werden soll.
Rufen Sie den Delegat auf: Rufen Sie die Delegatinstanz auf, und übergeben Sie alle erforderlichen Argumente.

Nachdem ein benannter Delegat deklariert wurde, können Sie Instanzen dieses Delegatentyps erstellen und sie verwenden, um Methoden aufzurufen, die der Signatur des Delegaten entsprechen. Jede Delegatinstanz kann auf eine andere Methode verweisen, sodass flexible und dynamische Methodenaufrufe möglich sind. Darüber hinaus können Delegaten kombiniert werden, um Multicast-Delegaten zu erstellen, die es ermöglichen, mehrere Methoden in einem einzigen Aufruf auszuführen.

Wenn ein Delegat aufgerufen wird, ruft er die(n) Methode(n) auf, auf die er verweist, und übergibt alle Argumente, die in der Signatur des Delegaten angegeben sind.

Instanziieren und Aufrufen von Delegaten

Stellvertretungen können mithilfe von benannten Methoden, Methodengruppenkonvertierung, anonymen Methoden oder Lambda-Ausdrücken instanziiert werden. Die Wahl der Instanziierungsmethode hängt vom jeweiligen Anwendungsfall und der gewünschten Lesbarkeits- und Wartungsfreundlichkeit ab.

Instanziieren von Delegaten mit benannten Methoden

Benannte Methoden werden mit einem bestimmten Namen definiert und können wiederverwendet werden. Die Verwendung benannter Methoden ist nützlich, wenn Sie eine Delegateninstanz erstellen möchten, die auf eine bestimmte Methode verweist. Benannte Methoden werden in der Regel in einer Klasse oder Struktur definiert und können statisch oder Instanzmethoden sein.


public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        // Create an instance of the delegate using a named method
        Notify notify = new Notify(NotificationService.SendNotification);

        // Invoke the delegate
        notify("Hello, World!");
    }
}

public static class NotificationService
{
    // Method that matches the delegate's signature
    public static void SendNotification(string message)
    {
        Console.WriteLine("Notification sent: " + message);
    }
}

In diesem Beispiel wird veranschaulicht, wie ein Delegattyp Notify erstellt wird, der einen Zeichenfolgenparameter verwendet und "void" zurückgibt. Die SendNotification Methode stimmt mit der Signatur des Delegaten überein, sodass sie der Stellvertretungsinstanz zugewiesen werden kann. Wenn der Delegat aufgerufen wird, ruft er die SendNotification Methode mit der bereitgestellten Nachricht auf.

Instanziieren von Delegaten durch Konvertierung von Methodengruppen

Die Methodengruppenkonvertierung ist eine kurze Möglichkeit zum Erstellen einer Delegateninstanz, indem direkt auf eine Methode verwiesen wird, ohne explizit eine Delegateninstanz zu erstellen. Die Verwendung der Methodengruppenkonvertierung ist nützlich, wenn Sie eine Delegateninstanz erstellen möchten, die auf eine bestimmte Methode verweist, ohne dass ein expliziter Stellvertretungskonstruktor erforderlich ist. Mit der Methodengruppenkonvertierung können Sie eine Methode direkt einem Delegattyp zuweisen, ohne eine Stellvertretungsinstanz explizit zu erstellen. Diese Möglichkeit ist nützlich, wenn die Methodensignatur mit der Signatur des Delegaten übereinstimmt, da sie übersichtlicheren und präziseren Code ermöglicht.


public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        // Create an instance of the delegate using a method group conversion for a named method
        Notify notifyMethodGroup = NotificationService.SendNotification;

        // Invoke the delegate
        notifyMethodGroup("Hello from Method Group!");

    }
}

public static class NotificationService
{
    // Method that matches the delegate's signature
    public static void SendNotification(string message)
    {
        Console.WriteLine("Notification sent: " + message);
    }
}

In diesem Beispiel wird veranschaulicht, wie Sie eine Stellvertretungsinstanz mithilfe einer Methodengruppenkonvertierung erstellen. Die SendNotification Methode wird direkt der Delegateninstanz notifyMethodGroupzugewiesen, sodass sie mit einer Nachricht aufgerufen werden kann. Wenn der Delegat aufgerufen wird, ruft er die SendNotification Methode mit der bereitgestellten Nachricht auf.

Instanziieren von Delegaten mit anonymen Methoden

Mit anonymen Methoden können Sie eine Methode inline definieren, ohne sie explizit zu benennen. Diese Möglichkeit ist nützlich für kurzlebige Vorgänge oder wenn Sie das Verhalten direkt an der Verwendungsstelle definieren möchten. Anonyme Methoden können zum Erstellen von Delegateninstanzen verwendet werden, ohne eine separate Methode zu definieren. Die Verwendung anonymer Methoden ermöglicht präziseren Code und kann die Lesbarkeit in bestimmten Szenarien verbessern.


public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        // Create an instance of the delegate using an anonymous method
        Notify notifyAnonymous = delegate (string message) { Console.WriteLine("Anonymous notification: " + message); };

        // Invoke the delegate
        notifyAnonymous("Hello from Anonymous Method!");

    }
}

In diesem Beispiel wird veranschaulicht, wie eine Delegateninstanz mithilfe einer anonymen Methode erstellt wird. Die anonyme Methode delegate (string message) { Console.WriteLine("Anonymous notification: " + message); } definiert das Verhalten des Delegaten direkt im Code und ermöglicht es, ihn mit einer Nachricht aufzurufen. Wenn der Delegat aufgerufen wird, wird der in der anonymen Methode definierte Code ausgeführt.

Instanziieren von Delegaten mit Lambda-Ausdrücken

Lambda-Ausdrücke sind eine präzise Methode zum Definieren anonymer Methoden. Sie ermöglichen es Ihnen, Stellvertretungsinstanzen zu erstellen, ohne eine Methode explizit zu definieren. Diese Möglichkeit ist nützlich für kurzlebige Vorgänge oder wenn Sie das Verhalten direkt an der Verwendungsstelle definieren möchten.


public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        // Create an instance of the delegate using a lambda expression
        Notify notifyLambda = (message) => Console.WriteLine("Lambda notification: " + message);

        // Invoke the delegate
        notifyLambda("Hello from Lambda!");
    }
}

In diesem Beispiel wird veranschaulicht, wie eine Delegateninstanz mithilfe eines Lambda-Ausdrucks erstellt wird. Der Lambda-Ausdruck (message) => Console.WriteLine("Lambda notification: " + message) definiert das Verhalten des Delegaten direkt, sodass er mit einer Nachricht aufgerufen werden kann. Wenn der Delegat aufgerufen wird, wird der im Lambda-Ausdruck definierte Code ausgeführt.

Einzelne und Multicast-Delegate aufrufen

Delegate können wie normale Methoden aufgerufen werden. Wenn ein Delegat aufgerufen wird, ruft er die(n) Methode(n) auf, auf die er verweist, und übergibt alle Argumente, die in der Signatur des Delegaten angegeben sind. Der Aufruf eines Delegaten ähnelt dem direkten Aufruf einer Methode.

Delegaten können kombiniert werden, um Multicast-Delegaten zu erstellen, wodurch mehrere Methoden mit einem einzigen Aufruf ausgeführt werden können. Die Möglichkeit zum Multicast ist nützlich, wenn Sie mehrere Aktionen ausführen möchten, z. B. mehrere Ereignisabonnenten benachrichtigen oder mehrere Methoden in einer bestimmten Reihenfolge ausführen möchten.

Mehrere Objekte können einer Stellvertretungsinstanz mithilfe des + Operators zugewiesen werden. Der Multicast-Delegat enthält eine Liste der zugewiesenen Delegaten. Wenn der Multicast-Delegat aufgerufen wird, ruft er die Delegaten in der angegebenen Reihenfolge in der Liste auf. Es können nur Stellvertretungen desselben Typs kombiniert werden.

Der - Operator kann verwendet werden, um einen Komponenten-Delegat aus einem Multicast-Delegat zu entfernen.

Im folgenden Beispiel wird veranschaulicht, wie Stellvertretungen mithilfe des + Operators kombiniert und eine Stellvertretung mithilfe des - Operators entfernt werden:


using System;

namespace DelegateExamples;

// Define a custom delegate that has a string parameter and returns void.
delegate void CustomCallback(string s);

class TestClass
{
    // Define two methods that have the same signature as CustomCallback.
    static void Hello(string s)
    {
        Console.WriteLine($"  Hello, {s}!");
    }

    static void Goodbye(string s)
    {
        Console.WriteLine($"  Goodbye, {s}!");
    }

    static void Main()
    {
        // Declare instances of the custom delegate.
        CustomCallback hiDel, byeDel, multiDel, multiMinusHiDel;

        // Initialize the delegate object hiDel that references the
        // method Hello.
        hiDel = Hello;

        // Initialize the delegate object byeDel that references the
        // method Goodbye.
        byeDel = Goodbye;

        // The two delegates, hiDel and byeDel, are combined to
        // form multiDel.
        multiDel = hiDel + byeDel;

        // Remove hiDel from the multicast delegate, leaving byeDel,
        // which calls only the method Goodbye.
        multiMinusHiDel = (multiDel - hiDel)!;

        Console.WriteLine("Invoking delegate hiDel:");
        hiDel("Elize Harmsen");

        Console.WriteLine("Invoking delegate byeDel:");
        byeDel("Mattia Trentini");

        Console.WriteLine("Invoking delegate multiDel:");
        multiDel("Peter Zammit");

        Console.WriteLine("Invoking delegate multiMinusHiDel:");
        multiMinusHiDel("Lennart Kangur");
    }
}

/* Output:
Invoking delegate hiDel:
  Hello, Elize Harmsen!
Invoking delegate byeDel:
  Goodbye, Mattia Trentini!
Invoking delegate multiDel:
  Hello, Peter Zammit!
  Goodbye, Peter Zammit!
Invoking delegate multiMinusHiDel:
  Goodbye, Lennart Kangur!
*/

In diesem Beispiel wird das Erstellen eines Multicast-Delegaten veranschaulicht, indem zwei Delegaten (hiDel und byeDel) mithilfe des +-Operators kombiniert werden. Der kombinierte Delegat (multiDel) ruft beide Methoden auf, wenn er aufgerufen wird. Der - Operator wird verwendet, um einen der Delegaten aus dem Multicastdelegat zu entfernen, sodass nur der andere Delegat aufgerufen werden kann.

Die Ausgabe zeigt die Ergebnisse des Aufrufens der einzelnen Delegierten und verdeutlicht, wie ein Multicast-Delegate funktioniert.

Häufige Szenarien für die Verwendung von Stellvertretungen

Stellvertretungen sind vielseitig und können in verschiedenen Szenarien verwendet werden, um die Flexibilität und Wartung von Code zu verbessern. Sie sind in Situationen hilfreich, in denen Sie Methoden als Parameter übergeben, Rückrufmechanismen implementieren oder Ereignishandler erstellen müssen.

Nachfolgend finden Sie einige häufige Szenarien, in denen Stellvertretungen verwendet werden:

Sortieren und Filtern: Delegaten können verwendet werden, um Vergleichsfunktionen an Sortier- und Filtermethoden zu übergeben. Mit diesem Prozess können Sie die Kriterien zum Sortieren oder Filtern einer Auflistung von Objekten dynamisch angeben. Sortieren Sie beispielsweise eine Liste von Bankkunden nach verschiedenen Kriterien wie Name, Kontostand oder Kunden-ID.
Rückrufmethoden: Stellvertretungen werden häufig verwendet, um Rückrufmethoden zu implementieren. Diese Funktion ist in Szenarien hilfreich, in denen eine Methode eine andere Methode aufrufen muss, sobald ein bestimmter Vorgang abgeschlossen ist. Beispielsweise können Sie einen Delegat verwenden, um den Abschluss einer Datenverarbeitungsaufgabe zu benachrichtigen.
Asynchrone Programmierung: Delegaten werden verwendet, um asynchrone Methoden aufzurufen. Diese Funktion ist nützlich für das Ausführen von Aufgaben, die möglicherweise eine lange Zeit dauern, z. B. Datei-E/A-Vorgänge oder Netzwerkanforderungen. Mit Delegaten können Sie die Methode angeben, die aufgerufen werden soll, sobald der asynchrone Vorgang abgeschlossen ist.
Ereignisbehandlung: Delegate sind die Grundlage für Ereignisse in C#. Sie ermöglichen es Ihnen, Ereignishandler zu definieren, die beim Auftreten eines Ereignisses aufgerufen werden können. Beispielsweise können Sie in einer Bankanwendung Stellvertretungen verwenden, um Kunden zu benachrichtigen, wenn eine Transaktion abgeschlossen ist.
Implementieren von Entwurfsmustern: Stellvertretungen werden in verschiedenen Entwurfsmustern verwendet, z. B. das Strategiemuster, in dem Sie das Verhalten einer Methode zur Laufzeit dynamisch ändern können, indem Sie verschiedene Stellvertretungsimplementierungen übergeben.

Hinweis

Das Ereignisbehandlungsszenario wird in einem separaten Modul sowie einer Einführung in die Verwendung von Ereignissen in C#-Apps behandelt.

Wichtige Punkte

Stellvertretungsinstanzen können mit benannten Methoden, Methodengruppenkonvertierung, anonymen Methoden oder Lambda-Ausdrücken erstellt werden.
Delegate können wie normale Methoden aufgerufen werden und können kombiniert werden, um Multicast-Delegaten zu erstellen.
Stellvertretungen werden in verschiedenen Szenarien verwendet, z. B. Sortieren und Filtern, Rückrufmethoden, asynchrone Programmierung, Ereignisbehandlung und Implementieren von Entwurfsmustern.

Feedback

War diese Seite hilfreich?