Wenn wir im VBA-Editor benutzerdefinierte Klassen programmieren wollen, verwenden wir für Eigenschaften üblicherweise eine private Variable, die wir über eine öffentliche Property Set\/Let-Prozedur mit einem Wert füllen und mit einer Property Get-Prozedur auslesen können. Das sind mindestens sieben Zeilen je Eigenschaft, was jede Menge Tipparbeit und Aufwand bedeutet und außerdem noch fehleranfällig ist. Selbst Copy und Paste macht diese Aufgabe nicht wesentlich angenehmer. Wohl dem, der weiß, wie er den VBA-Editor programmiert, sodass er solche Aufgaben mit wenigen Mausklicks automatisieren kann. Hier gibt es verschiedene Ansätze, die wir uns in diesem Artikel ansehen und auch umsetzen.<\/b><\/p>\n
Die Programmierung von Office-Anwendungen mit VBA ist die eine Aufgabe. Diese wird üblicherweise durch die Anforderungen des Kunden oder des Benutzers gesteuert und einfach Schritt für Schritt abgearbeitet. Als Entwickler sollten wir jedoch immer darauf bedacht sein, Abkürzungen bei der Arbeit zu suchen, um schneller und zuverlässiger ans Ziel zu kommen.<\/p>\n
Das gelingt unter Office anwendungsübergreifend im Bereich der VBA-Programmierung. Wir können uns auch die eine oder andere Prozedur bauen, um Aufgaben in Access, Excel, Outlook, PowerPoint oder Word zu automatisieren. Schließlich gibt es in einigen dieser Anwendungen dazu extra den Makro-Rekorder.<\/p>\n
Unter VBA ist das jedoch noch ein wenig spannender, denn hier können wir für alle Office-Anwendungen gleichermaßen Vereinfachungen programmieren. Und so machen wir uns auch gleich ans Werk und schauen uns an, welche Möglichkeiten wir hier so haben.<\/p>\n
Aber von welchen verschiedenen Ansätzen haben wir in der Einleitung gesprochen? Nun, es gibt verschiedene Ausgangssituationen. Wir schauen uns zuerst einmal an, was wir überhaupt haben wollen. Für eine vollwertige Eigenschaft, deren Wert gelesen und gesetzt werden kann, benötigen wir als Erstes eine private Member-Variable, die wir beispielsweise wie folgt deklarieren:<\/p>\n
Private <\/span>m_Firma As String<\/span><\/pre>\nDamit wir von außen auf diese Variable zugreifen können, um ihren Wert einzustellen, nutzen wir eine öffentliche Property Let<\/b>-Prozedur:<\/p>\nPublic Property Get <\/span>Firma() As String<\/span>\r\n Firma = m_Firma\r\nEnd Property<\/span> <\/pre>\nSchließlich wollen wir eine Eigenschaft auch von außen setzen können, also fügen wir noch eine entsprechende Property Let<\/b>-Prozedur hinzu:<\/p>\nPublic Property Let <\/span>Firma(str As String<\/span>)\r\n m_Firma = str\r\nEnd Property<\/span><\/pre>\nUnd wenn unsere Eigenschaft keine skalare Variable aufnimmt (also zum Beispiel Long <\/b>oder String<\/b>), sondern einen Objektverweis, müssen wir die Schreibweise ein wenig anpassen. Die Variable deklarieren wir dann etwa so:<\/p>\nPrivate <\/span>m_Recordset As <\/span>DAO.Recordset<\/pre>\nAuch in der Get<\/b>-Prozedur benötigen wir eine Änderung, denn für die Zuweisung von Objektverweisen ist das Schlüsselwort Set <\/b>nötig:<\/p>\nPublic Property Get <\/span>Recordset() As <\/span>DAO.Recordset\r\n Set<\/span> Recordset = m_Recordset\r\nEnd Property<\/span><\/pre>\nDieses Schlüsselwort benötigen wir auch beim Setzen des Objektverweises. Außerdem verwenden wir hier keine Property Let<\/b>-Prozedur, sondern eine Property Set<\/b>-Prozedur:<\/p>\nPublic Property Set<\/span> <\/span>Recordset(rst As <\/span>DAO.Recordset)\r\n Set<\/span> m_Recordset = rst\r\nEnd Property<\/span><\/pre>\nDie nächste Vorgabe ist, dass die Property Let<\/b>\/Set<\/b>\/Get<\/b>-Prozeduren im Modul frühestens nach der letzten Deklarationszeile hinzugefügt werden darf. Nach der ersten Prozedur darf keine alleinstehende Deklarationszeile mehr folgen.<\/p>\nProzedur zum Ersetzen von öffentlichen Eigenschaften durch Get\/Let\/Set-Property<\/h2>\n
Wir können mit den Methoden der Bibliothek Microsoft Visual Basic for Applications 5.3 Object Library <\/b>auf die Elemente des VBA-Editors zugreifen und diese manipulieren. Dies nutzen wir in diesem Falle, um die gewünschten Änderungen in einem Klassenmodul vorzunehmen. Den benötigten Verweis auf diese Bibliothek setzen wir auf gewohnte Weise über den Verweise<\/b>-Dialog.<\/p>\n
Dann fügen wir die Prozedur VariableToProperty <\/b>zu einem Standardmodul hinzu (siehe Listing 1).<\/p>\nPublic Sub <\/span>VariableToProperty()\r\n Dim <\/span>objCodePane As <\/span>CodePane, objCodeModule As <\/span>CodeModule\r\n Dim <\/span>lngStartline As Long<\/span>, lngStartcolumn As Long<\/span>\r\n Dim <\/span>lngEndline As Long<\/span>, lngEndcolumn As Long<\/span>\r\n Dim <\/span>lngLine As Long<\/span>, strLine As String<\/span>\r\n Dim <\/span>strVariable As String<\/span>, strDatatype As String<\/span>\r\n Dim <\/span>strVariables As String<\/span>\r\n Dim <\/span>strProperties As String<\/span>\r\n Dim <\/span>strPrefix As String<\/span>\r\n Set<\/span> objCodePane = VBE.ActiveCodePane\r\n objCodePane.GetSelection lngStartline, lngStartcolumn, lngEndline, lngEndcolumn\r\n Set<\/span> objCodeModule = objCodePane.CodeModule\r\n For lngLine = lngStartline To lngEndline\r\n strLine = Trim<\/span>(objCodeModule.Lines(lngLine, 1))\r\n If <\/span>Not<\/span> Len<\/span>(strLine) = 0 Then<\/span>\r\n strVariable = Split<\/span>(strLine, \" \")(1)\r\n strDatatype = Split<\/span>(strLine, \" \")(3)\r\n strPrefix = GetPrefix(strDatatype)\r\n strVariables = strVariables & \"Private m_\" & strVariable & \" As <\/span>\" & strDatatype & vbCrLf<\/span>\r\n Select Case strPrefix\r\n Case <\/span>\"obj\"\r\n strProperties = strProperties & \"Public Property Set<\/span> \" & strVariable & \"(\" & strPrefix & \" As <\/span>\" _\r\n & strDatatype & \")\" & vbCrLf<\/span>\r\n strProperties = strProperties & \" Set<\/span> m_\" & strVariable & \" = \" & strPrefix & vbCrLf<\/span>\r\n Case Else<\/span>\r\n strProperties = strProperties & \"Public Property Let \" & strVariable & \"(\" & strPrefix & \" As <\/span>\" _\r\n & strDatatype & \")\" & vbCrLf<\/span>\r\n strProperties = strProperties & \" m_\" & strVariable & \" = \" & strPrefix & vbCrLf<\/span>\r\n End Select<\/span>\r\n strProperties = strProperties & \"End Property\" & vbCrLf<\/span> & vbCrLf<\/span>\r\n strProperties = strProperties & \"Public Property Get \" & strVariable & \" As <\/span>\" & strDatatype & vbCrLf<\/span>\r\n Select Case strPrefix\r\n Case <\/span>\"obj\"\r\n strProperties = strProperties & \" Set<\/span> \" & strVariable & \" = m_\" & strVariable & vbCrLf<\/span>\r\n Case Else<\/span>\r\n strProperties = strProperties & \" \" & strVariable & \" = m_\" & strVariable & vbCrLf<\/span>\r\n End Select<\/span>\r\n strProperties = strProperties & \"End Property \" & vbCrLf<\/span> & vbCrLf<\/span>\r\n End If<\/span>\r\n Next<\/span> lngLine\r\n strVariables = strVariables & vbCrLf<\/span>\r\n objCodeModule.DeleteLines lngStartline, lngEndline - lngStartline + 1\r\n lngStartline = objCodeModule.CountOfDeclarationLines + 1\r\n objCodeModule.InsertLines lngStartline, strVariables & strProperties\r\n Call<\/span> RemoveTripeCrLf(objCodeModule)\r\nEnd Sub<\/span><\/pre>\nListing 1: Prozedur zum Erstellen von Property Get\/Let\/Set-Prozeduren für Variablen<\/span><\/b><\/p>\nDiese Prozedur deklariert zunächst einige Variablen und stellt dann die Variable objCodePane <\/b>mit der Funktion ActiveCodePane <\/b>auf das aktuelle CodePane<\/b>-Objekt ein, was dem aktuellen Codefenster entspricht.<\/p>\n
Wir gehen davon aus, dass der Benutzer eine oder mehrere Zeilen mit öffentlichen Variablen markiert hat und dass die Prozedur diese alle in private Variablen umwandeln soll, die über eine Get Property <\/b>verfügbar gemacht und mit Set<\/b>\/Let Property <\/b>gesetzt werden können sollen.<\/p>\n
Davon ausgehend erfassen wir die aktuelle Markierung im Codefenster mit der GetSelection<\/b>-Funktion des CodePane<\/b>-Objekts. Diese liefert uns für die Variablen lngStartline<\/b>, lngStartcolumn<\/b>, lngEndline <\/b>und lngEndcolumn <\/b>die Koordinaten der aktuellen Markierung.<\/p>\n
Damit ausgestattet durchlaufen wir die erste Zeile der Markierung (lngStartline<\/b>) bis zur letzten Zeile (lngEndline<\/b>) in einer For…Next<\/b>-Schleife mit lngLine <\/b>als Laufvariable.<\/p>\n
Darin lesen wir die aktuelle Zeile in die Variable strLine <\/b>ein und entfernen mit der Trim<\/b>-Funktion direkt führende und folgende Leerzeichen.<\/p>\n
Wenn strLine<\/b> nun keine leere Zeichenkette ist, teilen wir die Zeile mit der Split<\/b>-Funktion an den Leerzeichen auf und ermitteln das zweite und das vierte Element (mit den Indexwerten 1 <\/b>und 3 <\/b>wegen des 0<\/b>-basierten Indexes dieser Funktion). Wir gehen von einer Zeile wie der folgenden aus:<\/p>\nPublic <\/span>Field As <\/span>DAO.Field<\/pre>\nDann landet der Variablenname Field <\/b>in der Variablen strVariable <\/b>und DAO.Field <\/b>landet in strDatatype<\/b>.<\/p>\n
Bevor wir beginnen, den notwendigen Code zusammenzustellen, wollen wir noch den Datentyp der Variablen ermitteln und das dafür vorgesehene Präfix ermitteln. Das erledigen wir mit einem Aufruf der Funktion GetPrefix<\/b>, die uns für den jeweiligen Datentyp das aus drei Buchstaben bestehenden Präfix liefert. Hier werden die Basisdatentypen wie Boolean<\/b>, Integer <\/b>oder String <\/b>separat behandelt.<\/p>\n
Für alle anderen Datentypen wird als Präfix obj <\/b>angenommen. Ob wir es hier mit einem Object <\/b>zu tun haben oder mit einem anderen Datentyp, wirkt sich auch darauf aus, ob wir eine Property Set <\/b>(für Objekte) oder Property Let <\/b>(für einfache Basistypen) anlegen müssen. Die Funktion GetPrefix <\/b>sieht wie folgt aus und sie kann nach Bedarf erweitert werden:<\/p>\nPublic Function <\/span>GetPrefix(strDatatype As String<\/span>) As String<\/span>\r\n Select Case strDatatype\r\n Case <\/span>\"Boolean\"\r\n GetPrefix = \"bol\"\r\n Case <\/span>\"Byte\"\r\n GetPrefix = \"byt\"\r\n Case <\/span>\"Currency\"\r\n GetPrefix = \"cur\"\r\n Case <\/span>\"Date\"\r\n GetPrefix = \"dat\"\r\n Case <\/span>\"Decimal\"\r\n GetPrefix = \"dec\"\r\n Case <\/span>\"Double\"\r\n GetPrefix = \"dbl\"\r\n Case <\/span>\"Integer\"\r\n GetPrefix = \"int\"\r\n Case <\/span>\"Long\"\r\n GetPrefix = \"lng\"\r\n Case <\/span>\"Single\"\r\n GetPrefix = \"sng\"\r\n Case <\/span>\"String\"\r\n GetPrefix = \"str\"\r\n Case <\/span>\"Variant\"\r\n GetPrefix = \"var\"\r\n Case Else<\/span>\r\n GetPrefix = \"obj\"\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nZurück zur Prozedur VariableToProperty<\/b>. Diese speichert das Präfix in der Variablen strPrefix<\/b>. Dann fügt sie der Variablen strVariables <\/b>eine Zeichenkette hinzu die aus Privat m_<\/b>, dem Variablennamen, As<\/b>, dem Datentyp und einem Zeilenumbruch besteht, in unserem Fall also beispielsweise:<\/p>\nPrivate <\/span>m_Field As <\/span>DAO.Field<\/pre>\nDass wir hier den Wert nicht einfach der Variablen strVariables <\/b>zuweisen, sondern an diese anhängen, hängt damit zusammen, dass wir gegebenenfalls auch mehrere Variablen umwandeln wollen. Deshalb sammeln wir in strVariables<\/b> alle Zeilen mit den Deklarationen der nun als privat deklarierten Variablen.<\/p>\n
Danach prüft die Prozedur in einer Select Case<\/b>-Bedingung, ob es sich bei dem Präfix um den Wert obj <\/b>handelt oder um einen anderen Wert. Im Falle von obj <\/b>setzt diese die Kopfzeile der Property<\/b>-Prozedur mit dem Schlüsselwort Property Set <\/b>zusammen, zum Beispiel so:<\/p>\nPublic Property Set<\/span> <\/span>Field(obj As <\/span>DAO.Field)<\/pre>\nAnderenfalls wird das Schlüsselwort Let<\/b> verwendet, zum Beispiel so:<\/p>\nPublic Property Let <\/span>Text(str As String<\/span>)<\/pre>\nFalls weitere Unterscheidungen gewünscht sind und individuelle Präfixe vergeben werden sollen, kann man diese in zusätzlichen Case<\/b>-Zweigen unterbringen. Diese Kopfzeile wird hinten an die Variable strProperties <\/b>angehängt.<\/p>\n
Innerhalb der Schleife folgt auch noch die einzige Anweisung dieser Property Let<\/b>\/Set<\/b>-Prozedur, die zusammengestellt wird aus Set m_<\/b>, dem Variablennamen aus strVariable<\/b>, dem Gleichheitszeichen und dem Präfix.<\/p>\n
Für die Basisdatentypen wird die Anweisung auf die gleiche Weise zusammengestellt, allerdings kommt hier kein Set<\/b>-Schlüsselwort zum Einsatz. Schließlich folgt in der folgenden Anweisung noch die Fußzeile, die für alle Eigenschaften End Property <\/b>lautet.<\/p>\n
Dann stellt die Prozedur die Property Get<\/b>-Prozedur zusammen, die wieder für Basisdatentypen und Objektdatentypen einen Unterschied bereithält. Für Basisdatentypen sieht sie beispielsweise wie folgt aus:<\/p>\nPublic Property Get <\/span>Field() As <\/span>DAO.Field\r\n Field = m_Field\r\nEnd Property<\/span><\/pre>\nFür Objektdatentypen müssen wir noch das Set-Schlüsselwort hinzufügen:<\/p>\n
Set<\/span> Field = m_Field<\/pre>\nAuf diese Weise werden in der Variablen strVariables <\/b>die Variablen zusammengestellt und in der Variablen strProperties <\/b>die Property<\/b>-Prozeduren. Den Variablen wird noch ein Zeilenumbruch hinzugefügt. Danach löscht die Prozedur die bisher verwendete Deklaration der Variablen mit der DeleteLines<\/b>-Methode für die zuvor mit lngStartline <\/b>und lngEndline <\/b>ermittelten Zeilen.<\/p>\n
Schließlich ermittelt die Prozedur einen neuen Wert für lngStartline<\/b>, nämlich die erste Zeile hinter dem Deklarationsbereich des Moduls. Dahinter sollen nun die Deklarationen der nun privaten Variablen angehängt werden und direkt im Anschluss die Property<\/b>-Prozeduren.<\/p>\n
Letzteres erledigt die Prozedur mit der InsertLines<\/b>-Methode, welche an der Position der Zeile aus lngStartline <\/b>die Inhalte der Variablen strVariables <\/b>und strProperties <\/b>hinterlegt.<\/p>\nTesten der Prozedur VariableToProperty<\/h2>\n
Wie aber können wir die Prozedur ausprobieren, wenn dazu der umzuwandelnde Inhalt im Klassenmodul markiert sein muss?<\/p>\n
Wir können dann nicht zum Modul mit der Prozedur VariableToProperty <\/b>wechseln, um diese zu markieren und mit F5 <\/b>auszuführen.<\/p>\n
Das ist auch nicht nötig: Wir können auch einfach den Namen der Prozedur im Direktbereich des VBA-Editors eingeben. Die zu bearbeitende Zeile behält dann ihre Markierung, auch wenn diese nicht mehr angezeigt wird (siehe Bild 1).<\/p>\n
![\"Vor](\"..\/fileadmin\/_temp_\/2024_03\/pic_422_001.png\")
<\/p>\n
Bild 1: Vor der Änderung<\/span><\/b><\/p>\nRufen wir die Prozedur nun auf, ersetzt diese die markierte Zeile durch die Zeilen, die wir in Bild 2 sehen.<\/p>\n
![\"Nach](\"..\/fileadmin\/_temp_\/2024_03\/pic_422_002.png\")
<\/p>\n
Bild 2: Nach der Änderung<\/span><\/b><\/p>\nAuf diese Weise können brauchen wir zum Erstellen eines Satzes bestehend aus einer privaten Variablen und jeweils einer Property Let\/Set<\/b>– und einer Property Get<\/b>-Prozedur nur die private Variable zu markieren und dann die Prozedur aufzurufen.<\/p>\nSchönheitskorrektur<\/h2>\n
Es kann sein, dass sich hinter der letzten hinzugefügten Prozedur und der ersten bereits vorhandenen Prozedur nun mehr als eine Leerzeile befindet. Für diesen Fall fügen wir noch eine kleine Erweiterung an.<\/p>\n
Dazu nutzen wir die Prozedur RemoveTripeCrLf<\/b>. Sie nimmt ein CodeModule<\/b>-Objekt entgegen und schreibt zunächst den vollständigen Code des Moduls in eine String<\/b>-Variable.<\/p>\n
Dann prüft sie in einer Do While<\/b>-Schleife, ob die String<\/b>-Variable drei aufeinanderfolgende Zeilenumbrüche (vbCrLf<\/b>) enthält. In diesem Fall ersetzt sie die dreifachen Zeilenumbrüche durch doppelte Zeilenumbrüche. Dies geschieht so lange, bis es nur noch maximal zwei Zeilenbrüche in Folge gibt (siehe Listing 2).<\/p>\nPublic Sub <\/span>RemoveTripeCrLf (objCodeModule As <\/span>VBIDE.CodeModule)\r\n Dim <\/span>strCode As String<\/span>\r\n strCode = objCodeModule.Lines(1, objCodeModule.CountOfLines)\r\n Do While<\/span> InStr<\/span>(1, strCode, vbCrLf<\/span> & vbCrLf<\/span> & vbCrLf<\/span>)\r\n strCode = Replace<\/span>(strCode, vbCrLf<\/span> & vbCrLf<\/span> & vbCrLf<\/span>, vbCrLf<\/span> & vbCrLf<\/span>)\r\n Loop<\/span>\r\n objCodeModule.DeleteLines 1, objCodeModule.CountOfLines\r\n objCodeModule.InsertLines 1, strCode\r\nEnd Sub<\/span><\/pre>\nListing 2: Prozedur zum Entfernen von mehr als einer Leerzeile aus einem Modul<\/span><\/b><\/p>\nDiese Prozedur können wir am Ende der Prozedur VariableToProperty <\/b>mit der folgenden Anweisung aufrufen:<\/p>\nCall<\/span> RemoveTripeCrLf(objCodeModule)<\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Dieser Artikel zeigt, wir wie eine Prozedur programmieren, die uns viel Schreibarbeit abnehmen kann, wenn wir mit Klassen programmieren.<\/p>\n
Allerdings fehlt noch ein klein wenig Komfort. Bisher müssten wir die Prozedur VariableToProperty<\/b> immer in die Zielanwendung schreiben und diese dort durch die Eingabe des Prozedurnamens in das Direktfenster aufrufen.<\/p>\n
Schöner wäre es, wenn wir diese Prozedur über einen Menüeintrag im VBA-Editor aufrufen könnten oder sogar über das Kontextmenü.<\/p>\n
In einem weiteren Artikel namens Klassenprogrammierung mit COM-Add-In vereinfachen <\/b>(www.vbentwickler.de\/433<\/b>) schauen wir uns an, wir dies mithilfe eines COM-Add-Ins für den VBA-Editor realisieren können.<\/p>\nDownloads zu diesem Beitrag<\/h2>\n
Enthaltene Beispieldateien:<\/p>\n
VBEProgrammieren_Klasseneigenschaften.accdb<\/p>\n
mdlVBE.bas<\/p>\n