C# Delegates: deklarieren, aufrufen, Multicast und Callbacks

Ein Delegate ist ein Typ, der eine Methodensignatur darstellt. Eine Variable eines Delegate-Typs enthält eine Referenz auf eine Methode mit dieser Signatur, und der Aufruf der Variable ruft die Methode auf. So behandelt C# Funktionen als Werte: Du kannst sie speichern, an andere Methoden übergeben und später aufrufen.

using System;

delegate decimal PriceRule(decimal price);

class Program
{
    static decimal HalfPrice(decimal p) => p / 2;
    static decimal MinusTen(decimal p) => p > 10m ? p - 10m : 0m;

    static void Main()
    {
        PriceRule rule = HalfPrice;
        Console.WriteLine(rule(80m));

        rule = MinusTen;
        Console.WriteLine(rule(80m));

        rule = p => p * 0.85m;
        Console.WriteLine(rule.Invoke(80m));
    }
}

Ausgabe:

40
70
68.00

delegate decimal PriceRule(decimal price); deklariert einen neuen Typ, genau wie class. Jede Methode, die ein decimal nimmt und ein decimal zurückgibt, passt dazu. Die Variable rule zeigte nacheinander auf drei verschiedene Methoden, und jeder Aufruf führte die aus, die sie gerade enthielt.

Deklarieren, erzeugen und aufrufen

Eine Delegate-Typdeklaration sieht aus wie eine Methodensignatur mit dem Schlüsselwort delegate davor. Sie steht meist auf Namespace-Ebene neben Klassen oder verschachtelt in einer Klasse.

Es gibt vier Wege, eine Delegate-Instanz zu erzeugen:

PriceRule a = HalfPrice;                             // method group (most common)
PriceRule b = new PriceRule(HalfPrice);              // explicit constructor, same thing
PriceRule c = p => p - 5m;                            // lambda expression
PriceRule d = delegate (decimal p) { return p; };    // anonymous method (C# 2 syntax)

Und zwei Wege, sie aufzurufen, die identisch sind: rule(80m) und rule.Invoke(80m). Der Compiler prüft die Signatur bei der Zuweisung, eine unpassende Methode ist also ein Kompilierfehler und keine Überraschung zur Laufzeit.

Ein Delegate kann auch auf eine Instanzmethode zeigen. Er merkt sich dann sowohl die Methode als auch das Objekt, auf dem sie aufgerufen wird:

using System;

delegate void Notify(string message);

class Mailbox
{
    private readonly string owner;
    public Mailbox(string owner) { this.owner = owner; }

    public void Receive(string message) => Console.WriteLine($"{owner} got: {message}");
}

class Program
{
    static void Main()
    {
        var ana = new Mailbox("Ana");
        Notify notify = ana.Receive;

        notify("Your order shipped");
        Console.WriteLine($"target: {notify.Target.GetType().Name}, method: {notify.Method.Name}");
    }
}

Ausgabe:

Ana got: Your order shipped
target: Mailbox, method: Receive

Target ist das Objekt, auf dem der Delegate die Methode aufruft (null bei einer statischen Methode), und Method beschreibt die Methode. Das Festhalten des Targets bedeutet auch, dass ein Delegate dieses Objekt am Leben hält, was bei Events eine Rolle spielt.

Delegates als Callbacks

Die Hauptaufgabe eines Delegates ist, eine Methode Code aufrufen zu lassen, den ihr Aufrufer ausgewählt hat. Die Methode legt fest, wann etwas passiert; der Aufrufer legt fest, was:

using System;

delegate void ProgressHandler(int percent);

class Program
{
    static void ImportRows(string[] rows, ProgressHandler onProgress)
    {
        for (int i = 0; i < rows.Length; i++)
        {
            // ... import rows[i] ...
            int percent = (i + 1) * 100 / rows.Length;
            onProgress(percent);
        }
    }

    static void PrintBar(int percent)
    {
        Console.WriteLine($"[{new string('#', percent / 10),-10}] {percent}%");
    }

    static void Main()
    {
        string[] rows = { "a", "b", "c", "d" };

        ImportRows(rows, PrintBar);
        ImportRows(rows, p => { if (p == 100) Console.WriteLine("import finished"); });
    }
}

Ausgabe:

