Language: Deutsch English















Last Update: 2017 - 03 - 20





Tutorial zur Ereignisbehandlung in Access (Teil 1) - Erste Schritte für Anfänger

von Philipp Stiefel, ursprünglich veröffentlicht am 30.12.2015


Lustiger Spielzeugroboter, article header image

Ereignisse sind eine wunderbare Sache. Wenn du in einer modernen Entwicklungsumgebung (IDE, Integrated Development Environment) anfängst zu programmieren, verwendest du anfangs wahrscheinlich Ereignisbehandlung ohne zu wissen, dass Ereignisse existieren. - Das war zumindest so, als ich mit dem Programmieren angefangen habe. - Aber nach einer Weile, wenn du mehr Erfahrung gesammelt hast, wirst du immer mehr die Mächtigkeit in dem Konzept der Ereignisse sehen.

Ereignisse sind ein elementarer Teil der modernen, objektorientierten Programmierung.

Du kannst zwar sehr weit mit der VBA Programmierung kommen, ohne je über Ereignisse nachzudenken, aber ich glaube, dass Du ein versierterer Programmierer werden kannst, wenn du ein paar Details über sie weißt. Es wird dir helfen, besseren, eleganteren und saubereren Code zu schreiben.

Was ist ein Ereignis?

Ereignisse sind…, nun Ereignisse die vom den Objekten in deinem Entwicklungsframework, in diesem Fall Access, bereitgestellt werden. In Access haben nur die Objekte der Benutzeroberfläche Ereignisse, also Formulare, ihre Steuerelemente und Berichte. Aber die Objekte aus anderen Objektbibliotheken, die du als Verweise zu deinem VBA-Projekt hinzufügen kannst, können ebenfalls Ereignisse haben. Ein Ereignis findet z.B. statt, wenn ein Button geklickt wird, ein Formular geöffnet wird, oder eine Textbox auf einen neuen Wert aktualisiert wird.

Es gibt hunderte von vordefinierten Ereignissen in Access und während deine Access Anwendung von einem Benutzer verwendet wird, werden ständig Ereignisse ausgelöst.

Ereignisse werden zwar ständig ausgelöst, aber solange du keine Ereignisbehandlung in der Anwendung vorgenommen hast, haben diese keinerlei Auswirkungen. Um ein Ereignis zu behandeln, kannst du entweder ein Makro oder VBA Code zur Ereignisbehandlung verwenden. Eine VBA Prozedur, die mit einem Ereignis verbunden ist, wird Ereignisprozedur genannt. Das Makro oder die VBA Prozedur, die an ein Ereignis gebunden ist, wird jedes Mal ausgeführt, wenn dieses Ereignis eintritt.

Einfache Ereignisbehandlung

Lass uns nun eine einfache Beispielanwendung erstellen, um die Konzepte der Ereignisbehandlung in diesem Artikel zu veranschaulichen.

Ich schlage vor, du erstellst eine neue Access Desktop Datenbank als Beispielprojekt. Dann klickst du in dem „Erstellen“-Ribbon-Tab auf Formularentwurf. Ein neues Formular öffnet sich jetzt in der Entwurfsansicht. Dann fügst du einen neuen Button („Befehlsschaltfläche“) hinzu, indem du den Button in der „Steuerelemente“-Toolbox anwählst (1) und dann einen Bereich auf dem Formular markierst, in dem der Button erstellt werden soll (2). – Falls dann der Befehlsschaltflächen-Assistent erscheint, klickst du auf „Abbrechen“. – Im Moment wollen wir lernen, wie man die Ereignisbehandlung selbst erstellt und nicht wie man einen Assistenten bedient.

Falls das Eigenschaftsfenster nicht sichtbar ist, dann blende es mit einem Klick auf den Ribbon Button „Eigenschaftenblatt“ im „Entwurf“-Tab ein (3). Wenn du nun den Button auf dem Formular anwählst werden die Eigenschaften dieses Buttons in dem Eigenschaftenfenster angezeigt. Aktiviere nun den die Registerkarte „Alle“. In der Liste der Eigenschaften trage jetzt „btnMyButton“ als Name ein und trage auch eine Beschriftung ein (4). Die Beschriftung von Steuerelementen ist üblicherweise für die Programmierung nicht wichtig, sondern sollte für dich bzw. deine Benutzer aussagefähig sein.

