Ein Ereignis (englisch event) dient in der Softwaretechnik – bei Entwicklung nach dem ereignisorientierten 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. Ereignisorientierte Programmierung gehört zu den parallelen Programmiertechniken, hat also deren Vor- und Nachteile.

In Computerprogrammen kommt es häufig vor, dass auf Ressourcenanforderungen wie z. B. bei Speicheranforderungen und anderen Gerätezugriffen eine unvorhersagbar lange Zeit gewartet werden muss oder Ereignisse spontan auftreten können, z. B. Mausklicks, das Drücken von Tasten oder Tastenkombinationen oder das Öffnen, das Schließen oder die Größenänderung oder Timer-Abläufe durch den Anwender. Bei älterer Programmierung ohne Ereignisse oder auch mit einem einzigen, sequentiellen Kontrollfluss wird dieses Warten auf das Eintreten des Ereignisses z. B. die erfolgreiche Ressourcenzuweisung über ein aktives, beobachtendes Warten, das auch sogenannte Polling, durchgeführt.

Polling besitzt einige nachteilige Eigenschaften: Da die Programmausführung (scheinbar) solange angehalten wird, bis das Ereignis eintritt, ist die Programm-Leistungsfähigkeit schlechter und ebenso die Antwortzeiten nicht vorhersagbar. Auch kann auf andere Ereignisse, während des beobachtenden Wartens, gar nicht reagiert werden, d. h. diese gehen möglicherweise verloren. Und die Ausführung des beobachtenden Wartens benötigt unvorhersagbar viel Rechenzeit, da dieselbe Handlung – die Prüfung, ob das Ereignis eingetreten ist – unvorhersagbar oft wiederholt werden muss.

In der Programmierung ist ein Eventhandler eine Rückruffunktion, die asynchron arbeitet, sobald ein Ereignis eintritt. Es bestimmt die Aktion, die auf das Ereignis folgt. Der Programmierer schreibt eine Funktion oder Methode, damit diese Aktion ausgeführt werden kann. Ein Ereignis kann ein einzelnes Element der Benutzeroberfläche oder sogar ein HTML-Dokument sein. Ein Ereignis ist ein Element von Anwendungsinformationen aus einer zugrunde liegenden Programmbibliothek.^[1]

Ein Ansatz, um diese Problemsituation effizienter zu lösen, ist die ereignisorientierte Programmierung, die auf einer Inversion of Control basiert. D. h., es wird nicht mehr im Haupt-Kontrollfluss auf das Eintreten des Ereignisses gewartet (der Hauptkontrollfluss hat die Kontrolle), sondern dem Ereignis wird ein eigener Kontrollfluss zugeordnet (häufig realisiert als Thread), der eigenständig beim Eintreten des Ereignisses aktiv wird und Einfluss auf den Hauptkontrollfluss nehmen kann (siehe parallele Programmierung).

Technische Umsetzungen dieser Idee seit den 1960ern sind die Rückruffunktion (mit Event-spezifischem Unterprogramm) und (Hardware-)Interrupts, welche die Nachteile des Pollings vermeiden, dafür jedoch zwangsläufig die potentiellen Probleme des parallelen Programmierens hervorrufen.

Beschrieben werden können Ereignisbehandlungstechniken in Entwurfsmuster-Terminologie auch als Beobachter (Observer).

Das Konzept der Ereignisorientierten Programmierung eignet sich auch 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 (OOP) 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 (englisch event handler, deutsch Ereignishandler) und die Ereignisse selbst werden dann als Objekte modelliert. Es kann jedoch argumentiert werden, dass über die Idee des entkoppelten Messagings zwischen Objektentitäten die ereignisorientierte Programmierung schon immer implizit ein Teilkonzept von OOP war.^[2]

Ereignisse können je nach Programmierumgebung entweder nur eine Ereignisbehandlungsroutine (wie z. B. in Object Pascal) oder beliebig viele Ereignisbehandlungsroutinen (wie z. B. in Visual Basic, C# oder wie beim Signal-Slot-Konzept) aufrufen.

Es besteht die Möglichkeit, ein Ereignis als „verarbeitet“ zu kennzeichnen (consume). Nachfolgende Ereignisbehandler können dies abfragen und verzichten dann auf eine weitere Verarbeitung.

Mit Microsoft Access können 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 abhängig ist:

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

• bei Formularen: Öffnen, Anzeigen, vor Eingabe, Ändern, 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 Microsoft 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 oder unsichtbar gemacht oder mit bestimmten Inhalten ausgegeben werden.

Für solche Zusatzfunktionen legt der Programmierer, gegebenenfalls von einem Software-Assistenten unterstützt, eine Prozedur an, in der für das jeweilige Objekt und den jeweiligen Ereignistyp ein passender Code (in Visual Basic for Applications) hinterlegt wird (siehe Abbildung). 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).

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()

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

Formular = function()
{
    this.send = new Event();
}

function sendToServer()
{
    alert("Die Anfrage wurde an den Server gesendet.");
}

