imported>Thomas Dresler: Kommasetzung

2024-04-14T08:41:59Z

Kommasetzung

Neue Seite

Ein '''Ereignis''' ({{enS|''event''}}) dient in der [[Softwaretechnik]] – bei Entwicklung nach dem ereignisorientierten [[Programmierparadigma]] – zur Steuerung des [[Programmfluss]]es. 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 [[Parallele Programmierung|parallelen Programmiertechniken]], hat also deren Vor- und Nachteile.

== Motivation ==
In [[Computerprogramm|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. [[Mausklick|Mausklicks]], das Drücken von [[Tastatur|Tasten]] oder [[Tastenkombination|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 Warten|aktives, beobachtendes Warten]], das auch sogenannte ''[[Polling (Informatik)|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.

== Definition ==
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 (Programmierung)|Funktion]] oder [[Methode (Programmierung)|Methode]], damit diese Aktion ausgeführt werden kann. Ein Ereignis kann ein einzelnes Element der [[Grafische Benutzeroberfläche|Benutzeroberfläche]] oder sogar ein [[HTML-Dokument]] sein. Ein Ereignis ist ein Element von Anwendungsinformationen aus einer zugrunde liegenden [[Programmbibliothek]].<ref>TechTarget: [https://www.techtarget.com/searchapparchitecture/definition/event-handler What is an event handler?]</ref>

== Ereignisorientierte Programmierung ==
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 (Informatik)|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-)[[Interrupt]]s, 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 (Entwurfsmuster)|Beobachter]] (Observer).

== Verwendung ==
Das Konzept der Ereignisorientierten Programmierung eignet sich auch gut zur [[Implementierung]] von [[Grafische Benutzeroberfläche|grafischen Benutzeroberflächen]], wobei hier die Ereignisse meist Aktionen des [[Benutzer]]s sind, wie zum Beispiel das Drücken einer Taste oder das Anklicken einer [[Schaltfläche]]. Ein anderes wichtiges Anwendungsfeld sind [[Computersimulation]]en, 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 [[Objektorientierte Programmierung|objektorientierten Programmierung]] (OOP) kombinieren: [[Objekt (Programmierung)|Objekte]] definieren dann nicht mehr nur [[Eigenschaft]]en und [[Objektorientierte Programmierung|Methoden]], sondern sind auch ''Ereignisquellen'' und bieten die Möglichkeit, die Ereignisbehandlung zu beeinflussen. Auch die Ereignisbehandlungsroutinen ({{EnS|''event handler''}}, {{DeS|''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.<ref>{{cite web|url=http://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_en |title=Dr. Alan Kay on the Meaning of Object-Oriented Programming |author=Stefan Ram |date=2003-07-23 |accessdate=2012-06-04 |language=englisch |publisher=fu-berlin.de|quote=''OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things.''}}</ref>

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 .NET|Visual Basic]], [[C-Sharp|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.

== Beispiele ==

=== Beispiel zu Microsoft Access ===
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 [[Objekt (Programmierung)|Objekte]].

Die Verarbeitung für Objekte ist aufgeteilt in funktionale Teileinheiten, deren Ausführung vom Eintritt bestimmter Ereignisse abhängig ist:
[[Datei:Ereignis Access.png|mini|Definieren von Ereignissen in MS Access (2003)]]

In ''Formularen'' treten die Ereignisse im Wesentlichen durch Aktionen der Benutzeroberfläche auf: Mausereignisse und Eingaben, die von der [[Microsoft Access|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 [[Normierte Programmierung|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 (Programmierung)|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]]).

== Implementierung eines Ereignissystems ==

=== Pseudocode ===
Der folgende [[Pseudocode]] soll eine einfache Implementierung eines Ereignissystems zeigen:

<pre>
Function Event
listener = []
call = function()
for each parallel (l in listener)
l()
</pre>

Anwendungsbeispiel:

<pre>
Klick = new Event
Klick.listener.add(regenGeräusch)
Klick.listener.add(regenBild)
Klick()
</pre>

=== JavaScript ===
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:

<syntaxhighlight lang="javascript">
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();
</syntaxhighlight>

=== C++ ===
Das folgende Codebeispiel in Microsofts Variante der [[Programmiersprache]] [[C++]] zeigt die Verwendung von Ereignisbehandlungsmethoden ({{enS|event handlers}}) und die Verknüpfung mit einem dazu passenden Ereignis. Für das Verknüpfen und Trennen der Ereignisse werden spezifische [[Funktion (Programmierung)|Funktionen]] in C++ verwendet. Ereignisattribute <code>[event_source(native)]</code> und <code>[event_receiver(native)]</code> in nativem C++ sind nicht mit Standard-C++ kompatibel. Um sie mit [[Visual C++|MSVC]] kompilieren zu können, muss der ''/permissive-'' Konformitätsmodus ausgeschaltet sein.<ref>Microsoft: [https://learn.microsoft.com/en-us/cpp/cpp/event-handling-in-native-cpp?view=msvc-170 Event handling in native C++]</ref> Mit anderen C++-Compilern funktioniert dieses Beispiel nicht.<syntaxhighlight lang="c++">
#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);
}

</syntaxhighlight>Beim Ausführen der [[Funktion (Programmierung)|Funktion]] ''main'' wird folgender Text auf der Konsole ausgegeben:<pre>
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.
</pre>

== Siehe auch ==
* [[Complex Event Processing]]
* [[Smart UI]]

== Einzelnachweise ==
<references />

[[Kategorie:Programmierkonzept]]

Ereignis (Programmierung) - Versionsgeschichte

imported>Thomas Dresler: Kommasetzung