[##        ] 25%
[#####     ] 50%
[#######   ] 75%
[##########] 100%
import finished

ImportRows weiß nichts von Konsolen oder Balken. Dieselbe Methode kann einen Fortschrittsbalken, eine Logzeile oder eine UI-Aktualisierung steuern, je nachdem, was der Aufrufer übergibt. List.Sort(Comparison<T>), Array.Find(Predicate<T>), Task.Run(Action) und jeder LINQ-Operator folgen diesem Muster.

Multicast-Delegates: += und -=

Ein Delegate kann mehr als eine Methode enthalten. += hängt eine Methode an seine Aufrufliste an, -= entfernt sie, und der Aufruf des Delegates ruft jede Methode der Reihe nach auf:

using System;

delegate void OrderPlaced(string orderId);

class Program
{
    static void SendConfirmation(string id) => Console.WriteLine($"email sent for {id}");
    static void UpdateStock(string id) => Console.WriteLine($"stock updated for {id}");
    static void NotifyWarehouse(string id) => Console.WriteLine($"warehouse notified for {id}");

    static void Main()
    {
        OrderPlaced handlers = SendConfirmation;
        handlers += UpdateStock;
        handlers += NotifyWarehouse;

        handlers("A-1001");
        Console.WriteLine($"{handlers.GetInvocationList().Length} handlers");

        handlers -= UpdateStock;
        handlers("A-1002");
    }
}

Ausgabe:

email sent for A-1001
stock updated for A-1001
warehouse notified for A-1001
3 handlers
email sent for A-1002
warehouse notified for A-1002

Drei Details von Multicast-Delegates zählen in der Praxis:

• Rückgabewerte: Gibt der Delegate-Typ einen Wert zurück, liefert der Aufruf eines Multicast-Delegates nur das Ergebnis der letzten Methode. Um alle Ergebnisse zu sammeln, durchlaufe GetInvocationList() und rufe jede Methode selbst auf.
• Exceptions: Wirft eine Methode, laufen die übrigen Methoden nicht, und die Exception erreicht den Aufrufer.
• Unveränderlichkeit: Delegates sind unveränderlich. += erzeugt einen neuen Delegate mit längerer Liste und weist ihn der Variable zu, deshalb wirkt sich ein -= auf eine Kopie nicht auf das Original aus.

Ein Lambda mit -= zu entfernen funktioniert nur, wenn du dieselbe Delegate-Instanz übergibst. Dasselbe Lambda zweimal zu schreiben erzeugt zwei verschiedene Delegates, handlers -= id => Log(id); entfernt also nichts. Speichere das Lambda in einer Variable, wenn du es später abmelden willst.

null-Delegates und ?.Invoke

Eine Delegate-Variable ohne Zuweisung ist null, und das Entfernen der letzten Methode mit -= hinterlässt ebenfalls null. Der Aufruf von null wirft NullReferenceException:

using System;

class Program
{
    static void Main()
    {
        Action<string> onSaved = null;

        onSaved?.Invoke("draft.txt");          // nothing happens
        Console.WriteLine("no handler, no crash");

        onSaved += name => Console.WriteLine($"saved {name}");
        onSaved?.Invoke("draft.txt");

        try
        {
            Action<string> missing = null;
            missing("x");
        }
        catch (NullReferenceException e)
        {
            Console.WriteLine(e.GetType().Name);
        }
    }
}

Ausgabe:

no handler, no crash
saved draft.txt
NullReferenceException

?.Invoke ist der Standardweg, einen optionalen Callback aufzurufen. Der Operator ?. kann nicht direkt vor die Klammern gesetzt werden (onSaved?("x") ist keine gültige Syntax), daher ruft das Muster die Methode Invoke des Delegates beim Namen auf, was dasselbe tut wie der Kurzaufruf.

Delegates, Func, Action und Events

Für jede Signatur einen Delegate-Typ zu deklarieren wäre mühsam, deshalb liefert .NET generische mit:

PriceRule aus dem ersten Beispiel hat dieselbe Form wie Func<decimal, decimal>, trotzdem sind beide verschiedene Typen und lassen sich nicht ineinander umwandeln. Selbst zwei eingebaute Typen mit identischer Signatur lassen sich das nicht:

Func<int, bool> isPositive = x => x > 0;
Predicate<int> p = isPositive;
// error CS0029: Cannot implicitly convert type 'System.Func<int, bool>' to 'System.Predicate<int>'

Predicate<int> ok = new Predicate<int>(isPositive);   // wrap it explicitly
Predicate<int> ok2 = x => isPositive(x);              // or with a lambda

Ein Lambda lässt sich in jeden kompatiblen Delegate-Typ umwandeln, APIs nehmen daher meist Lambdas, und die Frage kommt gar nicht auf. Die Seite zu Func und Action behandelt die generische Familie und wann sich eine eigene Deklaration trotzdem lohnt.

Events bauen direkt auf Delegates auf. Ein event-Feld ist ein Multicast-Delegate, bei dem externer Code nur += und -= verwenden darf, ihn aber nie aufrufen oder überschreiben kann. Die Abonnentenliste im Multicast-Beispiel oben ist genau das, was ein Event für dich verwaltet, mit diesem zusätzlichen Schutz. Events haben eine eigene Seite.