Screenshot eines Access Formulars in der Entwurfsansicht

Ich empfehle dringend, dass Du dir angewöhnst, aussagefähige Namen für die Steuerelemente eines Formulars zu vergeben. Mindestens jedes Steuerelement, das du im VBA Code ansprechen willst sollte einen aussagefähigen Namen haben. Es gibt nichts irritierenderes, als im VBA Code zu sehen dass das Steuerelement „Text123“ angesprochen wird, ohne den geringsten Hinweis darauf was für ein Steuerelement dies im Kontext der Anwendung ist.

Dann gehe zu der Registerkarte „Ereignis“ des Eigenschaftsfensters und finde das „Beim Klicken“-Ereignis. Dieses Ereignis findet immer dann statt, wenn der Button geklickt wird. Du kannst jetzt für diese Eigenschaft entweder mit dem Dropdown ein vordefiniertes Makro auswählen, oder du klickst auf den kleinen Button mit den drei Punkten um eine neue Ereignisbehandlung zu erstellen.

Screenshot des Eigenschaftsblattes in der Formular-Entwurfsansicht

Ein Makro zu Ereignisbehandlung

Du kannst jetzt im „Generator auswählen“ Dialog entweder den Makro-Generator oder den Code-Generator auswählen. Der Ausdrucksgenerator macht keinen Sinn im Kontext der Ereignisbehandlung.

Ich mag Makros nicht, denn sie sind zu eingeschränkt für ernsthafte Programmierung, aber der Vollständigkeit halber las uns zuerst ein Makro zur Ereignisbehandlung erstellen. - Um das zu tun, klicke auf Makro-Generator in dem Dialog.

In dem „Neue Aktion hinzufügen“-Kombinationsfeld (1) des Makro-Generators wähle „Meldungsfeld“ (ich verwende dafür ab hier den englischen Begriff „Messagebox“). Dann trage einen Message Text (2) und einen Titel (3) ein. Danach klicke „Speichern“ (4) und dann „Schließen“ (5). Dies speichert dieses Makro als eingebettetes Makro zusammen mit dem Button im Formular.

Screenshot des Access Makro-Generators

Nun speichere das Formular ab und wechsle zur „Formularansicht“ des Formulars. Klicke auf den Button und beobachte, dass eine Message Box mit dem Text und Titel angezeigt wird, den du im Makro-Generator eingetragen hast.

Eine VBA Ereignisprozedur

VBA ist so viel vielseitiger als Makros. Daher konzentrieren wir uns von hier an darauf, wie man Ereignisse mit VBA Code behandelt.

Wiederhole die Schritte aus dem letzten Absatz, um ein neues Formular zu erstellen und einen Button hinzuzufügen. Denk daran wieder einen Namen für den Button („btnMyButton“) festzulegen.

Dann gehe erneut zu dem „Beim Klicken“-Ereignis in dem Eigenschaftsfenster. Klicke wieder auf den kleinen Button mit den drei Punkten und wähle jetzt aber den Code-Generator in dem „Generator auswählen“-Dialog.

Es öffnet sich jetzt die VBA Entwicklungsumgebung. Wenn du bereits VBA Code geschrieben hast, dann waren deine ersten Codezeilen in Microsoft Access wahrscheinlich Teil einer Ereignisprozedur. Wenn nicht, dann werden sie es gleich sein…

Prozedurdeklaration einer VBA Ereignisprozedur

Dies ist die noch leere Prozedurdeklaration für eine Ereignisprozedur. Setzte nun den Cursor zwischen diese beiden Zeilen und schreibe das folgende.

MsgBox "Meldung aus VBA", , "VBA Ereignisprozedur"

Wechsle jetzt wieder zu dem Formular-Entwurf im Access-Hauptfenster und schalte dort um auf die Formularansicht. Dann klicke auf deinen Button und diese Messagebox mit dem gerade eingefügten Text wird angezeigt. – Gratulieren, du hast gerade deine erste Ereignisprozedur in VBA geschrieben.

Das „Beim Klicken“-Ereignis eines Button ist sicherlich das mit Abstand am häufigsten verwendete Ereignis. Es gibt jedoch noch viele weitere Ereignisse in Access, die sehr nützlich sind und du wirst viele davon in jeder ernsthaften Anwendung verwenden.