function sayThankYou()
{
    alert("Vielen Dank für das Ausfüllen des Formulars.");
}

var umfrage = new Formular();
umfrage.send.addListener(this, "sendToServer");
umfrage.send.addListener(this, "sayThankYou");
umfrage.send();

Das folgende Codebeispiel in Microsofts Variante der Programmiersprache C++ zeigt die Verwendung von Ereignisbehandlungsmethoden (englisch event handlers) und die Verknüpfung mit einem dazu passenden Ereignis. Für das Verknüpfen und Trennen der Ereignisse werden spezifische Funktionen in C++ verwendet. Ereignisattribute [event_source(native)] und [event_receiver(native)] in nativem C++ sind nicht mit Standard-C++ kompatibel. Um sie mit MSVC kompilieren zu können, muss der /permissive- Konformitätsmodus ausgeschaltet sein.^[3] Mit anderen C++-Compilern funktioniert dieses Beispiel nicht.

#include <iostream>

using namespace std;

// Ereignisquellenklasse
[event_source(native)]
class EventSource
{
public:
    // Methodendeklaration, die die Ereignisbehandlungsmethoden (event handlers) als Ereignis deklariert
    __event void MyEvent(int count, int wordCount);
};

// Ereignisempfängerklasse
[event_receiver(native)]
class EventReceiver
{
public:
    // Ereignisbehandlungsmethode (event handler)
    // Sie hat dieselbe Methodensignatur wie das Ereignis MyEvent
    void MyEventHandler1(int count, int wordCount)
    {
        cout << "MyEventHandler1 asserts that Wikipedia is an important encyclopedia with " << count << " articles and " << wordCount << " words." << endl; // Ausgabe auf der Konsole
    }

    // Ereignisbehandlungsmethode (event handler)
    // Sie hat dieselbe Methodensignatur wie das Ereignis MyEvent
    void MyEventHandler2(int count, int wordCount)
    {
        cout << "MyEventHandler2 asserts that Uncyclopedia is a funny encyclopedia with " << count << " articles and " << wordCount << " words." << endl; // Ausgabe auf der Konsole
    }

    // Diese Methode verknüpft das Ereignis (Zeiger pEventSource) mit den Ereignisbehandlungsmethoden MyEventHandler1 und MyEventHandler2
    void hookEvent(EventSource* pEventSource)
    {
        // Aufrufe der intrinsischen C++ Funktion __hook
        __hook(&EventSource::MyEvent, pEventSource, &EventReceiver::MyEventHandler1);
        __hook(&EventSource::MyEvent, pEventSource, &EventReceiver::MyEventHandler2);
    }

    // Diese Methode trennt das Ereignis (Zeiger pSource) von den Ereignisbehandlungsmethoden MyEventHandler1 und MyEventHandler2
    void unhookEvent(EventSource* pEventSource)
    {
        // Aufrufe der intrinsischen C++ Funktion __unhook
        __unhook(&EventSource::MyEvent, pEventSource, &EventReceiver::MyEventHandler1);
        __unhook(&EventSource::MyEvent, pEventSource, &EventReceiver::MyEventHandler2);
    }
};

// Hauptfunktion die das Programm ausführt
int main()
{
    // Variablendeklaration für Ereignisquelle und Ereignisempfänger
    EventSource eventSource;
    EventReceiver eventReceiver;

    eventReceiver.hookEvent(&eventSource); // Aufruf der Methode hookEvent in der Klasse EventReceiver
     // Löst das Ereignis MyEvent aus. Dadurch werden die Ereignisbehandlungsmethoden MyEventHandler1 und MyEventHandler2 jeweils aufgerufen.
    __raise eventSource.MyEvent(1000000, 100000000);
    __raise eventSource.MyEvent(100000, 10000000);
    eventReceiver.unhookEvent(&eventSource); // Aufruf der Methode unhookEvent in der Klasse EventReceiver
     // Löst das Ereignis MyEvent aus. Die Ereignisbehandlungsmethoden werden nicht aufgerufen, weil das Ereignis in der Methode unhookEvent getrennt wurde.
    __raise eventSource.MyEvent(10000, 1000000);
}

Beim Ausführen der Funktion main wird folgender Text auf der Konsole ausgegeben:

MyEventHandler2 asserts that Uncyclopedia is a funny encyclopedia with 1000000 articles and 100000000 words.
MyEventHandler1 asserts that Wikipedia is an important encyclopedia with 1000000 articles and 100000000 words.
MyEventHandler2 asserts that Uncyclopedia is a funny encyclopedia with 100000 articles and 10000000 words.
MyEventHandler1 asserts that Wikipedia is an important encyclopedia with 100000 articles and 10000000 words.

• Complex Event Processing
• Smart UI

1. ↑ TechTarget: What is an event handler?
2. ↑ Stefan Ram: Dr. Alan Kay on the Meaning of Object-Oriented Programming. fu-berlin.de, 23. Juli 2003, abgerufen am 4. Juni 2012 (englisch): „OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things.“ 
3. ↑ Microsoft: Event handling in native C++