Die allermeisten Prozeduren und Funktionen des VBA-Projekts Ihrer Datenbank werden Sie in ganz normalen Modulen unterbringen. Dabei wird leicht übersehen, dass es sich etwa bei Formularen um eine andere Art Module handelt, nämlich um Klassenmodule. Diese können Sie aber auch selbst anlegen. Erfahren Sie hier, wie Sie dabei vorgehen. Wir leiten das Thema zunächst jedoch mit den benutzerdefinierten Typen ein, welche Klassenmodule verständlicher machen.<\/p>\n
Die Beispiele dieses Artikels finden Sie in der Datenbank 1601_Klassenmodule.accdb<\/b><\/p>\nBenutzerdefinierte Typen<\/h2>\n
Ein benutzerdefinierter Typ ist nichts weiter, als eine zusammengefasste Struktur von Variablen.<\/p>\n
Interessanterweise findet man Beispiele dafür im VBA-Objektkatalog weder in der Access-Bibliothek, noch unter den VBA- oder Office-Bibliotheken. Also stellen wir gleich eine eigene Kreation vor:<\/p>\n
Public <\/span>Type TAdresse\r\n ID As Long<\/span>\r\n Nachname As String<\/span>\r\n Vorname As String<\/span>\r\n Strasse As String<\/span>\r\n PLZ As String<\/span>\r\n Ort As String<\/span>\r\nEnd Type<\/pre>\nDer reservierte Begriff Type<\/b> definiert, dass unter dem folgenden Namen TAdresse<\/b> eine Variablenstruktur folgt. Solche Typen können im Gültigkeitsbereich auch mit Private<\/b> gekennzeichnet sein, was sie nur für das Modul zugreifbar macht, in dem sich die Deklaration befindet. Public<\/b> bedeutet hier, dass nun das gesamte VBA-Projekt den Typen kennt und auch aus anderen Modulen heraus verwendet werden kann.<\/p>\n
Die einzelnen Variablen des Typs werden in den folgenden Zeilen durch Namen und Variablentypen definiert. Jeglicher Datentyp ist hier möglich – etwa auch As Object<\/b>. <\/p>\n
Wozu ist das gut Kann man die Elemente der Struktur nicht auch als einzelne Variablen deklarieren Es gibt sicher viele Fälle, für die die Antwort hier Ja lautet. Doch schauen wir uns an, welche Vorteile der benutzerdefinierte Typ bietet. Denn er verhält sich genau so, wie jeder andere Datentyp. Also kann er einer Variablen zugeordnet werden:<\/p>\n
Dim <\/span>A As <\/span>TAdresse<\/pre>\nDer Zugriff auf die Elemente des Typs geschieht über Punkt und Namen:<\/p>\n
A.Nachname = \"Minhorst\"\r\nA.Vorname = \"André\"\r\nA.Ort = \"Duisburg\"\r\nDebug.Print<\/span> A.Nachname<\/pre>\nDer Code lässt sich noch über die With<\/b>-Anweisung vereinfachen:<\/p>\nWith<\/span> A\r\n .Nachname = \"Minhorst\"\r\n .Vorname = \"André\"\r\n .Ort = \"Duisburg\"\r\n Debug.Print<\/span> .Nachname\r\nEnd With<\/span><\/pre>\nDas wäre schon einmal Vorteil Nummer eins. Nach Eingabe von A<\/b> und Punkt stellt das IntelliSense<\/b> von VBA gleich alle Elemente des Typs in der Auswahlliste vor. Und das übrigens auch innerhalb des With<\/b>-Blocks, wo allein die Punkt-Eingabe für das Auslösen von IntelliSense<\/b> ausreicht.<\/p>\n
Besonders nützlich sind benutzerdefinierte Typen jedoch dann, wenn Sie in Arrays Verwendung finden:<\/p>\n
Dim <\/span>Adressen() As <\/span>TAdresse\r\nReDim Adressen(99)\r\nAdressen(0).Nachname = \"Minhorst\"\r\nAdressen(0).Vorname = \"André\"\r\nAdressen(1).Nachname = \"Trowitzsch\"\r\nAdressen(1).Vorname = \"Sascha\"\r\n...<\/pre>\nDas Array Adressen<\/b> ist vom Typ TAdresse<\/b>. Es wird im ersten Schritt auf Hundert Elemente dimensioniert. Danach folgt die Zuweisung der Werte einerseits über die Indizes des Arrays, andererseits über den Namen der Elemente. Wollte man das über separate Variablen erreichen, so benötigte man für jedes Element des Typs ein eigenes gesondertes Array. Das machte die Angelegenheit deutlich unüberschaubarer, als es das Handling mit einem Array des benutzerdefinierten Typs erlaubt.<\/p>\n
Die Sache lässt sich noch weiterspinnen. Durch den Fakt, dass ein Typelement Variablen beliebigen Datentyps aufweisen darf, kommt für dieses selbst ein benutzerdefinierter Typ infrage:<\/p>\n
Public <\/span>Type TAdressen\r\n Items() As <\/span>TAdresse\r\nEnd Type<\/pre>\nZwar enthält der Typ nur ein Element, welches jedoch als Array des benutzerdefinierten TAdresse<\/b> ausgelegt ist. Damit ist nur eine Variable vom Typ TAdressen<\/b> imstande mehrere Adressen zu speichern:<\/p>\nDim <\/span>A As <\/span>TAdressen\r\nReDim A.Items(99)\r\nWith<\/span> A\r\n .Items(0).Nachname = \"Minhorst\"\r\n .Items(0).Vorname = \"André\"\r\n .Items(1).Nachname = \"Trowitzsch\"\r\n .Items(1).Vorname = \"Sascha\"\r\n ...\r\nEnd With<\/span>\r\nDebug.Print<\/span> A.Items(1).Vorname<\/pre>\nAuch hier führt der benutzerdefinierte Typ zu strukturierterer Programmierung. Treiben wir es noch einen Schritt weiter. Es lägen etwa Adressen für verschiedene Anwendungsbereiche vor, seien es Kundenadressen, Ansprechpartner, Behörden, Firmen.<\/p>\n
Dann könnten alle Adressen zusammen wiederum in einen neuen Typ überführt werden:<\/p>\n
Public <\/span>Enum eAddressType\r\n eAddressUnspecific = 0 \r\n eAddressCustomer = 1\r\n eAddressPartner = 2\r\n eAddressCompany = 3\r\nEnd Enum\r\nPublic <\/span>Type TAdressenGesamt\r\n AddressType As <\/span>sAddressType\r\n AddressBlock As <\/span>TAdressen\r\nEnd Type<\/pre>\nDie Zuordnung der Werte wird nun zwar etwas länglich, ist aber dennoch gut zu überblicken:<\/p>\n
Dim <\/span>A() As <\/span>TAdressenGesamt\r\nReDim A(3)\r\nA(1).AddressType = eAddressCustomer\r\nRedim A(1).AdressBlock.Items(9)\r\nWith<\/span> A(1).AdressBlock\r\n .Items(0).Nachname = \"Minhorst\"\r\n .Items(0).Vorname = \"Minhorst\"\r\n .Items(1).Nachname = \"Trowitzsch\"\r\n .Items(1).Vorname = \"Sascha\"\r\n ...\r\nEnd With<\/span>\r\nA(2).AddressType = eAddressUnspecific\r\nRedim A(2).AdressBlock.Items(9)\r\nWith<\/span> A(2).AdressBlock\r\n .Items(0).Nachname = \"Häberle\"\r\n .Items(0).Vorname = \"Adam\"\r\n .Items(1).Nachname = \"Gutschmidt\"\r\n .Items(1).Vorname = \"Andrea\"\r\n ...\r\nEnd With<\/span>\r\n...<\/pre>\nImmerhin haben wir nun mehrere Adressblöcke unterschiedlichen Umfangs und Typs in einer Variablen vereint! Das einzig hinderlich ist die Notwendigkeit, die Items<\/b>-Arrays jeweils neu zu dimensionieren. Das ließe sich mit einer festen Anzahl von Elementen umgehen:<\/p>\nPublic <\/span>Type TAdressen\r\n Items(99) As <\/span>TAdresse\r\nEnd Type<\/pre>\nDamit läge die Maximalzahl von Adressen für einen Block bei Hundert. Probleme gibt stellen sich also ein, wenn doch mehr benötigt würden. Und bei kleinerer Anzahl würde außerdem Speicherplatz vergeudet. Dieses Beispiel sollte eigentlich nur eines demonstrieren, nämlich wie sich benutzerdefinierte Typen im Interesse von Strukturierung verschachteln lassen. Das Ganze geht in Richtung Objektorientierter Programmierung, mit der wir es später bei den Klassenmodulen noch mehr zu tun bekommen.<\/p>\n
Tabellendaten in benutzerdefinierten Typen<\/h2>\n
Damit es nicht bei trockener Theorie bleibt, folgt ein Beispiel, das in der einen oder anderen Datenbank durchaus vertreten sein kann. Es geht hier darum, die Datensätze einer Tabelle oder Abfrage in VBA-Strukturen zu überführen.<\/p>\n
Listing 1 zeigt das Grundgerüst mit der Prozedur TestUDT<\/b>. Nebenbei erwähnt ist UDT<\/b> das Kürzel für einen benutzerdefinierten Typ (User Defined Type<\/b>). Eine Datensatzgruppe rs<\/b> wird auf alle Datensätze der Tabelle tblAdressen<\/b> geöffnet. In einer Do-Loop<\/b>-Schleife werden sie alle durchlaufen und die einzelnen Feldinhalte den Elementen der Variablen T<\/b> des Typs TAdresse<\/b> verabreicht. Da mache Felder der Datensätze leer sind und Leer<\/b> nicht in einem String gespeichert werden kann – Strasse ist etwa vom Typ String<\/b> – müssen die Werte noch einer Vorbehandlung mit der Funktion Nz<\/b> unterzogen werden, die aus Nullwerten ordnungsgemäße Strings der Länge 0 macht.<\/p>\nSub <\/span>TestUDT()\r\n Dim <\/span>rs As <\/span>DAO.Recordset\r\n Dim <\/span>T As <\/span>TAdresse\r\n \r\n Set<\/span> rs = CurrentDb.OpenRecordset(\"SELECT * FROM tblAdressen\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rs.EOF\r\n With<\/span> T\r\n .ID = rs!ID.Value\r\n .Nachname = Nz(rs!Nachname.Value)\r\n .Vorname = Nz(rs!Vorname.Value)\r\n .Strasse = Nz(rs!Strasse.Value)\r\n .PLZ = Nz(rs!PLZ.Value)\r\n .Ort = Nz(rs!Ort.Value)\r\n End With<\/span>\r\n rs.MoveNext<\/span>\r\n Loop<\/span>\r\n rs.Close\r\nEnd Sub<\/span><\/pre>\nListing 1: Hier werden die Daten der Tabelle tblAdressen hintereinander in einer Variablen T des benutzerdefinierten Typs TAdressen abgespeichert<\/p>\n
Viel Sinn macht das Beispiel nicht. Schließlich landen alle Daten in der einen Variablen T<\/b> und überschreiben sich damit bei jedem Schleifendurchlauf. In Listing 2 ist die Routine aufgebohrt und um den Typ TAdressen<\/b> erweitert, welcher, wie bereits weiter oben dargestellt, mehrere Adressen aufnehmen kann. Die Items<\/b> des Typs T<\/b>, also die einzelnen Adressen, müssen zunächst auf die Zahl der Datensätze des Recordsets dimensioniert werden. Sie erhalten diese über die Methode RecordCount<\/b>, nachdem Sie den Daten-Cursor über MoveLast<\/b> einmal auf das Ende der Datensätze einstellen. Da das Array Items<\/b> nullbasiert ist, muss die Obergrenze auf RecordCount – 1<\/b> festgelegt werden. In der folgenden Do-Loop<\/b>-Schleife wird auf eine Adresse nun über den Array-Index i<\/b> Bezug genommen, wobei T.Items(i)<\/b> als Spezifikation des With<\/b>-Blocks dient. Die Zählervariable i<\/b> wird nach erfolgtem MoveNext<\/b> innerhalb der Schleife erhöht. Im Endergebnis haben Sie damit alle Datensätze der Tabelle in der einen Variablen T<\/b>.<\/p>\nSub <\/span>TestUDTArray()\r\n Dim <\/span>rs As <\/span>DAO.Recordset\r\n Dim <\/span>T As <\/span>TAdressen\r\n Dim <\/span>i As Long<\/span>\r\n \r\n Set<\/span> rs = CurrentDb.OpenRecordset(\"SELECT * FROM tblAdressen\", dbOpenDynaset)\r\n rs.MoveLast: rs.MoveFirst\r\n ReDim T.Items(rs.RecordCount - 1)\r\n Do While<\/span> Not<\/span> rs.EOF\r\n With<\/span> T.Items(i)\r\n .ID = i\r\n .Nachname = Nz(rs!Nachname.Value)\r\n .Vorname = Nz(rs!Vorname.Value)\r\n .Strasse = Nz(rs!Strasse.Value)\r\n .PLZ = Nz(rs!PLZ.Value)\r\n .Ort = Nz(rs!Ort.Value)\r\n End With<\/span>\r\n rs.MoveNext: i = i + 1\r\n Loop<\/span>\r\n rs.Close\r\nEnd Sub<\/span><\/pre>\nListing 2: Hier kommt der benutzerdefinierte Typ TAdressen zum Tragen<\/p>\n
Was damit dann anstellen, ist ein anderes Thema. Beispiel wäre etwa das Abspeichern in eine Textdatei. Tatsächlich lassen sich Variablen eines benutzerdefinierten Typs über nur eine einzige Zeile exportieren. Sie könnten die Routine von Listing 2 am Ende mit diesen Zeilen erweitern:<\/p>\n
Dim <\/span>F As Integer<\/span>\r\nF = FreeFile\r\nOpen \"c:\\daten\\tabelle.txt\" For Binary As <\/span>F\r\nPut F,, T\r\nClose F<\/pre>\nMit der dergestalt exportierten Textdatei kann allerdings kein anderes Programm etwas anfangen. Sie lässt sich aber analog in einem VBA-Programm einlesen, das den Typ TAdressen<\/b> kennt; sinngemäß:<\/p>\nDim <\/span>T As <\/span>TAdressen\r\nGet F,, T<\/pre>\nKlassenmodule<\/h2>\n
Recht grundlos fristen Klassenmodule unter VBA ein Nischendasein. Entweder wird der Umgang mit ihnen immer wieder als kompliziert dargestellt, oder aber der Nutzen in Frage gestellt. Schließlich lässt sich mit den normalen Modulen dasselbe bewerkstelligen Dem ist aber nicht so. Grund genug, sich einmal deren Grundlagen zu widmen.<\/p>\n
Rein mechanisch fügen Sie Ihrer Datenbank ein Klassenmodul hinzu, indem Sie den gleichnamigen Button im Ribbon<\/b> unter der Registerseite Erstellen<\/b> anklicken, oder, alternativ, im Projekt-Explorer <\/b>der VBA-Umgebung und das Kontextmenü Einfügen | Klassenmodul<\/b> betätigen. Bei Speichern vergeben Sie dem Modul einen Namen. Es hat sich eingebürgert, hier ein abweichendes Präfix zu verwenden. Versieht man normale Module meist mit dem Präfix mod<\/b> oder mdl<\/b>, so kommt hier eher ein cls<\/b> oder schlicht C<\/b> zum Einsatz. Ist das Thema des Klassenmoduls die Verwaltung von Adressen, so verwenden Sie etwa clsAdressen<\/b>.<\/p>\n
Vom programmtechnischen Standpunkt aus unterscheidet sich ein Klassenmodul nicht von normalen Modulen. Es existiert lediglich eine kleine Erweiterung, das Event, auf welches wir noch zu sprechen kommen. Der Unterschied besteht vielmehr darin, dass ein Klassenmodul eben eine Klasse zur Verfügung stellt, während normale Module eine Sammlung von allgemein verwendbaren Funktionen verzeichnet. Die Methoden der Klasse können aber nicht direkt aufgerufen werden. Eine Klasse ist nämlich lediglich der Bauplan für ein Objekt<\/b>! Ein Objekt<\/b> stellt eine Instanz<\/b> einer Klasse dar, welche erst per New<\/b>-Anweisung erzeugt werden muss, um an die Funktionen der Klasse zu kommen:<\/p>\nDim <\/span>C As <\/span>clsAdressen\r\nSet<\/span> C = New<\/span> clsAdressen<\/pre>\noder einfach<\/p>\n
Dim <\/span>C As <\/span>New<\/span> clsAdressen<\/pre>\nüber C<\/b> gelangen Sie dann an die Methoden der Klasse. ähnlich, wie beim benutzerdefinierten Typ, zeigt IntelliSense<\/b> die Methoden der Klasse, wenn Sie einen Punkt hinter die Variable setzen. Enthielte die Adressenklasse eine Prozedur FindeNachnamen<\/b>, so riefen Sie jene auf diese Weise auf:<\/p>\nC.FindeNachname<\/pre>\nDer Umstand, dass Klassenmodule erst auf dem Umweg über deren Instanziierung ansprechbar werden, macht sie wahrscheinlich unbeliebt, ist doch der Aufwand höher, als bei normalen Modulfunktionen.<\/p>\n
Es gibt an anderer Stelle erschöpfende Darlegungen über Klassen, Objekte, Instanziierung und objektorientierte Programmierung. Da viele der Charakteristiken von Objektstrukturen unter VBA jedoch nicht implementiert sind, lassen wir es für den Anfang bei einigen grundlegenden Erläuterungen.<\/p>\n
Ein Schlagwort bei Klassen ist Kapselung<\/b>. Dadurch, dass eine Klasse erst dezidiert über eine Variable instanziiert werden muss, kapselt sich deren Funktionalität und schottet den Zugriff im Vergleich zu normalen Modulen ab. Die Methoden sind nur Teil des Objekts und damit nicht generell verfügbar.<\/p>\n
Deshalb eignet sich eine Klasse und deren Objekt auch für die Aufnahme von Daten. Nicht zufällig hatten wir es eingangs mit benutzerdefinierten Objekten zu tun. UDT<\/b>-Variablen sind häufig öffentlich ansprechbar und damit unsicherer, als ein Objekt.<\/p>\nContainer-Klassen<\/h2>\nMöchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t