Ereignisprozeduren mit Parametern

Bei manchen Ereignissen reicht es nicht aus, einfach nur zu wissen, dass sie eingetreten sind. Du benötigst noch weitere Informationen, um das Ereignis sinnvoll behandeln zu können.

Ein Beispiel für ein solches Ereignis ist das „Bei Taste“-Ereignis eines Textfeld-Steuerelementes (Textbox), das ausgelöst wird, wenn eine Taste auf der Tastatur gedrückt (und wieder losgelassen) wird. In den meisten Fällen ist es nicht ausreichend nur zu wissen, dass eine Taste gedrückt wurde, sondern du möchtest auch genau wissen welche Taste es war.

Für diesen Teil des Tutorials erstelle wieder ein neues Formular in der Entwurfsansicht. Dann wähle diesmal das Textfeld-Steuerelement aus der Steuerelemente-Toolbox aus (1), ziehe es auf das Formular (2) und trage dann in dem Eigenschaftsfenster „txtMyTextbox“ als Namen für das Steuerelement ein (3).

Entwurfsansicht eines eines Access Formulars mit dem Eigenschaftsblatt

Jetzt lass uns annehmen, es gibt die Anforderung an die Anwendung, dass nur ganz bestimmte Zeichen in diese Textbox eingegeben werden dürfen. Nur die Großbuchstaben A, B und C und die Zahlen von 1 bis 6 sollen in dieses Feld eingegeben werden dürfen.

Um einfache Regeln für die Eingabe in einem Steuerelement durchzusetzen, ist eine Gültigkeitsregel üblicherweise angemessener als VBA-Code. Nur komplexe Regeln erfordern eigenen VBA-Code.

Wir können das erreichen, indem wir eine Ereignisprozedur für das „Bei Taste“-Ereignis (KeyPress-Event) der Textbox erstellen. Um das zu tun, suche nach dem „Bei Taste“-Ereignis in dem „Ereignis“-Register des Eigenschaftsfensters der Textbox, klicke wieder den …-Button der und wählen in dem sich öffnenden Dialog den Code Generator aus.

Beachte, dass in der Deklaration der Ereignisprozedur jetzt ein Parameter mit dem Namen KeyAscii vom Typ Integer definiert ist. Dieser Parameter enthält den numerischen ASCII-Code für das Zeichen, dessen Taste auf der Tastatur gedrückt wird, wenn sich der Cursor in der Textbox befindet.

VBA Entwicklungsumgebung mit einer KeyPress-Ereignisprozedur

Dies ermöglicht es uns zu prüfen, welche Taste von dem Benutzer gedrückt wurde, und innerhalb der Ereignisprozedur darauf zu reagieren. Der Code für eine solche Ereignisprozedur könnte in etwa so aussehen.

Private Sub txtMyTextbox1_KeyPress(KeyAscii As Integer) If Not (KeyAscii >= Asc("A") And KeyAscii <= Asc("C") _ Or KeyAscii >= "1" And KeyAscii <= Asc("6")) _ Then MsgBox "Invalid character" End If End Sub

Die Asc-Funktion, die wir in diesem Beispiel verwenden, liefert den numerischen ASCII-Code für das Zeichen, das ihr übergeben wird. Mit dem von der Funktion gelieferten Rückgabewert prüfen wir, ob der Wert von KeyAscii in den Bereich der zulässigen Zeichen fällt.

Jetzt wird immer wenn du (oder ein anderer Benutzer) in der Textbox ein Zeichen eingibst, das nicht eingegeben werden darf, mit einer Message Box auf diesen Sachverhalt hingewiesen. – Oh je, das ist nervtötend!

Ich schlage vor, du schaltest im Access Fenster in die Formularansicht unserer Beispielformular und probierst es selbst aus.

Informationen aus einer Ereignisprozedur an Access zurückliefern

Bisher haben wir in diesem Beispiel ausprobiert, wie wir in unserem Code auf einen Parameter-Wert, der an die Ereignisprozedur übergeben wurde, reagieren können. Unser Weg mit unerwünschten Eingaben umzugehen ist aber noch nicht ideal.

