<\/p>\n
Wer die Office-Anwendungen Access, Excel, Outlook, PowerPoint oder Word mit VBA programmiert, kann eine Menge erreichen, ohne jemals eine eigene Klasse zu programmieren. Wer sich die gesamten Möglichkeiten eröffnen will, kommt jedoch irgendwann nicht mehr um die Programmierung benutzerdefinierter Klassen herum. Dieser Artikel zeigt verschiedene Szenarien auf, wann man benutzerdefinierte Klassen programmieren und darauf basierende Objekte instanziieren kann und soll. Dabei geht es um Begriffe wie Eigenschaften, Methoden, Ereignisse und darum, wo und wie man Klassen einsetzt.<\/b><\/p>\n
Wer in den VBA-Projekten von Outlook oder von Dokumenten auf Basis von Access, Excel, PowerPoint oder Word programmiert, ahnt es vielleicht manchmal nicht, aber tatsächlich programmiert man fast zwangsläufig innerhalb von Klassenmodulen. Das Modul Projekt1<\/b>, das angezeigt wird, wenn man das VBA-Projekt von Outlook öffnet, das Modul ThisDocument <\/b>in Word, die Module DieseArbeitsmappe <\/b>oder Tabelle1 <\/b>in Excel oder auch die Module, die man in Access beim Anlegen von Ereignisprozeduren für Formulare, Steuerelemente oder Berichte verwendet, sind allesamt Klassenmodule.<\/p>\n
Diese sind jedoch mit der jeweiligen Anwendung (Outlook) beziehungsweise mit dem jeweiligen Dokument oder dem Element verknüpft, in deren Kontext sie geöffnet werden. Dadurch ergeben sich einige Vorteil: Wir können nämlich in diesen direkt auf einige Elemente des jeweiligen Objekts zugreifen. Im Klassenmodul ThisOutlookSession <\/b>von Outlook greifen wir beispielsweise direkt auf die Eigenschaften, Methoden und Ereignisse des Application<\/b>-Objekts zu.<\/p>\n
Im Klassenmodul eines Access-Formulars greifen wir direkt auf die Eigenschaften, Methoden und Ereignisse des jeweiligen Formulars und der enthaltenen Steuerelemente zu. Im Klassenmodul ThisDocument <\/b>eines Word-Dokuments stehen die entsprechenden Elemente des Document<\/b>-Objekts zur Verfügung und in Excel können wir in der Klasse DieseArbeitsmappe <\/b>über die Variable Workbook <\/b>auf die enthaltenen Eigenschaften, Methoden und Ereignisse zugreifen sowie in den Klassen für die einzelnen Tabellen auf das jeweilige Worksheet<\/b>-Element.<\/p>\n
Wenn wir bereits eine solche Vielfalt von eingebauten Elementen haben, warum sollten wir noch benutzerdefinierte Klassen entwickeln? Dazu gibt es verschiedene Gründe, die wir in den folgenden Abschnitten beschreiben. Außerdem sehen wir uns an, warum es in diesem Fällen ein Klassenmodul sein muss und warum es nicht reicht, ein Standardmodul zu verwenden.<\/p>\n
Ein wichtiger Anwendungszweck für Klassen ist schlicht und einfach das Zusammenfassen von Elementen in einer Code-Einheit. Wann immer wir im Code allein Informationen zusammenstellen, die zusammengehören, können wir dies mit einer Klasse erledigen.<\/p>\n
Für diese legen wir dann Eigenschaften fest, mit denen wir die Informationen erfassen können. Sobald wir ein Objekt auf Basis der Klasse erstellt haben, können wir diesem Informationen über die Eigenschaften zuweisen und die Eigenschaften wieder auslesen. Wir können auch dafür sorgen, dass das Objekt seine Eigenschaften selbst füllt – beispielsweise durch das Einlesen eines Datensatzes einer Access-Tabelle, der Daten einer E-Mail oder der Absätze eines Word-Dokuments.<\/p>\n
Auf Basis dieser Eigenschaften können wir nun Methoden bereitstellen, welche die Inhalte der Eigenschaften verarbeiten – beispielsweise, um aus Daten wie Absender, Empfänger, Betreff und Inhalt eine Outlook-E-Mail zu erstellen und diese abzusenden. Oder wir bieten Funktionen an, welche die eingegebenen Eigenschaften in unterschiedlichen Arten verarbeiten.<\/p>\n
So können wir beispielsweise einer Klasse, die eine Adresse in Form der Eigenschaften Firma, Anrede, Vorname, Nachname, Straße, PLZ, Ort und Land aufnimmt, eine Funktion hinzufügen, welche aus diesen Informationen einen Adressblock erstellt, den wir in einem Access-Bericht oder in einem Word-Dokument ausgeben können.<\/p>\n
Ein Beispiel hierfür stellen wir im Artikel Klassen programmieren unter VBA <\/b>(www.vbentwickler.de\/423<\/b>) vor.<\/p>\nGrund für Klassen: Ereignisse bereitstellen<\/h2>\n
Wenn Du selbst Ereignisse bereitstellen möchtest, die ausgelöst werden, wenn bestimmte Dinge in Deinem Code geschehen, sind Klassenmodule die einzige Möglichkeit. Über ein solches Ereignis kannst Du eine Ereignisprozedur implementieren, also eine Prozedur, die mit dem Feuern des Ereignisses gestartet wird und Deinen benutzerdefinierten Code ausführt.<\/p>\n
Nun stellst Du Dir vielleicht die Frage, warum Du nicht direkt dort den auszuführenden Code unterbringen sollst, wo die auslösende Aktion in Deinem Code geschieht. Der Grund ist, dass Du in einer Klasse allgemeine Elemente und Methoden unterbringst, die für jeden Anwendungsfall gleich sein sollen. Es gibt jedoch auch Anteile, die je nach Anwendungsfall unterschiedlich behandelt werden sollen.<\/p>\n
Ein gutes Beispiel dafür ist eine Schaltfläche. Diese erledigt beim Anklicken bereits automatisch Aufgaben – zum Beispiel ändert sie ihre Ansicht in den gedrückten Zustand. Du möchtest aber für jede Schaltfläche individuelle Funktionen programmieren. So soll zum Beispiel eine OK<\/b>-Schaltfläche in einem Formular andere Aktionen ausführen als beispielsweise eine Abbrechen<\/b>-Schaltfläche. Deshalb stellt die Schaltflächen-Klasse für jede einzelne Instanz einer Schaltfläche eine eigene Ereignisprozedur bereit, in der Du die jeweiligen Anweisungen unterbringen kannst.<\/p>\n
Wenn Du selbst eine Klasse programmierst, wird es für Ereignisse ebenfalls zwei Arten von Aktionen geben:<\/p>\n
Nehmen wir an, Du hast eine Klasse programmiert, die das Einlesen von XML-Dateien erledigt. Die Klasse nimmt mit einer Eigenschaft namens Pfad <\/b>den Pfad der einzulesenden XML-Datei entgegen. Eine Methode namens Einlesen<\/b> führt den Einlesevorgang der XML-Datei in ein Objekt des Typs DOMDocument <\/b>durch. Der Inhalt des XML-Dokuments wird dann durch die Eigenschaft XML <\/b>nach außen bereitgestellt. Beim Einlesen kann es vorkommen, dass ein Fehler ausgelöst wird – beispielsweise, weil das Dokument einen Syntaxfehler enthält. Du könntest nun in der Methode Einlesen<\/b> für den Fall eines Fehlers einfach eine Meldung ausgeben. Wenn Du diese Klasse dann in einem anderen Kontext nutzt, wo Du vielleicht keine Meldung erhalten möchtest, sondern den Fehler in einer Protokolldatei erfassen willst, musst Du den Code der Klasse ändern. Damit hast Du dann verschiedene Versionen einer Klasse in Deinen Anwendungen.<\/p>\n
Besser wäre es, wenn Du in der XML-Klasse eine Schnittstelle anbieten würdest, mit der das aufrufende Element abfragen könnte, ob und wann ein Fehler auftritt. Dazu gibt es zwei Möglichkeiten: Du könntest einen eventuellen Fehler mit einem Parameter der Methode Einlesen <\/b>zurückgeben. Wir könnten aber auch ein Ereignis beispielsweise namens Fehler <\/b>in der XML-Klasse definieren, das beim Eintreten eines Fehlers ausgelöst wird und das die Fehlermeldung als Parameter bereitstellt. Auf die Ausgabe einer Meldung beim Auftreten eines Fehlers innerhalb der XML-Klasse verzichten wir nun natürlich.<\/p>\n
Damit könntest Du nun im aufrufenden Element, also beispielsweise im Klassenmodul eines Access-Formulars, das Ereignis implementieren, das beim Einlesefehler ausgelöst wird. Und egal, von wo Du die Klasse nutzt – Du kannst in der Ereignisprozedur immer auf die gewünschte Weise auf den aufgetretenen Fehler reagieren.<\/p>\n
Auf die Programmierung von Ereignissen in Klassen gehen wir im Artikel Ereignisse in Klassen programmieren <\/b>(www.vbentwickler.de\/425<\/b>) genauer ein.<\/p>\nGrund für Klassen: Mehrere Instanzen möglich<\/h2>\n
Wenn Du nicht gerade Ereignisse deklarieren und implementieren möchtest, könnte man argumentieren, dass ein Standardmodul für einige Anwendungszwecke ausreicht, für die man sonst ein Klassenmodul definieren würde. Wir können auch im Standardmodul Eigenschaften und Methoden definieren, die wir dann nutzen.<\/p>\n
Was ein Standardmodul allerdings nicht bietet, ist die Erstellung mehrerer Instanzen. Wenn wir also beispielsweise mit der oben erwähnten XML-Klasse mehrere XML-Dokumente laden und ihren Inhalt abrufbar halten wollten, könnten wir dies mit einem Standardmodul nicht realisieren. Die darin enthaltene Variable zum Speichern des Inhalts des XML-Dokuments würde bei jedem Einlesen einer weiteren XML-Datei überschrieben werden.<\/p>\n
In diesem Fall können wir ein Klassenmodul besser nutzen, weil wir davon ohne Probleme mehrere Instanzen nutzen können. Dazu benötigen wir schlicht mehrere Objektvariablen, die wir dann mit Instanzen der XML-Klasse füllen.<\/p>\n
Wir können dann für jede Objektvariable die Einlesen<\/b>-Methode aufrufen und für jede Objektvariable separat auf den in der XML-Eigenschaft gespeicherten Inhalt des XML-Dokuments zugreifen.<\/p>\nBeliebig viele Instanzen in Collection speichern<\/h2>\n
Wenn wir Instanzen einer Klasse erstellen und diese jeweils in zuvor deklarierten Objektvariablen speichern, ist die Anzahl der Instanzen durch die Anzahl der Objektvariablen begrenzt. Dies ist jedoch in vielen Fällen nicht praktikabel.<\/p>\n
Wenn wir beispielsweise für alle Textfelder in einem Access-Formular jeweils eine Instanz einer Klasse erstellen wollen, welche bestimmte Ereignisse von Textfeldern kapselt, wollen wir nicht auf gut Glück eine bestimmte Menge von Variablen für diese Instanzen deklarieren. Stattdessen deklarieren wir jeweils eine Variable für die Instanz eines Textfeldes und speichern diese nach dem Instanziieren in einer Collection. Danach können wir mit der gleichen Variable eine neue Instanz erstellen und auch diese zur Collection hinzufügen.<\/p>\n
Der erste Vorteil ist, dass wir so beliebig viele Instanzen erstellen können und nicht durch die Anzahl der vorbereiteten Objektvariablen eingeschränkt werden.<\/p>\n
Ein weiterer Vorteil ist, dass wir die Instanzen, falls notwendig, in einer Schleife über alle Elemente der Collection durchlaufen können.<\/p>\n
Es gibt sicherlich Klassen, die speziell für eine Anwendung programmiert werden und die nur dort sinnvoll einsetzbar sind. In vielen Fällen können wir jedoch Code in Klassen organisieren, die wir in vielen verschiedenen Anwendungen nutzen können.<\/p>\n
Wenn wir die Klasse in einer Anwendung erfolgreich eingesetzt haben, kopieren wir diese einfach in die nächste Anwendung und nutzen sie dort. Die Klasse zum Einlesen von XML-Dokumenten und zum Ausgeben des enthaltenen XML-Codes wäre ein solches Beispiel.<\/p>\n
Ein essenzieller Grund, um ein Klassenmodul zu verwenden, ist das Implementieren von Ereignissen anderer Objekte. Wenn wir das Ereignis Fehler <\/b>der oben vorgestellten XML-Klasse implementieren wollen, um im Fehlerfall beim Einlesen eine Fehlermeldung in eine Protokolldatei zu schreiben, können wir dies nur innerhalb eines weiteren Klassenmoduls erledigen.<\/p>\n
Dabei spielt es allerdings keine Rolle, ob wir die Objektvariable in einem eingebauten Klassenmodul anlegen und die Ereignisprozedur dort implementieren oder ob wir das in einem benutzerdefinierten Klassenmodul erledigen.<\/p>\n
Wenn sich die Möglichkeit ergibt, ist es immer leichter, das in einem eingebauten Klassenmodul wie beispielsweise dem eines Access-Formulars, eines Word-Dokuments oder einer Excel-Arbeitsmappe zu erledigen, denn dann brauchen wir dazu nicht noch eine benutzerdefinierte Klasse zu programmieren und zu instanziieren.<\/p>\n
Wir können nicht nur die Ereignisse von Objekten auf Basis von benutzerdefinierten Klassen implementieren. Auch die eingebauten Klassen stellen Ereignisse zur Verfügung. Dabei unterscheiden wir zwischen zwei Arten:<\/p>\n
Wir deklarieren also in einem Klassenmodul, ganz gleich, ob es sich nun um ein eingebautes oder ein benutzerdefiniertes Klassenmodul handelt, eine Objektvariable für das Element, dessen Ereignisse wir implementieren wollen.<\/p>\n
Dazu müssen wir ein spezielles Schlüsselwort namens WithEvents <\/b>benutzen. Damit wir nicht versehentlich eine Klasse mit diesem Schlüsselwort deklarieren, die gar keine Ereignisse anbietet, liefert IntelliSense nur solche Einträge, die auch Ereignisse enthalten.<\/p>\nZusammenfassung und Ausblick<\/h2>\n
In diesem Artikel haben wir uns die Gründe angesehen, die für den Einsatz von benutzerdefinierten Klassenmodulen sprechen.<\/p>\n
In weiteren Artikeln, auf die wir im Laufe dieses Artikels verwiesen haben, füllen wir die theoretischen Ansätze dieses Artikels mit Leben. <\/p>\n","protected":false},"excerpt":{"rendered":"
Wer die Office-Anwendungen Access, Excel, Outlook, PowerPoint oder Word mit VBA programmiert, kann eine Menge erreichen, ohne jemals eine eigene Klasse zu programmieren. Wer sich die gesamten Möglichkeiten eröffnen will, kommt jedoch irgendwann nicht mehr um die Programmierung benutzerdefinierter Klassen herum. Dieser Artikel zeigt verschiedene Szenarien auf, wann man benutzerdefinierte Klassen programmieren und darauf basierende Objekte instanziieren kann und soll. Dabei geht es um Begriffe wie Eigenschaften, Methoden, Ereignisse und darum, wo und wie man Klassen einsetzt.<\/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":[],"class_list":["post-55000424","post","type-post","status-publish","format-standard","hentry","category-66022024","category-662024","category-VBAProgrammierung"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000424","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000424"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000424\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000424"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000424"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000424"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000424"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}