Ereignis (Programmierung)

Ein Ereignis (engl. event) dient in der Softwaretechnik – bei Entwicklung nach dem ereignisorientieren Programmierparadigma – zur Steuerung des Programmflusses. Das Programm wird nicht linear durchlaufen, sondern es werden spezielle Ereignisbehandlungsroutinen (engl. listener, observer, event handler) immer dann ausgeführt, wenn ein bestimmtes Ereignis auftritt (vergleiche Rückruffunktion). Dieses Konzept wird durch das Entwurfsmuster Observer (Beobachter) beschrieben. Ein verwandtes Konzept sind Interrupts.

Ereignisse eignen sich besonders gut zur Implementierung von grafischen Benutzeroberflächen, wobei hier die Ereignisse meist Aktionen des Benutzers sind, wie zum Beispiel das Drücken einer Taste oder das Anklicken einer Schaltfläche. Ein anderes wichtiges Anwendungsfeld sind Computersimulationen, die so aufgebaut werden, dass Zustandsänderungen nur von Ereignissen ausgelöst werden, und ihrerseits Ereignisse auslösen (siehe ereignisorientierte Simulation).

Ereignisorientierte Programmierung lässt sich gut mit den Konzepten der objektorientierten Programmierung kombinieren: Objekte definieren dann nicht mehr nur Eigenschaften und Methoden, sondern sind auch Ereignisquellen und bieten die Möglichkeit, die Ereignisbehandlung zu beeinflussen. Auch die Ereignisbehandlungsroutinen (engl. event handler, eingedeutscht der Event-Handler, etwa „Ereignisverarbeiter“ oder „Ereignisbehandler“) und die Ereignisse selbst werden dann als Objekte modelliert.

Ereignisse können je nach Programmierumgebung entweder nur eine Ereignisbehandlungsroutine (wie z. B. in Borland Delphi) oder beliebig viele Ereignisbehandlungsroutinen (wie beim Signal-Slot-Konzept) aufrufen.

Beispiele

Beispiel zu MS Access

Der Benutzer kann u. a. Formulare und Berichte mit jeweils darin enthaltenen Feldern entwerfen. Zusätzlich gibt es 'Bereiche' wie Formularkopf, Berichtskopf, Gruppenkopf und Gruppenfuß (je Gruppenstufe) und Detailbereich, die selbst wiederum Einzelfelder enthalten. Alle diese Begriffe sind Objekte.

Die Verarbeitung für Objekte ist aufgeteilt in funktionale Teileinheiten, deren Ausführung vom Eintritt bestimmter Ereignisse („ereignisorientiert“) abhängig ist:

Definieren von Ereignissen in MS Access (2003)

In Formularen treten die Ereignisse im Wesentlichen durch Aktionen der Benutzeroberfläche auf: Mausaktionen, Eingaben etc. - die von der Access Engine erkannt und behandelt werden. Mögliche Ereignisse sind (zum Beispiel):

• bei Formularen: Öffnen, Anzeigen, vor Eingabe, geändert, Löschen, Schließen ...
• bei Formular-Eingabefeldern: wenn geändert, beim Berühren mit Mauszeiger, beim Klicken, beim Doppelklicken, bei Taste UP
• bei Befehlsschaltflächen: beim Hingehen, beim Klicken, beim Doppelklicken

Bei Berichten initiiert die Engine die Ereignisse datenabhängig, ähnlich den Steuerungsprinzipien der normierten Programmierung. Mögliche Ereignisse sind (zum Beispiel):

• für den ganzen Bericht: Beim Öffnen / Schließen, bei Seitenanfang, bei leeren Daten
• für Berichtsbereiche wie Gruppenkopf und -fuß: beim Drucken, beim Formatieren

Zusätzlich zur Standardverarbeitung je Ereignistyp durch MS Access kann der Programmierer für jedes Objekt und für jeden Ereignistyp festlegen, ob etwas Individuelles zu tun ist – und was. Zum Beispiel kann nach dem Ändern eines Eingabefelds eine bestimmte Prüfung vorgenommen werden; beim Öffnen eines Berichts im Fall 'leerer Daten' kann ein Fehlerhinweis angezeigt werden; ein Gruppenfuß kann bei nur 1 Einzelzeile je Gruppe 'unsichtbar' gemacht werden; Datenfelder können sichtbar / unsichtbar gemacht oder mit bestimmten Inhalten ausgegeben werden.

Für solche Zusatzfunktionen legt der Programmierer, ggf. von einem Software-„Assistenten“ unterstützt, eine Prozedur an, in der für das jeweilige Objekt und den jeweiligen Ereignistyp ein passender Code (in VBA) hinterlegt wird; siehe Grafikbeispiel. Bei Eintreten des Ereignisses wird die entsprechende Prozedur ausgeführt. Ist keine Prozedur angelegt, wird das Ereignis in der definierten Grundform verarbeitet oder es erfolgt keine Verarbeitung (z. B. bei Berühren des Objekts mit dem Mauszeiger).

Implementierung eines Ereignissystems

Der folgende Pseudocode soll eine einfache Implementierung eines Ereignissystems zeigen:

Function Event
  listener = []
  call = function()
    for each parallel (l in listener)
      l()

Anwendungsbeispiel:

Klick = new Event
Klick.listener.add(regenGeräusch)
Klick.listener.add(regenBild)
Klick()

In JavaScript umgesetzt könnte dies beispielsweise folgendermaßen aussehen:

var Event = function() {
  var e = function() { call(arguments); };
  e.toString = function () { return "[event Event]"; }
  var listener = [];
  e.getListener = function() { return listener; }
  e.addListener = function(obj, l) {
    if (typeof obj[l] !== "function") return false;
    for (var i = 0; i < listener.length; i++) {
      if (listener[i][0] === obj && listener[i][1] === l)
        return false;
    }
    listener.push([obj, l]);
    return true;
  };
  e.removeListener = function(obj, l) {
    if (typeof obj[l] !== "function") return false;
    for (var i = 0; i < listener.length; i++) {
      if (listener[i][0] === obj && listener[i][1] === l)
        { listener.splice(i,1); return true; }
    }
    return false;
  };
  var call = function(argsArray) {
    for each (var l in listener) {
      l[0][l[1]].apply(l[0], argsArray);
    }
  };
  return e;
}

Dieses einfache Ereignissystem bietet eine linear ablaufende Ereignisbehandlung und ermöglicht das An- und Abmelden von Ereignisbehandlungsroutinen. Für parallele Ausführung plant das W3C sogenannte Web Workers. Das dargestellte Ereignissystem kann wie folgt verwendet werden:

Formular = function() {
  this.abschicken = new Event();
  ⋮
}
 
function zumServerSenden() {
  ⋮
}
 
function DankeSagen() {
  alert("Vielen Dank für das Ausfüllen des Formulars.");
}
 
var umfrage=new Formular();
umfrage.abschicken.addListener(this, "zumServerSenden");
umfrage.abschicken.addListener(this, "DankeSagen");
umfrage.abschicken();

Siehe auch

• Complex Event Processing