Ereignisse (C# und Java im Vergleich)
Aktualisiert: November 2007
Mithilfe von Ereignissen benachrichtigt eine Klasse die Benutzer eines Objekts, sobald mit diesem Objekt etwas Wesentliches geschieht, zum Beispiel wenn auf ein Steuerelement der grafischen Benutzeroberfläche (GUI) geklickt wird. Diese Benachrichtigung wird als Auslösen eines Ereignisses bezeichnet. Das Objekt, das ein Ereignis auslöst, wird als Quelle oder Absender des Ereignisses bezeichnet.
Im Gegensatz zur Ereignisbehandlung in Java, die durch Implementieren der benutzerdefinierten Listenerklassen ausgeführt wird, können C#-Entwickler für die Ereignisbehandlung Delegaten verwenden. Ein Delegat ist ein Typ, der eine Methode kapselt. Sobald ein Delegat mit einer Methode initialisiert wird, verhält er sich genau wie diese Methode und kann mit dem ()-Operator aufgerufen werden. Delegaten ähneln C++-Funktionszeigern, sind aber typsicher.
Wie im folgenden Beispiel kann der Delegat wie jede andere Methode mit Parametern und Rückgabewerten verwendet werden:
public delegate int ReturnResult(int x, int y);
Weitere Informationen zu Delegaten finden Sie unter Delegaten (C#-Programmierhandbuch).
Genauso wie Ereignisse verfügen Methoden über eine Signatur, die einen Namen und eine Parameterliste umfasst. Diese Signatur wird durch einen delegate-Typ definiert. Beispiel:
public delegate void MyEventHandler(object sender, System.EventArgs e);
Üblicherweise stellt der erste Parameter bei der Windows-Benutzeroberflächenprogrammierung das Objekt dar, das auf die Quelle des Ereignisses verweist, und der zweite Parameter enthält die ereignisbezogenen Daten. Von C# wird dieser Aufbau allerdings nicht gefordert oder erzwungen. Eine Ereignissignatur kann das Format jeder gültigen Delegatsignatur besitzen, solange sie void zurückgibt.
Ein Ereignis kann wie im folgenden Beispiel mit dem event-Schlüsselwort deklariert werden:
public event MyEventHandler TriggerIt;
Um das Ereignis auszulösen, definieren Sie die Methode, die aufgerufen werden soll, wenn das Ereignis ausgelöst wird. Beispiel:
public void Trigger()
{
TriggerIt();
}
Um ein Ereignis auszulösen, rufen Sie den Delegaten auf, und übergeben Sie die ereignisbezogenen Parameter. Der Delegat ruft dann alle Handler auf, die dem Ereignis hinzugefügt wurden. Jedem Ereignis kann mehr als ein Handler als Empfänger zugewiesen sein. In diesem Fall ruft das Ereignis alle Empfänger automatisch auf. Um ein Ereignis auszulösen, muss es unabhängig von der Anzahl der Empfänger nur einmal aufgerufen werden.
Wenn eine Klasse ein Ereignis empfangen soll, abonnieren Sie dieses Ereignis, indem Sie ihm mit dem Operator += den Delegaten hinzufügen. Beispiel:
myEvent.TriggerIt += myEvent.MyMethod;
Um ein Ereignisabonnement zu löschen, entfernen Sie den Delegaten aus dem Ereignis mithilfe des Operators -=, z. B.:
myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod);
Weitere Informationen zu Ereignissen finden Sie unter Ereignisse (C#-Programmierhandbuch).
.gif "Hinweis") Hinweis: |
|---|
In C# 2.0 können Delegaten sowohl benannte als auch anonyme Methoden kapseln. Weitere Informationen zu anonymen Methoden finden Sie unter Anonyme Methoden (C#-Programmierhandbuch). |
Beispiel
Beschreibung
Im folgenden Beispiel wird ein Ereignis definiert, dem drei Methoden zugeordnet sind. Wenn das Ereignis ausgelöst wird, werden die Methoden ausgeführt. Eine Methode wird anschließend aus dem Ereignis entfernt. Das Ereignis wird erneut ausgelöst.
Code
// Declare the delegate handler for the event:
public delegate void MyEventHandler();
class TestEvent
{
// Declare the event implemented by MyEventHandler.
public event MyEventHandler TriggerIt;
// Declare a method that triggers the event:
public void Trigger()
{
TriggerIt();
}
// Declare the methods that will be associated with the TriggerIt event.
public void MyMethod1()
{
System.Console.WriteLine("Hello!");
}
public void MyMethod2()
{
System.Console.WriteLine("Hello again!");
}
public void MyMethod3()
{
System.Console.WriteLine("Good-bye!");
}
static void Main()
{
// Create an instance of the TestEvent class.
TestEvent myEvent = new TestEvent();
// Subscribe to the event by associating the handlers with the events:
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod1);
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod2);
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod3);
// Trigger the event:
myEvent.Trigger();
// Unsuscribe from the the event by removing the handler from the event:
myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod2);
System.Console.WriteLine("\"Hello again!\" unsubscribed from the event.");
// Trigger the new event:
myEvent.Trigger();
}
}
Ausgabe
Hello!
Hello again!
Good-bye!
"Hello again!" unsubscribed from the event.
Hello!
Good-bye!