Glücklicherweise habe die Entwickler von Access diese Art von Problem vorhergesehen und dafür vorgesorgt. Der Parameter KeyAscii der KeyPress-Ereignisprozedur wird ByRef übergeben. Das Bedeutet, dass dieser Wert in einer Variable übergeben wird, die bereits von der aufrufenden Access-Umgebung reserviert wurde. Wir können den Wert in dieser Variable innerhalb unserer eigenen Ereignisprozedur verändern und der aufrufende Code in Access selbst kann dann den von uns veränderten Wert sehen und für den weiteren Programmablauf verwenden.

Verändere deinen Code in der Ereignisprozedur wie folgt.

Private Sub txtMyTextbox_KeyPress(KeyAscii As Integer) If Not (KeyAscii >= Asc("A") And KeyAscii <= Asc("C") _ Or KeyAscii >= "1" And KeyAscii <= Asc("6")) _ Then KeyAscii = 0 End If End Sub

Anstatt die nervtötende Messagebox anzuzeigen, setzen wir jetzt den Wert von KeyAscii auf 0. Die 0 ist das ASCII NUL(L) Zeichen und bedeutet etwa überhaupt kein Zeichen. Wenn also jetzt unsere Ereignisprozedur ausgeführt wurde, sieht Access, dass wir den Wert der Variable KeyAscii zu überhaupt kein Zeichen geändert haben und fügt als Konsequenz daraus kein neues Zeichen in die Textbox ein.

Indem wir die Werte von Prozedur-Parameter ändern, können wir das Verhalten von Access im Kontext eines Ereignisses verändern.

Das Vorgehen in diesem Beispiel für die Eingabevalidierung ist nicht ideal für eine echte Anwendung, denn der Benutzer kann immer noch ungültige Eingaben per Copy&Paste in die Textbox einfügen. Es ist natürlich gut Tippfehler bei der Eingabe schon direkt zum erst möglichen Zeitpunkt zu verhindern, aber dieser Ansatz sollte noch mit einer anderen Methode der Eingabevalidierung kombiniert werden.

Dies führt uns direkt zu dem am häufigsten verwendeten Parameter in Access Ereignisprozeduren.

Der Parameter „Cancel“

Der am häufigsten verwendete Parameter in Access Ereignisprozeduren ist wahrscheinlich der „Cancel“-Parameter u.a. im „Vor Aktualisierung“-Ereignis und vielen anderen Ereignissen. Im Kern unterscheidet sich der „Cancel“-Parameter nicht von anderen Parametern, die in der Signatur von Ereignisprozeduren auftauchen, aber er ist so wichtig und wird so häufig verwendet, dass ich ihm einen ganzen Absatz widmen möchte.

Das „Vor Aktualisierung“-Ereignis wird entweder für ein Steuerelement, wie eine Textbox, oder für ein ganzes Formular ausgelöst, nachdem neue oder geänderte Daten eingegeben wurden, aber bevor diese endgültig in dem Steuerelement (z.B. der Textbox) oder in dem Datensatz der im Formular angezeigt wird, gespeichert wurden.

Das „Vor Aktualisierung“-Ereignis ist ideal für erweiterte Eingabevalidierung. In einem Formular kannst du die Eingaben in mehreren Feldern zusammen überprüfen, um festzustellen, ob die Daten für den Datensatz als Ganzes gültig sind. Genauso kannst du aber auch nur die Daten in einer einzelnen Textbox überprüfen, wenn der Benutzer das Eingabefeld verlassen möchte, aber bevor die Daten gespeichert sind.

Wenn du den „Cancel“-Parameter auf Wahr (True, -1) setzt, wird die Datenaktualisierung für ein Steuerelement oder ein Formular unterbrochen und die geänderten Daten werden nicht gespeichert. Da die neu eingegeben Daten in dem betroffenen Steuerelement oder Formular verloren gehen würden, wenn nur das Speichern der Daten abgebrochen werden würde, wird auch die Benutzeraktion, die die Aktualisierung ausgelöst hat (z.B. verlassen des Steuerelementes oder Wechsel des aktuellen Datensatzes im Formular), abgebrochen.

Wir sollten das Abbrechen der Aktualisierung idealerweise mit einer Messagebox kombinieren, um den Benutzer über das Problem zu informieren.

