{"id":55000425,"date":"2024-04-01T00:00:00","date_gmt":"2024-04-23T12:50:12","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=425"},"modified":"2024-04-23T11:13:31","modified_gmt":"2024-04-23T11:13:31","slug":"ereignisse_in_klassen_programmieren","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/ereignisse_in_klassen_programmieren\/","title":{"rendered":"Ereignisse in Klassen programmieren"},"content":{"rendered":"

\"\"Eines der wichtigsten Features vieler eingebauter Klassen in den Office-Anwendungen sind die Ereignisse. Damit können wir Ereignisprozeduren implementieren, mit denen wir beispielsweise auf das Anklicken von Schaltflächen, dem Öffnen oder Schließen von Dokumenten oder dem Wechseln eines Tabellenblatts in einem Excel-Arbeitsblatt reagieren können. Wenn man selbst Klassen programmiert, findet sich früher oder später ein Anlass, dieser ein eigenes Ereignis hinzuzufügen, dass durch eine bestimmte Aktion ausgelöst wird. Dieser Artikel zeigt, wir wie solche Ereignisse programmieren und auslösen und wie wir diese in Form von Ereignisprozeduren in den Klassen implementieren, welche das entsprechende Objekt instanziiert haben.<\/b><\/p>\n

Ereignisse in Klassenmodulen<\/h2>\n

Wer schon einmal eine Ereignisprozedur beispielsweise für das Anklicken einer Schaltfläche, das Öffnen eines Word-Dokuments, das Markieren eines Ranges in Excel et cetera programmiert hat, kennt zumindest schon einmal die Verbraucherseite von Ereignissen.<\/p>\n

Hier können wir zum Beispiel in Excel in der Klasse Tabelle1 <\/b>eines Excel-Dokuments im Codefenster im linken Kombinationsfeld den Eintrag Worksheet <\/b>auswählen, was im rechten Kombinationsfeld automatisch die Standardmethode SelectionChange <\/b>selektiert. Dadurch wird automatisch die Ereignisprozedur Worksheet_SelectionChange <\/b>angelegt, mit der wir in diesem Fall die Adresse des neu ausgewählten Bereichs im Direktbereich des VBA-Editors ausgeben (siehe Bild 1).<\/p>\n

\"Ereignisprozedur<\/p>\n

Bild 1: Ereignisprozedur beim Ändern der Markierung in einem Excel-Arbeitsblatt<\/span><\/b><\/p>\n

Nun schauen wir uns die andere Seite an, auf der wir Ereignisse definieren, die wir dann wiederum als Verbraucher nutzen können. Wozu aber überhaupt Ereignisse? Weil wir benutzerdefiniert auf bestimmte Ereignisse reagieren können wollen. Stellen wir uns beispielsweise vor, wir wollen den Benutzer unserer Klasse clsAdresse <\/b>darüber informieren, wenn die Methode Leeren <\/b>erfolgreich aufgerufen wurde. Dann können wir das einfach erledigen, indem wir der Methode Leeren<\/b> eine entsprechende Meldung hinzufügen:<\/p>\n

Public Sub <\/span>Leeren()\n     ...\n     m_Land = \"\"\n     MsgBox<\/span> \"Die Eigenschaften der Adresse wurden geleert.\", _\n         vbOKOnly + vbExclamation, \"Adresse geleert\"\nEnd Sub<\/span><\/pre>\n
Rufen wir die Methode nun von einer anderen Prozedur aus auf, erscheint diese Meldung (siehe Bild 2).<\/p>\n
\"Meldung<\/p>\n
Bild 2: Meldung beim Aufruf einer Methode<\/span><\/b><\/p>\n
Nun stellen wir uns vor, wir wollen die Meldung dieser Klasse nicht innerhalb der Klasse verdrahten, sondern dem Entwickler, der diese Klasse in seinem Code verwendet (meist wir selbst), die Möglichkeiten geben wollen, individuell auf dieses Ereignis zu reagieren.<\/p>\n
Das ist ein Beispieleinsatzzweck für die Bereitstellung eines Ereignisses. Und das gelingt in zwei Schritten:<\/p>\n
    \n
  • Als Erstes definieren wir das Ereignis mit dem Schlüsselwort Event<\/b>, dem Namen des Ereignisses und gegebenenfalls den zu verwendenden Parametern.<\/li>\n
  • Als zweites fügen wir in diesem Beispiel der Methode Leeren Code hinzu, der dieses Ereignis auslöst. Dabei verwenden wir das Schlüsselwort RaiseEvent <\/b>und übergeben die Werte für die Parameter, welche das Verbraucher des Ereignisses erhalten soll.<\/li>\n<\/ul>\n
    In der Klasse fügen wir oben die Deklaration des Ereignisses ein:<\/p>\n
    Public <\/span>Event NachDemLeeren()<\/pre>\n
    Der Prozedur Leeren <\/b>fügen wir am Ende den Befehl RaiseEvent <\/b>hinzu und geben den Namen des Ereignisses als Parameter an:<\/p>\n
    Public Sub <\/span>Leeren()\n     ...\n     RaiseEvent NachDemLeeren\nEnd Sub<\/span><\/pre>\n
    Dieses wird, wie in Bild 3 dargestellt, per IntelliSense angeboten. Dadurch geschieht nun erst einmal nichts.  Wir können die obige Prozedur AdressblockLeeren <\/b>starten und die Methode Leeren <\/b>aufrufen, aber wir erhalten keinen sichtbaren Effekt. Das ist logisch, denn wir haben das Ereignis noch nicht implementiert.<\/p>\n
    \"Deklarieren<\/p>\n
    Bild 3: Deklarieren und Auslösen eines Ereignisses<\/span><\/b><\/p>\n
    Keine Ereignisprozeduren ohne das Schlüsselwort WithEvents<\/h2>\n
    Der Schritt ist auch in dieser Konstellation nicht möglich, denn um die Ereignisse einer Klasse zu implementieren, müssen die Klasse, die das Ereignis enthält, mit einem bestimmten Schlüsselwort deklarieren. Dieses heißt WithEvents<\/b>. Es gibt noch weitere Bedingungen: Diese Deklaration kann nicht innerhalb einer Prozedur erfolgen, sondern muss im Kopf des Moduls hinterlegt werden. Außerdem können wir das Schlüsselwort WithEvents <\/b>nicht innerhalb von Standardmodulen verwenden, sondern nur in Klassenmodulen. Versuchen wir dies dennoch, erhalten wir direkt einen Kompilierfehler wie in Bild 4.<\/p>\n
    \"Fehler<\/p>\n
    Bild 4: Fehler beim Versuch, WithEvents in einem Standardmodul zu verwenden<\/span><\/b><\/p>\n
    Warum aber benötigen wir dieses Schlüsselwort überhaupt? Wenn wir in Word auf die Ereignisse des Document<\/b>-Objekts zugreifen oder in Access auf ein Form<\/b>– oder Button<\/b>-Element, können wir das auch einfach ohne WithEvents<\/b>-Schlüsselwort erledigen.<\/p>\n
    Das ist dann allerdings reiner Zufall: Bei Word waren wir dann vermutlich im Klassenmodul zum Word-Dokument und in Access im Klassenmodul des Formulars, in dem sich auch die Schaltfläche befand, deren Ereignisse wir implementiert haben. Da es sich um das Klassenmodul des Objekts selbst handelt, stehen dort alle Ereignisse standardmäßig zur Verfügung.<\/p>\n
    Würden wir jedoch die Ereignisse dieses Word-Dokuments oder Access-Formulars von einem anderen Klassenmodul aus implementieren wollen, müssten wir dazu auch erst einmal eine Objektvariable anlegen, die wir mit dem Schlüsselwort WithEvents<\/b> deklarieren. Und wir müssten diese auch noch mit einem Verweis auf das entsprechende Objekt versehen.<\/p>\n
    Genauso ist es bei der Klasse clsAdresse<\/b>: Diese verwenden wir von einer anderen Klasse aus, also müssen wir die Objektvariable mit dem Schlüsselwort WithEvents <\/b>versehen – und das gelingt wiederum nur in Klassenmodulen. Welche Art von Klassenmodul wir hier verwenden, spielt allerdings keine Rolle. Wir können die Klasse sowohl innerhalb des Klassenmoduls eines eingebauten Elements wie einem Word-Dokument, einem Excel-Workbook oder einem Access-Formular deklarieren, aber auch in einem anderen alleinstehenden Klassenmodul.<\/p>\n
    Damit Du die Beispiele dieses Artikels in allen Office-Anwendungen ausprobieren kannst, erstellen wir zu diesem Zweck ein neues Klassenmodul namens clsAdressenVerwalten<\/b>.<\/p>\n
    Diese fügen wir die Deklaration der Objektvariablen ein, der wie die Instanz der Klasse clsAdresse <\/b>zuweisen wollen:<\/p>\n
    Private <\/span>WithEvents objAdresse As <\/span>clsAdresse<\/pre>\n
    Außerdem fügen wir eine Methode hinzu, die das Objekt erstellt und seine Eigenschaften füllt:<\/p>\n
    Public Sub <\/span>AdresseErstellen()\n     Set<\/span> objAdresse = New<\/span> clsAdresse\n     With<\/span> objAdresse\n         .Anrede = \"Herr\"\n         .Vorname = \"André\"\n         .Nachname = \"Minhorst\"\n         .Strasse = \"Borkhofer Str. 17\"\n         .PLZ = \"47137\"\n         .Ort = \"Duisburg\"\n         .Land = \"Deutschland\"\n     End With<\/span>\nEnd Sub<\/span><\/pre>\n
    Schließlich fügen wir den Aufruf der Methode Leeren <\/b>der Adresse hinzu:<\/p>\n
    Public Sub <\/span>AdresseLeeren()\n     objAdresse.Leeren\nEnd Sub<\/span><\/pre>\n
    Um die Klasse clsAdressenVerwalten <\/b>wiederum zu instanziieren, legen wir in einem Standardmodul die Deklaration der Objektvariablen zu dieser Klasse an:<\/p>\n
    Dim <\/span>objAdressenVerwalten As <\/span>clsAdressenVerwalten<\/pre>\n
    Diese instanziieren wir. Außerdem rufen wir nacheinander die Methoden AdresseErstellen <\/b>und AdresseLeeren <\/b>auf:<\/p>\n
    Public Sub <\/span>AdressenSteuern()\n     Set<\/span> objAdressenVerwalten = New<\/span> clsAdressenVerwalten\n     objAdressenVerwalten.AdresseErstellen\n     objAdressenVerwalten.AdresseLeeren\nEnd Sub<\/span><\/pre>\n
    Damit geschieht nun allerdings nichts Sichtbares. Was wir erreichen wollten, ist die Implementierung des Ereignisses NachDemLeeren <\/b>der Klasse clsAdresse<\/b>. Dazu zeigen wir nun das Codefenster zur Klasse clsAdressenVerwalten <\/b>an. Da wir hier die Objektvariable objAdresse <\/b>mit dem Schlüsselwort WithEvents <\/b>deklariert haben, können wir nun Ereignisprozeduren auf Basis der für diese Klasse definieren Ereignisse implementieren.<\/p>\n
    Das gelingt wie folgt:<\/p>\n
      \n
    • Wir wählen im linken Kombinationsfeld des Klassenmoduls clsAdressenVerwalten <\/b>den Eintrag objAdresse <\/b>aus.<\/li>\n
    • Im rechten Kombinationsfeld wird nun automatisch das einzige verfügbare Ereignis ausgewählt.<\/li>\n
    • Dies legt wiederum eine neue Ereignisprozedur auf Basis der in der Klasse clsAdresse <\/b>angegebenen Deklaration an.<\/li>\n<\/ul>\n
      Diesen Ablauf können wir uns in Bild 5 ansehen. Wir finden nun eine Ereignisprozedur vor, die wir mit einer Anweisung füllen können – beispielsweise der Anzeige einer Meldung:<\/p>\n
      \"Anlegen<\/p>\n
      Bild 5: Anlegen einer Ereignisprozedur für ein benutzerdefiniertes Ereignis<\/span><\/b><\/p>\n
      Private Sub <\/span>objAdresse_NachDemLeeren()\n     MsgBox<\/span> \"Adresse geleert\"\nEnd Sub<\/span><\/pre>\n
      Damit steht es nun offen, das Ereignis NachDemLeeren <\/b>von der aufrufenden Instanz aus mit den gewünschten Anweisungen zu füllen.<\/p>\n
      Vorteil von Ereignisprozeduren bei benutzerdefinieren Ereignissen<\/h2>\n
      Der große Vorteil dieser Vorgehensweise ist der Gleiche wie bei den Ereignissen eingebauter Elemente der jeweiligen Office-Anwendung. Wir können je nach Anwendungszweck individuell festlegen, was beim Auslösen eines der Ereignisse geschehen soll. Damit machen wir unsere Klasse viel flexibler, als wenn wir diesen Code direkt in der Klasse einfügen. Wir können die Ereignisse der Klasse nun mit verschiedenen Anweisungen versehen, die je nach Anwendungsfall ausgeführt werden sollen.<\/p>\n
      Ereignisse mit Parametern<\/h2>\n
      Als Nächstes wollen wir ein Ereignis mit verschiedenen Parametern hinzufügen. Dazu bietet sich der Zeitpunkt an, an dem wir schon die Methode zum Leeren der Adresse in der Klasse clsAdresse <\/b>aufgerufen haben, aber das Leeren noch nicht stattgefunden hat.<\/p>\n
      Wir wollen mit diesem Ereignis erstens einige der Werte der zu leerenden Adresse bereitstellen (wir könnten das auch mit allen Werten tun, aber wir wollen die Übersichtlichkeit bewahren). Zweitens wollen wir einen Parameter nutzen, um das Leeren gegebenenfalls abzubrechen. Dabei handelt es sich um einen sogenannten Rückgabeparameter.<\/p>\n
      Die Deklaration des Ereignisses sieht wie folgt aus:<\/p>\n
      Public <\/span>Event VorDemLeeren(strAnrede As String<\/span>, _\n     strVorname As String<\/span>, strNachname As String<\/span>, _\n     bolCancel As Boolean<\/span>)<\/pre>\n
      Der Übersichtlichkeit halber fügen wir alle Deklarationen von Ereignissen hinter der Deklaration ein und vor den übrigen Elementen wie Methoden oder Funktionen.<\/p>\n
      Aufruf des Ereignisses mit Parametern integrieren<\/h2>\n
      Wo integrieren wir den Aufruf dieses Ereignisses nun? Auch wenn dieses VorDemLeeren <\/b>heißt, gehört es in die Methode Leeren<\/b>. Dort fügen wir den Aufruf gleich zu Beginn ein, also bevor das eigentliche Leeren der Eigenschaften der Klasse beginnt. Mit den ersten drei Parametern wollen wir die aktuellen Werte für die Anrede, den Vornamen und den Nachnamen an die Implementierung des Ereignisses in der instanziierenden Klasse übergeben. Der vierte Parameter übergibt die Variable bolCancel<\/b>, die wir zuvor deklarieren. Dieser Boolean<\/b>-Parameter enthält standardmäßig den Wert False<\/b>.<\/p>\n
      Wenn der Benutzer diesen Parameter in der Implementierung des Ereignisses nicht auf True <\/b>einstellt, behält dieser den Wert False<\/b>. Das ist wichtig zu wissen, denn wir untersuchen diesen Wert direkt im Anschluss an das Auslösen des Ereignisses VorDemLeeren <\/b>mit RaiseEvent<\/b>. Wenn bolCancel <\/b>dann den Wert True <\/b>aufweist, soll das Leeren der Adresse abgebrochen werden. Dazu fügen wir hinter das Auslösen des Ereignisses VorDemLeeren <\/b>mit der Anweisung RaiseEvent <\/b>eine If…Then<\/b>-Bedingung ein, die prüft, ob bolCancel <\/b>den Wert True <\/b>hat. Ist das der Fall, wird die Prozedur mit Exit Sub <\/b>verlassen (siehe Listing 1).<\/p>\n
      Public Sub <\/span>Leeren()\n     Dim <\/span>bolCancel As Boolean<\/span>\n     RaiseEvent VorDemLeeren(m_Anrede, m_Vorname, m_Nachname, bolCancel)\n     If <\/span>bolCancel = True<\/span> Then<\/span>\n         Exit Sub<\/span>\n     End If<\/span>\n     m_Firma = \"\"\n     m_Anrede = \"\"\n     m_Vorname = \"\"\n     m_Nachname = \"\"\n     m_Strasse = \"\"\n     m_PLZ = \"\"\n     m_Ort = \"\"\n     m_Land = \"\"\n     RaiseEvent NachDemLeeren\nEnd Sub<\/span><\/pre>\n
      Listing 1: Integration des Ereignisses, das vor dem Leeren der Klasse ausgelöst werden soll<\/span><\/b><\/p>\n
      Ereignis mit Parametern implementieren<\/h2>\n
      Zum Implementieren dieses neuen Ereignisses wählen wir wieder das Objekt objAdresse <\/b>aus dem linken Kombinationsfeld des Codefensters der Klasse clsAdressenVerwalten <\/b>aus. Im rechten Kombinationsfeld finden wir nun einen weiteren Eintrag namens VorDemLeeren<\/b>, den wir ebenfalls selektieren. Damit fügen wir eine neue Ereignisprozedur zur Klasse clsAdressenVerwalten <\/b>hinzu, die wie in Bild 6 aussieht.<\/p>\n
      \"Anlegen<\/p>\n
      Bild 6: Anlegen einer weiteren Ereignisprozedur, diesmal mit Parametern<\/span><\/b><\/p>\n
      Diese enthält alle in der Definition in der Klasse clsAdresse <\/b>festgelegten Parameter. Diese Prozedur füllen wir nun wie in Listing 2. Hier nutzen wir gleich alle Parameter. Die ersten drei, strAnrede<\/b>, strVorname <\/b>und strNachname<\/b>, integrieren wir in den Text einer MsgBox<\/b>-Funktion, in der wir den Benutzer fragen, ob die Adresse mit diesen Daten gelöscht werden soll. Klickt der Benutzer auf Ja<\/b>, wird bolCancel <\/b>auf False <\/b>gesetzt und die Adresse wird geleert. In diesem Fall erscheint anschließend auch noch die Meldung aus der Ereignisprozedur objAdresse_NachDemLeeren<\/b>, dass die Adresse geleert wurde. Klickt er auf Nein<\/b>, erhält bolCancel <\/b>den Wert True <\/b>und die Adresse wird beibehalten.<\/p>\n
      Private Sub <\/span>objAdresse_VorDemLeeren(strAnrede As String<\/span>, strVorname As String<\/span>, strNachname As String<\/span>, _\n         bolCancel As Boolean<\/span>)\n     If MsgBox<\/span>(\"Adresse ''\" & strAnrede & \" \" & strVorname & \" \" & strNachname & \"'' leeren?\", vbYesNo + vbExclamation, _\n         \"Adresse leeren?\") = vbYes Then\n         bolCancel = False<\/span>\n     Else<\/span>\n         bolCancel = True<\/span>\n     End If<\/span>\nEnd Sub<\/span><\/pre>\n
      Listing 2: Implementierung des Ereignisses VorDemLeeren des Objekts objAdresse<\/span><\/b><\/p>\n
      Zusammenfassung und Ausblick<\/h2>\n
      Damit haben wir die Programmierung von Ereignissen in Klassen besprochen. In weiteren Artikeln schauen wir uns konkrete Anwendungsfälle an.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Eines der wichtigsten Features vieler eingebauter Klassen in den Office-Anwendungen sind die Ereignisse. Damit können wir Ereignisprozeduren implementieren, mit denen wir beispielsweise auf das Anklicken von Schaltflächen, dem Öffnen oder Schließen von Dokumenten oder dem Wechseln eines Tabellenblatts in einem Excel-Arbeitsblatt reagieren können. Wenn man selbst Klassen programmiert, findet sich früher oder später ein Anlass, dieser ein eigenes Ereignis hinzuzufügen, dass durch eine bestimmte Aktion ausgelöst wird. Dieser Artikel zeigt, wir wie solche Ereignisse programmieren und auslösen und wie wir diese in Form von Ereignisprozeduren in den Klassen implementieren, welche das entsprechende Objekt instanziiert haben.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66022024,662024,44000025],"tags":[],"yst_prominent_words":[66062029],"class_list":["post-55000425","post","type-post","status-publish","format-standard","hentry","category-66022024","category-662024","category-VBAProgrammierung"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t