Delegates und Ereignisse in C#

In C# bilden Delegates und Events die Grundlage der ereignisgesteuerten Programmierung. Ein delegate ist ein typsicherer Verweistyp, der auf eine Methode zeigen kann. Ein event ermöglicht es einer Klasse, der Außenwelt mitzuteilen, dass „ein bestimmtes Ereignis eingetreten ist“. Durch diese Mechanismen können lose gekoppelte Architekturen aufgebaut und Methoden dynamisch ausgeführt werden.

Was ist ein Delegate?

Ein Delegate speichert Referenzen auf Methoden mit einer bestimmten Signatur (Parameter und Rückgabetyp). Mit anderen Worten: Delegates sind „Strukturen, die Methoden wie Variablen tragen können“. Einer einzelnen Delegate-Variablen können mehrere Methoden zugewiesen werden, die bei Bedarf aufgerufen werden.

// Definition eines Delegates
public delegate void Notify(string message);

class Program
{
    static void SendEmail(string message)
    {
        Console.WriteLine("E-Mail gesendet: " + message);
    }

    static void SendSms(string message)
    {
        Console.WriteLine("SMS gesendet: " + message);
    }

    static void Main()
    {
        Notify notifyHandler;

        // Methode dem Delegate zuweisen
        notifyHandler = SendEmail;
        notifyHandler("Das Meeting ist um 10:00 Uhr.");

        // Weitere Methode an dasselbe Delegate anhängen (Multicast)
        notifyHandler += SendSms;
        notifyHandler("Neues Produkt ist online!");
    }
}

In diesem Beispiel ruft das notifyHandler-Delegate sowohl die SendEmail- als auch die SendSms-Methode auf. Delegates ermöglichen es, Ereignisse dynamisch an verschiedene Methoden weiterzuleiten.

Was ist ein Event?

Ein Event ist ein Mechanismus, der signalisiert, dass eine Aktion eingetreten ist. Es basiert in der Regel auf einem Delegate. Das Schlüsselwort event wird zur Deklaration verwendet und kann extern nur mit += (abonnieren) oder -= (abbestellen) genutzt werden. Dadurch wird sichergestellt, dass das Event nur innerhalb der Klasse ausgelöst werden kann.

public class Button
{
    // Event-Definition (EventHandler ist ein Standard-Delegatetyp)
    public event EventHandler? Click;

    public void SimulateClick()
    {
        Console.WriteLine("Button wurde geklickt!");
        // Event auslösen
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        var btn = new Button();

        // Event abonnieren
        btn.Click += (s, e) => Console.WriteLine("Ereignis: Button wurde geklickt.");

        btn.SimulateClick();
    }
}

Hier veröffentlicht die Klasse Button ein Click-Event. Der abonnierte Code (Lambda-Ausdruck) wird ausgeführt, wenn das Event ausgelöst wird. Dieser Ansatz wird häufig in UI-Anwendungen wie WinForms und WPF verwendet.

EventHandler und EventArgs

In C# ist der am häufigsten verwendete Standard-Delegate für Events der EventHandler. Mit EventArgs oder davon abgeleiteten Klassen können zusätzliche Informationen über das Ereignis übergeben werden.

public class OrderEventArgs : EventArgs
{
    public int OrderId { get; }
    public decimal Amount { get; }

    public OrderEventArgs(int orderId, decimal amount)
    {
        OrderId = orderId;
        Amount = amount;
    }
}

public class OrderService
{
    public event EventHandler<OrderEventArgs>? OrderCreated;

    public void CreateOrder(int id, decimal amount)
    {
        Console.WriteLine($"Bestellung erstellt (ID={id}, Betrag={amount})");

        // Event auslösen
        OrderCreated?.Invoke(this, new OrderEventArgs(id, amount));
    }
}

class Program
{
    static void Main()
    {
        var service = new OrderService();

        service.OrderCreated += (s, e) =>
        {
            Console.WriteLine($"Benachrichtigung: Bestellung erhalten (#{e.OrderId}, {e.Amount} EUR)");
        };

        service.CreateOrder(101, 250m);
    }
}

In diesem Beispiel löst die Klasse OrderService das OrderCreated-Event aus, sobald eine neue Bestellung erstellt wird. Der abonnierte Code erhält die Bestellinformationen über EventArgs.

Wann Delegates und Events verwenden?

• Delegates: Um Methoden als Parameter zu übergeben, Callbacks zu erstellen oder mehrere Methoden aufzurufen.
• Events: Um Benutzerinteraktionen (Button-Klicks, Formular schließen usw.) oder Statusänderungen in Geschäftsprozessen mitzuteilen.

TL;DR

Ähnliche Artikel