Um das in unserem Beispielformular zu implementieren, schalte wieder zu Entwurfsansicht des Formulars um und suche nach dem Ereignis „Vor Aktualisierung“ in dem Eigenschaftsblatt des Formulars. Erstelle eine neue VBA-Ereignisbehandlung für dieses Ereignis und schreibe eine Ereignisprozedur ähnlich dieser hier.

Private Sub txtMyTextbox_BeforeUpdate(Cancel As Integer) Dim x As Integer Dim retVal As Boolean Dim strInput As String If Not IsNull(Me.txtMyTextbox.Value) Then strInput = Me.txtMyTextbox.Value For x = 1 To Len(strInput) If Not (Asc(Mid(strInput, x, 1)) >= Asc("A") And Asc(Mid(strInput, x, 1)) <= Asc("C") _ Or Asc(Mid(strInput, x, 1)) >= "1" And Asc(Mid(strInput, x, 1)) <= Asc("6")) _ Then Cancel = True MsgBox "Invalid data in 'MyTextbox'" Exit For End If Next End If End Sub

Dies unterscheidet sich gar nicht so sehr von unserer ursprünglichen Validierungsprozedur im „Bei Taste“-Ereignis, außer dass wir jetzt die kompletten, in die Textbox eingegebenen, Daten verarbeiten müssen. Um das zu tun, untersuchen wir jetzt jedes einzelne Zeichen, das sich im Moment in der Textbox befindet und prüfen ob es den Gültigkeitskriterien entspricht.

Wir verwenden die Len-Funktion um die Gesamtlänge der Zeichen im Feld zu ermitteln um in einer For-Schleife mit der Mid-Funktion jedes einzelne Zeichen zu extrahieren und in der gleichen Weise zu validieren, wie bei dem vorhergehenden „Bei Taste“-Beispiel.

Nachdem du diese VBA-Prozedur fertig hast, wechsle wieder zu der Formularansicht und füge per Copy&Paste einen ungültigen Wert, wie „XYZ999“ in das Textbox-Steuerelement ein und verlasse dann das Steuerelement. – Wie du siehst, können wir zwar nicht verhindern, dass die ungültigen Daten erstmal in das Steuerelement eingefügt werden, aber es ist nicht möglich das Steuerelement zu verlassen und die Daten zu speichern.

Die Reihenfolge von Ereignissen

Bei manchen Ereignissen, wie z.B. den Ereignissen „Vor Aktualisierung“ und „Nach Aktualisierung“, ist es einfach zu erraten, wann genau sie auftreten. Bei anderen Ereignissen, wie den Ereignissen „Beim Öffnen“, „Beim Laden“, „Beim Schließen“ und „Bei Entladen“ ist es alles andere als intuitiv nur anhand des Namens genau zu verstehen, wann diese Ereignisse auftreten.

Es ist elementar zu wissen, wann genau ein Ereignis eintritt. Dies ist weitgehend offensichtlich bei Ereignissen wie „Beim Klicken“ oder „Bei Taste“, aber wesentlich weniger offensichtlich bei vielen anderen nützlichen Ereignissen. Lies immer die Dokumentation zu den Ereignissen die du benutzen möchtest.

Die Details der Ereignisreihenfolge sprengen den Rahmen dieses Artikels. Ich verweise daher auf den sehr informativen Artikel über die Ereignisreihenfolge auf der Microsoft Office Support Webseite.

Beispiel-Code Download

Ich habe die Datenbank, die ich bei der Erstellung dieses Artikels verwendet habe in ein ZIP-Archiv gepackt. Hier kannst du die Bespieldatenbank herunterladen.

Feedback willkommen

Ich hoffe dieser Artikel hat dir die Ereignisbehandlung mit VBA in Access etwas näher gebracht. Du kannst mir gerne Feedback per Email senden.

Wenn Dir der Artikel gefallen hat, dann teile ihn doch mit deinen Kontakten in deinem bevorzugten Sozialen Netzwerk.

Share this article: Share on Facebook Tweet Share on LinkedIn Share on XING

Abonniere meinen Newsletter

*

Ich werde Deine Email-Addresse niemals weitergeben. Du kannst den Newsletter jederzeit abbestellen.



© 1999 - 2016 by Philipp Stiefel