<\/p>\n
Gelegentlich ist es sinnvoll, Daten eines Datensatzes aus einer Tabelle in einem Objekt auf Basis einer Klasse abzulegen – vor allem dann, wenn Sie nur auf einen kompakten Satz von Daten zugreifen möchten und diese nicht ändern wollen. Leider ist der nötige Code je nach Anzahl der Felder der Datenherkunft und somit der Eigenschaften recht umfangreich und die Erstellung eine mühselige Arbeit. Mit dem in diesem Beitrag vorgestellten Add-In soll dies ganz schnell von der Hand gehen.<\/b><\/p>\n
Die Beispieldatenbank ist ein fertiges Add-In. Zur Installation starten Sie den Add-In-Manager und wählen die Datei Klassengenerator.mda<\/b> aus. Anschließend finden Sie im Add-In-Menü den Eintrag aiuKlassengenerator<\/b>. Es erscheint der Dialog aus Bild 1. Hier lesen Sie entweder die Daten aller Tabellen neu ein (was beim ersten Öffnen in einer Datenbank automatisch geschieht) und wählen per Kombinationsfeld die Tabelle oder Abfrage aus, zu der Sie eine Klasse erstellen möchten. Das Unterformular zeigt dann alle Felder dieser Datenherkunft. Legen Sie dort fest, welche Felder als Eigenschaften der Klasse berücksichtigt werden sollen, und passen Sie gegebenenfalls von den Feldnamen abweichende Eigenschaftsnamen an. Klicken Sie dann auf Erzeugen<\/b>, um die komplette Klasse auf Basis der Datenherkunft in Sekundenbruchteilen zu erstellen. Nach Wunsch fügen Sie dem Code auch gleich eine Prozedur hinzu, die eine Routine zum Erstellen und Füllen einer Instanz dieser Klasse erstellt. Die erzeugten Quelltexte müssen Sie nur noch in die Zielmodule kopieren.<\/p>\n
![\"pic015.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic015.png\")
<\/p>\n
Bild 1: Der Klassengenerator in Aktion<\/span><\/b><\/p>\n Datenmodell<\/b><\/p>\n Das Add-In soll die Auswahl einer Tabelle oder Abfrage ermöglichen, für deren Felder eine Klasse angelegt werden soll. Für diese Tabelle soll das Add-In alle Felder anzeigen. Der Benutzer legt fest, welche Felder berücksichtigt werden sollen und wie die entsprechenden Eigenschaften in der Klasse heißen sollen.<\/p>\n Das Add-In soll die Namen der Tabellen und Abfragen in der Datenbank, von der aus das Add-In gestartet wurde, in einem Kombinationsfeld zur Auswahl anbieten. Der direkte Zugriff von einem Kombinationsfeld innerhalb eines Add-Ins auf die Daten der Host-Datenbank ist nicht möglich, also schreiben wir die notwendigen Daten zuvor in eine Tabelle innerhalb der Add-In-Datenbank.<\/p>\n Diese Tabelle enthält die Felder TabelleAbfrageID <\/b>(Primärschlüsselfeld, Autowert), TabelleAbfrage<\/b>, Datenbank<\/b>, Klassenname<\/b>, Primaerschluesselfeld<\/b> und Objekttyp<\/b>. TabelleAbfrage<\/b> nimmt die Namen der in der Datenbank enthaltenen Tabellen und Abfragen auf (s. Bild 2). Datenbank<\/b> speichert den Namen der Zieldatenbank, damit einmal definierte Schemata zur Erzeugung von Klassen erneut verwendet werden können. Das Feld Klassenname <\/b>nimmt den Namen auf, unter dem die Klasse für diese Tabelle oder Abfrage erzeugt werden soll – also beispielsweise clsPerson<\/b>. Primaerschluesselfeld <\/b>enthält den Namen des entsprechenden Feldes der Tabelle. Bei Tabellen wird dieser später automatisch ermittelt, bei Abfragen muss er manuell eingetragen werden. Objekttyp <\/b>nimmt den Zahlenwert des Feldes Type <\/b>der Tabelle MSysObjects <\/b>auf – dazu später mehr.<\/p>\n Bild 2: Diese Tabelle speichert die Namen der Tabellen und Abfragen der Zieldatenbank.<\/span><\/b><\/p>\n Die zweite Tabelle heißt tblFelder <\/b>(s. Bild 3). Sie enthält neben dem Primärschlüsselfeld FeldID <\/b>folgende Felder:<\/p>\n Bild 4: Beziehung der beiden Tabellen des Add-Ins<\/span><\/b><\/p>\n Die Beziehung zwischen den beiden Tabellen ist mit referentieller Integrität definiert und Löschweitergabe. Wenn also ein Datensatz aus der Tabelle tblTabellenAbfragen <\/b>gelöscht wird, entfernt Access auch die mit dem entsprechenden Datensatz verknüpften Datensätze der Tabelle tblFelder<\/b> (s. Bild 4).<\/p>\n Bild 3: Die Tabelle tblFelder speichert die Felder und ihre Einstellungen.<\/span><\/b><\/p>\n Formular des Add-Ins<\/b><\/p>\n Damit der Benutzer die Tabelle\/Abfrage für die Generierung der Klasse auswählen und die Felder festlegen kann, die das Add-In dabei berücksichtigen soll, zeigt das Add-In eine entsprechende Benutzeroberfläche in Form eines Formulars an. Dieses heißt frmKlassengenerator <\/b>und bietet zunächst ein Kombinationsfeld zur Auswahl der zu verwendenden Tabelle oder Abfrage an. Außerdem soll das Hauptformular jeweils einen Datensatz der Tabelle tblTabelleAbfrage <\/b>anzeigen – und zwar denjenigen, der vom Benutzer mit dem im Anschluss beschriebenen Kombinationsfeld ausgewählt wurde. Dazu stellen Sie für das Formular die Eigenschaft Datenherkunft <\/b>auf die Tabelle tblTabelleAbfrage <\/b>ein. Ziehen Sie außerdem die beiden Felder Datenbank<\/b> und Klassenname <\/b>aus der Feldliste in den Entwurf des Formulars. Lassen Sie darüber noch ein wenig Platz für ein Kombinationsfeld zur Auswahl der Tabelle\/Abfrage<\/b> (s. Bild 5). Wir schauen uns zunächst das Kombinationsfeld an und den Mechanismus, der die Datensatzherkunft des Kombinationsfeldes füllt und filtert.<\/p>\n Bild 6: Kombinationsfeld zur Auswahl der Tabellen und Abfragen der Zieldatenbank<\/span><\/b><\/p>\n Das Kombinationsfeld soll alle Tabellen der aktuellen Datenbank wie in Bild 6 anzeigen. Damit dieses überhaupt Daten anzeigt, weisen Sie diesem zunächst eine entsprechende Datenherkunft zu – und zwar die Tabelle tblTabellenAbfragen<\/b>. Damit das Kombinationsfeld das Primärschlüsselfeld der Tabelle ausblendet und nur die Namen der Tabellen und Abfragen anzeigt, stellen Sie die beiden Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>auf die Werte 2 <\/b>und 0cm <\/b>ein. Nachdem Sie in der Formularansicht geprüft haben, dass das Kombinationsfeld die Werte wie gewünscht anzeigt, können Sie die Eigenschaft Datensatzherkunft <\/b>wieder leeren – wir füllen diese später zur Laufzeit. Immerhin soll das Kombinationsfeld ja nur die Tabellen und Abfragen der aktuellen Datenbank anzeigen. Die Tabelle tblTabellenAbfragen <\/b>soll jedoch nach der Verwendung des Add-Ins in verschiedenen Anwendungen auch die entsprechenden Daten zu den jeweiligen Anwendungen enthalten.<\/p>\n Bild 5: Entwurfsansicht des aktuellen Stands des Formulars frmKlassengenerator<\/span><\/b><\/p>\n Deshalb löst das Formular beim Öffnen das Ereignis Beim Laden <\/b>aus und somit die Ereignisprozedur aus Listing 1<\/a><\/span>. Diese Prozedur speichert zunächst den Namen der Zieldatenbank in der Variablen strDatenbank <\/b>(beim Erstellen und Testen des Add-Ins öffnen Sie dieses direkt und nicht von einer anderen Anwendung aus, daher enthält strDatenbank <\/b>hier den Namen der Add-In-Datenbank selbst).<\/p>\n Listing 1: Füllen des Kombinationsfeldes beim Öffnen des Formulars<\/p>\n Ein Aufruf der Funktion FLookup <\/b>mit den entsprechenden Parametern prüft, ob es in der Tabelle tblTabellenAbfragen <\/b>bereits mindestens einen Datensatz gibt, dessen Feld Datenbank <\/b>den Namen der aktuellen Datenbank enthält. Falls ja, wird die Prozedur TabellenAbfragenEinlesen <\/b>aufgerufen, welche die Tabelle tblTabellenAbfragen <\/b>mit den Namen der Tabellen und Abfragen der Zieltabelle füllt. Anschließend stellt die Prozedur die Datensatzherkunft des Kombinationsfeldes cboTabelleAbfrage <\/b>auf eine SQL-Abfrage ein, die alle Datensätze der Tabelle tblTabellenAbfragen <\/b>liefert, deren Feld Datenbank<\/b> den Namen der aktuellen Zieldatenbank enthält (beziehungsweise im Standalone-Modus den Namen der Add-In-Datenbank).<\/p>\n Warum nutzen wir hier eine Funktion namens FLookup <\/b>– heißt diese nicht üblicherweise DLookup<\/b> Das ist richtig. FLookup <\/b>ist ein Nachbau der DLookup<\/b>-Funktion, die allerdings auf eine Datensatzgruppe zugreift, die sich in der mit CodeDB <\/b>referenzierten Datenbank befindet. DLookup <\/b>greift, auch von einem Add-In aus, immer auf die Tabellen oder Abfragen der Datenbank zu, die das Add-In geöffnet hat.<\/p>\n Tabellen und Abfragen einlesen<\/b><\/p>\n Nun sind beim ersten Start des Formulars noch keine Tabellen oder Abfragen in der Tabelle tblTabellenAbfragen <\/b>gespeichert. Also ruft die Prozedur Form_Load <\/b>auf jeden Fall die Prozedur TabellenAbfragenEinlesen <\/b>auf (s. Listing 2<\/a><\/span>). Diese Prozedur deklariert gleich zwei Database<\/b>-Objekte. Das erste heißt dbHost <\/b>und wird mit der Funktion CurrentDb <\/b>gefüllt. Dies liefert einen Verweis auf die aktuell in Access geöffnete Datenbank. Wenn Sie das Add-In von einer anderen Datenbank aus geöffnet haben, handelt es sich um die öffnende Datenbank, wenn Sie das Add-In direkt geöffnet haben, wird hier die Add-In-Datenbank selbst referenziert. Die zweite Variable namens dbAddIn<\/b> erhält ihren Verweis auf das Database<\/b>-Objekt über die Funktion CodeDB<\/b>. Dieses liefert immer einen Verweis auf die Datenbank, in welcher sich der ausführende Code befindet.<\/p>\n Listing 2: Füllen der Tabelle tblTabellenAbfragen<\/p>\n Mit diesen beiden Verweisen ausgestattet öffnet die Prozedur eine Datensatzgruppe auf Basis der Tabelle MSysObjects <\/b>der Zieldatenbank. Die Datensatzgruppe liefert das Feld Name <\/b>aller Datensätze zurück, deren Feld Type <\/b>den Wert 1<\/b>, 4<\/b>, 5 <\/b>oder 6 <\/b>enthält und deren Name nicht mit ~ <\/b>beginnt (dies sind Abfragen, die als Wert der Eigenschaften Datenherkunft <\/b>beziehungsweise Datensatzherkunft <\/b>gespeichert, aber nicht im Datenbankfenster oder Navigationsbereich angezeigt werden). Der Wert 1 <\/b>für das Feld Type <\/b>gibt an, dass es sich um eine eingebaute Tabelle handelt. 4 <\/b>kennzeichnet eine per ODBC verknüpfte Tabelle, 5 <\/b>eine Abfrage und 6 <\/b>eine per Jet verknüpfte Tabelle – also beispielsweise eine externe Excel- oder Access-Tabelle oder Textdatei.<\/p>\n In einer Do While<\/b>-Schleife über diese Datensätze trägt die Prozedur für jede Tabelle oder Abfrage einen Datensatz in die Tabelle tblTabellenAbfragen <\/b>ein. Dazu ermittelt diese mit der Funktion KlassennameErmitteln <\/b>den Namen der zu erzeugenden Klasse – mehr dazu weiter unten. Eine INSERT INTO<\/b>-Anweisung füllt die Felder TabelleAbfrageName<\/b>, Datenbank <\/b>und Klassenname <\/b>mit den ermittelten Werten. Anschließend aktualisiert die Prozedur die Datenherkunft des Formulars und des Kombinationsfeldes.<\/p>\n Felder der gewählten Datenherkunft anzeigen<\/b><\/p>\n Ein Unterformular namens sfmKlassengenerator <\/b>liefert die Daten zu den in der Tabelle\/Abfrage enthaltenen Feldern. Nach der Anzeige der Tabellen und Abfragen der aktuellen Datenbank und der Auswahl eines der Objekte durch den Benutzer soll das Unterformular alle Felder dieser Datenherkunft in der Datenblattansicht anzeigen. Dazu erstellen Sie zunächst ein Unterformular namens sfmKlassengenerator<\/b>. Weisen Sie seiner Eigenschaft Datenherkunft <\/b>die Tabelle tblFelder <\/b>zu. Ziehen Sie die drei Felder Feldname<\/b>, Eigenschaftsname <\/b>und Erzeugen <\/b>in den Detailbereich des Formularentwurfs und stellen Sie die Eigenschaft Standardansicht <\/b>des Formulars auf Datenblatt <\/b>ein (s. Bild 7).<\/p>\n Bild 7: Unterformular zur Anzeige der Felder der Tabelle oder Abfrage<\/span><\/b><\/p>\n Speichern Sie das Formular, öffnen Sie das Hauptformular frmKlassengenerator <\/b>in der Entwurfsansicht und ziehen Sie das Unterformular sfmKlassengenerator <\/b>aus dem Datenbankfenster beziehungsweise dem Navigationsbereich in den Detailbereich des Hauptformulars. Das Ergebnis sieht nun etwa wie in Bild 8 aus. Nun sorgen Sie dafür, dass nach der Auswahl einer Tabelle oder Abfrage durch den Benutzer die entsprechenden Felder im Unterformular angezeigt werden. Dazu müssen diese zunächst einmal in die Tabelle tblFelder <\/b>eingetragen werden – dies ist bislang noch nicht geschehen.<\/p>\n Bild 8: Hauptformular mit integriertem Unterformular in der Entwurfsansicht<\/span><\/b><\/p>\n Dazu fügen Sie für das Kombinationsfeld cboTabelleAbfrage <\/b>eine neue Ereignisprozedur für das Ereignis Nach Aktualisierung <\/b>hinzu (s. Listing 3<\/a><\/span>). Diese Prozedur verwendet wiederum zwei Objektvariablen des Typs Database<\/b> – eines für die Add-In-Datenbank und eines für die aufrufende Datenbank. Die Prozedur prüft zunächst, ob der Benutzer überhaupt einen Eintrag im Kombinationsfeld cboTabelleAbfrage <\/b>ausgewählt hat.<\/p>\n Listing 3: Füllen der Tabelle tblFelder<\/p>\n <\/p>\n Falls ja, prüft eine weitere Bedingung, ob die Tabelle tblFelder <\/b>bereits mindestens einen Datensatz enthält, der mit der ausgewählten Tabelle\/Abfrage verknüpft ist. Falls ja, fragt die Prozedur den Benutzer, ob die Felder neu eingelesen und somit die gegebenenfalls bereits angepassten Eigenschaftsnamen und die Werte des Feldes Erzeugen <\/b>zurückgesetzt werden sollen. Wenn der Benutzer hier auf Nein <\/b>klickt, aktualisiert die Prozedur nur die Anzeige der Felder der gewählten Datenherkunft. Man könnte hier noch weiter ins Detail gehen und prüfen, ob sich die Anzahl oder die Eigenschaften der Felder geändert haben, aber das würde den Rahmen des Beitrags sprengen.<\/p>\n Hat der Benutzer jedoch auf Ja <\/b>geklickt oder sind noch keine Daten für diese Tabelle\/Abfrage vorhanden, füllt die Prozedur die Variablen dbHost <\/b>und dbAddIn <\/b>mit den entsprechenden Verweisen und führt eine Aktionsabfrage aus, die alle Einträge der Tabelle tblFelder <\/b>zur aktuellen Tabelle oder Abfrage löscht.<\/p>\n Danach erstellt die Prozedur ein neues Recordset-Objekt auf Basis der mit cboTabelleAbfrage <\/b>ausgewählten Tabelle oder Abfrage. Da wir nur die Felder ermitteln möchten, benötigen wir keine Daten – dementsprechend wird als Kriterium der Ausdruck 1=2 <\/b>eingestellt, der dafür sorgt, dass die Datensatzgruppe keine Daten enthält.<\/p>\n Nun durchläuft die Prozedur alle Field<\/b>-Elemente der Fields<\/b>-Auflistung des Recordset<\/b>-Objekts und trägt diese mithilfe einer INSERT INTO<\/b>-Aktionsabfrage in die Tabelle tblFelder <\/b>ein. Dabei füllt sie das Feld Eigenschaftsname <\/b>ebenfalls mit dem Feldnamen und trägt für das Feld TabelleAbfrageID <\/b>die entsprechende ID des mit dem Kombinationsfeld cboTabelleAbfrage <\/b>ausgewählten Eintrags ein.<\/p>\n Schließlich aktualisiert die Prozedur die im Unterformular sfmKlassengenerator <\/b>angezeigten Daten. Damit dies funktioniert, müssen Sie das Unterformular etwas anpassen – genauer gesagt das Unterformular-Steuerelement. Damit das Unterformular nur solche Datensätze anzeigt, die zu dem im Steuerelement cboTabelleAbfrage <\/b>ausgewählten Eintrag passen, stellen Sie die Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>des Unterformulars wie in Bild 9 auf die Werte TabelleAbfrageID <\/b>und cboTabelleAbfrage <\/b>ein.<\/p>\n Bild 9: Unterformular nach der ausgewählten Tabelle oder Abfrage filtern<\/span><\/b><\/p>\n Dadurch zeigt das Unterformular nur diejenigen Datensätze an, deren Fremdschlüsselfeld TabelleAbfrageID <\/b>mit dem im Kombinationsfeld cboTabelleAbfrage <\/b>ausgewählten Wert übereinstimmt (s. Bild 10). Hier kann der Benutzer nun ansetzen und einige Einstellungen vornehmen, die im weiteren Verlauf interessant werden. So kann er hier etwa die in der Klasse zu verwendenden Bezeichnungen für die Eigenschaften auf Basis der Feldnamen anpassen und mit dem Ja\/Nein<\/b>-Feld Erzeugen <\/b>grundsätzlich festlegen, ob ein Feld überhaupt verwendet werden soll.<\/p>\n Bild 10: Anzeige der Felder der gewählten Datenherkunft<\/span><\/b><\/p>\n Einstellungen für die Erzeugung der Klasse<\/b><\/p>\n Ein Element einer Klasse für eine Tabelle oder Abfrage besteht aus drei Teilen: der Deklaration der privaten Variablen zum Speichern des Feldwertes, der Public Property Set\/Let<\/b>-Prozedur zum Einstellen des Eigenschaftswertes und der Public Property Let<\/b>-Prozedur zum Auslesen des Eigenschaftswertes (siehe clsPerson<\/b>):<\/p>\n Die Verwendung dieser Klasse sieht etwa wie folgt aus:<\/p>\n Die meisten hier verwendeten Informationen lassen sich beim Einlesen der Eigenschaften der Tabelle und der enthaltenen Felder ermitteln. Einige sollen jedoch gleich automatisch angepasst werden, andere erst beim Zusammenstellen des Codes der Klasse.<\/p>\n Der Klassenname etwa wird aus dem Tabellen- oder Abfragenamen abgeleitet. Dort soll das Präfix (etwa tbl <\/b>oder qry<\/b>) durch das Präfix cls <\/b>ersetzt werden. Und die Member-Variablen (wie m_Vorname<\/b>) werden aus den Feldnamen abgeleitet und um ein Präfix wie m_ <\/b>erweitert. Wo aber legt der Benutzer diese Informationen fest Theoretisch könnte man es sich leicht machen und diese Daten einfach im Code verankern. Allerdings sollten diese Einstellungen durchaus flexibel vorgenommen werden können, weshalb wir dafür eine entsprechende Optionen-Tabelle einrichten, deren Werte der Benutzer nach Belieben einstellen kann.<\/p>\n Diese Tabelle heißt tblOptionen <\/b>und sieht im Entwurf wie in Bild 11 aus. Die Felder haben die folgende Funktion:<\/p>\n Bild 11: Entwurf der Tabelle tblOptionen<\/span><\/b><\/p>\n Das Formular zum Bearbeiten dieser Einstellungen heißt frmOptionen <\/b>und verwendet die Tabelle tblOptionen <\/b>als Datenherkunft (s. Bild 12). Es enthält die Felder der Datenherkunft sowie eine Schaltfläche namens cmdOK<\/b>, die das Formular wieder schließt. Dazu verwendet es die folgende Ereignisprozedur:<\/p>\n Bild 12: Das Formular frmOptionen zum Bearbeiten der Optionen<\/span><\/b><\/p>\n Die Eigenschaften Navigationsschaltflächen<\/b>, Datensatzmarkierer<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>dieses Formulars stellen Sie auf Nein<\/b>, die Eigenschaft Automatisch zentrieren <\/b>auf Ja <\/b>ein. Das Optionen-Formular rufen Sie mit einer Schaltfläche im Formular frmKlassengenerator <\/b>auf (s. Bild 13). Diese löst die folgende Prozedur aus:<\/p>\n Bild 13: Aufruf des Optionen-Formulars<\/span><\/b><\/p>\n Wo kommen die in dieser Tabelle gespeicherten Optionen nun zum Einsatz Einen Fall haben Sie bereits kennengelernt. Wenn die Tabellen der Datenbank neu eingelesen werden, ruft die Prozedur TabellenAbfragenEinlesen <\/b>die Funktion KlassennameErmitteln <\/b>auf und übergibt dieser den Namen der Tabelle\/Abfrage<\/b>, für die ein Klassenname generiert werden soll. Aus tblPersonen <\/b>soll so etwa clsPersonen <\/b>werden.<\/p>\n Diese Funktion finden Sie in Listing 4<\/a><\/span>. Sie liest zunächst die Liste der semikola-separierten und zu ersetzenden Präfixe aus dem Feld TabelleAbfragePraefixErsetzen <\/b>der Tabelle tblOptionen <\/b>ein. Diese wird per Split<\/b>-Funktion direkt in ein Array umgewandelt und in der Variablen strPraefixe() <\/b>gespeichert.<\/p>\n Listing 4: Ermitteln eines Klassennamens auf Basis des Namens der Tabelle\/Abfrage<\/p>\n In einer For…Next<\/b>-Schleife über alle Elemente dieses Arrays ersetzt die Prozedur alle vorkommenden Präfixe durch eine leere Zeichenkette. Aus tblPersonen <\/b>wird so zunächst Personen<\/b>. Anschließend liest die Prozedur das Präfix für Klassennamen aus dem Feld Klassenpraefix <\/b>der Tabelle tblOptionen <\/b>ein und fügt dieses vorn an den Klassennamen an. Das Ergebnis wird als Funktionswert zurückgegeben.<\/p>\n Klassen generieren<\/b><\/p>\n Ein Klick auf die Schaltfläche cmdKlasseGenerieren <\/b>soll den Klassencode zusammenstellen und im Textfeld txtKlassencode <\/b>darstellen. Dieses Textfeld erfordert einige spezielle Einstellungen. Als Erstes legen Sie für die Eigenschaft Schriftart <\/b>den Wert Courier New<\/b> und Schriftgrad <\/b>auf den Wert 8 <\/b>oder 9 <\/b>fest. Die Eigenschaft Bildlaufleisten <\/b>erhält den Wert Vertikal<\/b>. Das Textfeld soll seinen Inhalt dann etwa wie in Bild 14 anzeigen.<\/p>\n Bild 14: Das Formular frmKlassengenerator mit frisch erzeugtem Code<\/span><\/b><\/p>\n Was geschieht nun nach einem Mausklick auf die Schaltfläche cmdErzeugen<\/b> Dies löst die Prozedur aus Listing 5<\/a><\/span> aus. Die Prozedur stellt nach und nach den kompletten Code der Klasse zusammen. Die Zwischenergebnisse speichert die Prozedur dabei in verschiedenen Variablen. Den Beginn macht die Variable strKopf<\/b>, welche die beiden Kopfzeilen aufnimmt:<\/p>\n Listing 5: Prozedur zum Zusammenstellen des Codes der Klasse auf Basis einer Tabelle oder Abfrage<\/p>\n Danach folgen einige Vorbereitungen. So ermittelt die Prozedur per FLookup das Präfix für die Membervariablen (zum Beispiel m_<\/b>) und speichert es in der Variablen strMemberpraefix<\/b>. Dann erstellt es drei Objekte. dbAddIn<\/b> referenziert die aktuelle Datenbank. rstTabelleAbfrage <\/b>liefert den Datensatz der Tabelle tblTabelleAbfrage<\/b>, zu dem die Prozedur den Klassencode erzeugen soll, und rstFelder <\/b>enthält ein Recordset mit allen Datensätzen der Tabelle tblFelder<\/b>, die zur ausgewählten Tabelle gehören.<\/p>\n Eine Do While<\/b>-Schleife durchläuft alle Datensätze der Datensatzgruppe rstFelder<\/b>. Darin ruft die Prozedur die Routine DatentypErmitteln <\/b>auf, die mit dem Datentyp für das aktuelle Feld gefüttert wird und das Präfix für diesen Datentyp und die Bezeichnung des Datentyps zurückliefert sowie einen Boolean-Wert, der angibt, ob es sich um einen Objektdatentyp handelt.<\/p>\n Letztere Information landet in der Variablen bolObjekt<\/b>. Ist diese True<\/b>, wird zum Übergeben eines Wertes für die entsprechende Eigenschaft eine Zeile wie <\/p>\n verwendet, sonst eine solche:<\/p>\n Der Unterschied liegt in der Verwendung des Schlüsselworts Let <\/b>oder Set<\/b>. Dieses Schlüsselwort wird je nach dem Wert von bolObjekt <\/b>in der Variablen strLetSet <\/b>gespeichert (also Let <\/b>oder Set<\/b>).<\/p>\n Das Recordset rstFelder <\/b>liefert mit dem Feld Eigenschaftsname <\/b>den in der Klasse zu verwendenden Namen für die Eigenschaft. Diesen speichert die Prozedur in der Variablen strEigenschaftsname<\/b>.<\/p>\n Danach setzt die Prozedur in einer Variablen namens strMembervariablen<\/b> die Liste der Variablendeklarationen zusammen. Ein Element sieht etwa so aus:<\/p>\n Die Variable strMembervariablen <\/b>nimmt alle Variablendeklarationen auf – getrennt jeweils durch einen Zeilenumbruch (vbCrLf<\/b>).<\/p>\n Die Variable strProperty <\/b>nimmt die Get<\/b>– beziehungsweise die Let\/Set<\/b>-Property-Prozeduren auf.<\/p>\n Die erste Zeile der Get<\/b>-Prozedur setzt sich beispielsweise aus den Schlüsselwörtern Public Property Get<\/b>, dem Eigenschaftsnamen aus strEigenschaftsname<\/b>, dem Schlüsselwort As <\/b>und dem Datentyp (aus strDatentyp<\/b>) zusammen. Die übrigen Zeilen werden auf ähnliche Weise zusammengestellt.<\/p>\n Nach dem Durchlaufen der Do While<\/b>-Schleife für alle Datensätze setzt die Prozedur noch die einzelnen Elemente, also strKopf<\/b>, strMembervariablen <\/b>und strProperty <\/b>zusammen und trägt das Ergebnis in das Textfeld txtKlassencode <\/b>ein.<\/p>\n Datentypabhängige Elemente ermitteln<\/b><\/p>\n Weiter oben haben wir bereits die Prozedur DatentypErmitteln<\/b> erwähnt, die vier Parameter verwendet. Dabei erwartet der Eingangsparameter intDatentyp <\/b>eine Zahl, die den Datentyp des Tabellenfeldes repräsentiert.<\/p>\n Auf Basis dieses Wertes soll die Prozedur die drei Rückgabeparameter strPraefixDatentyp<\/b>, strDatentyp <\/b>und bolObjekt <\/b>füllen.<\/p>\n Die Prozedur sieht (in verkürzter Form) wie in Listing 6<\/a><\/span> aus. Sie enthält eine einfache Select Case<\/b>-Bedingung, die abhängig vom Wert von intDatentyp <\/b>verzweigt und die Rückgabeparameter mit den entsprechenden Werten füllt.<\/p>\n Listing 6: Ermitteln von Elementen abhängig vom Datentyp<\/p>\n Prozedur zum Erzeugen einer Klasse <\/b><\/p>\n Wenn man schon eine Klasse zum Speichern der Daten eines Datensatzes einer Tabelle oder Abfrage erstellt, möchte man diese im Praxiseinsatz gegebenenfalls auch schnell mit den Daten aus der entsprechenden Datenherkunft füllen. Die dazu benötigten Codezeilen lassen sich ebenfalls leicht automatisiert zusammenstellen.<\/p>\n Der resultierende Code sollte beispielsweise wie in Listing 7<\/a><\/span> aussehen.<\/p>\n Listing 7: Prozedur zum Erzeugen eines Objekts mit den Daten eines Kundendatensatzes<\/p>\n Das Aufrufen der Prozedur und die Nutzung des zurückgelieferten Objekts erfordert dann nur noch wenige Zeilen:<\/p>\n In diesem Beispiel erzeugt ErzeugeKunden <\/b>ein neues Objekt auf Basis der Klasse clsKunden<\/b>, füllt seine Eigenschaften mit den Daten des Datensatzes mit dem Wert 71 <\/b>im Feld KundeID <\/b>und gibt testweise die E-Mail-Adresse für diesen Kunden aus.<\/p>\n![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic001.png\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic003.png\")
<\/p>\n\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic004.png\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic005.png\")
<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic002.png\")
<\/p>\nPrivate Sub Form_Load()\r\n Dim strDatenbank As String\r\n strDatenbank = CurrentProject.Name\r\n If IsNull(FLookup("TabelleAbfrageID", "tblTabellenAbfragen", "Datenbank = ''" & strDatenbank _\r\n & "''")) Then\r\n TabellenAbfragenEinlesen\r\nEnd If\r\nMe!cboTabelleAbfrage.RowSource = "SELECT * FROM tblTabellenAbfragen WHERE Datenbank = ''" _\r\n & strDatenbank & "''"\r\nEnd Sub<\/pre>\nPrivate Sub TabellenAbfragenEinlesen()\r\n Dim dbHost As DAO.Database\r\n Dim dbAddIn As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim strKlassenname As String\r\n Set dbHost = CurrentDb\r\n Set dbAddIn = CodeDb\r\n Set rst = dbHost.OpenRecordset("SELECT Name, Type FROM MSysObjects WHERE Type IN (1,4,5,6) " _\r\n & "AND Name NOT LIKE ''~*'' ORDER BY Name", dbOpenDynaset)\r\n Do While Not rst.EOF\r\n strKlassenname = KlassennameErmitteln(rst!Name)\r\n dbAddIn.Execute "INSERT INTO tblTabellenAbfragen(TabelleAbfrageName, Datenbank, Klassenname) " _\r\n & "VALUES(''" & rst!Name & "'', ''" & CurrentProject.Name & "'', ''" & strKlassenname & "'')", _\r\n dbFailOnError\r\n rst.MoveNext\r\n Loop\r\n Me.Requery\r\n Me!cboTabelleAbfrage.Requery\r\n Set dbHost = Nothing\r\n Set dbAddIn = Nothing\r\nEnd Sub<\/pre>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic006.png\")
<\/p>\n![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic007.png\")
<\/p>\nPrivate Sub cboTabelleAbfrage_AfterUpdate()\r\n Dim dbHost As DAO.Database\r\n Dim dbAddIn As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim fld As DAO.Field\r\n Dim bolEinlesen As Boolean\r\n If Not IsNull(Me!cboTabelleAbfrage) Then\r\n bolEinlesen = True\r\n If Not IsNull(FLookup("FeldID", "tblFelder", "TabelleAbfrageID = " & Me!cboTabelleAbfrage)) Then\r\n bolEinlesen = _\r\n MsgBox("Felder neu einlesen und vorhandene Daten überschreiben", vbYesNo) = vbYes\r\n End If\r\n If bolEinlesen Then\r\n Set dbHost = CurrentDb\r\n Set dbAddIn = CodeDb\r\n dbAddIn.Execute "DELETE FROM tblFelder WHERE TabelleAbfrageID = " _\r\n & Me!cboTabelleAbfrage, dbFailOnError\r\n Set rst = dbHost.OpenRecordset("SELECT * FROM " & Me!cboTabelleAbfrage.Column(1) _\r\n & " WHERE 1=2", dbOpenDynaset)\r\n For Each fld In rst.Fields\r\n dbAddIn.Execute "INSERT INTO tblFelder(Feldname, Eigenschaftsname, " _\r\n "TabelleAbfrageID, Erzeugen, Datentyp) VALUES(''" & fld.Name & "'', ''" _\r\n & fld.Name & "'', " & Me!cboTabelleAbfrage & ", -1, " & fld.Type & ")", _\r\n dbFailOnError\r\n Next fld\r\n End If\r\n Me!sfmKlassengenerator.Form.Requery\r\n Me.Filter = "TabelleAbfrageID = " & Me!cboTabelleAbfrage\r\n Me.FilterOn = True\r\n End If\r\nEnd Sub<\/pre>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic008.png\")
<\/p>\n![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic009.png\")
<\/p>\nDim m_Vorname As String\r\nPublic Property Let Vorname(strVorname As String)\r\n m_Vorname = strVorname\r\nEnd Property\r\nPublic Property Get Vorname() As String\r\n Vorname = m_Vorname\r\nEnd Property<\/pre>\n
Public Sub Test_Klasse()\r\n Dim objPerson As clsPerson\r\n Set objPerson = New clsPerson\r\n With objPerson\r\n .Vorname = "André"\r\n Debug.Print .Vorname\r\n End With\r\n Set objPerson = Nothing\r\nEnd Sub<\/pre>\n
![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic010.png\")
<\/p>\n\n
![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic011.png\")
<\/p>\nPrivate Sub cmdOK_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/pre>\n
![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic012.png\")
<\/p>\nPrivate Sub cmdOptionen_Click()\r\n DoCmd.OpenForm "frmOptionen", _\r\n WindowMode:=acDialog\r\nEnd Sub<\/pre>\n
Private Function KlassennameErmitteln(strDatenherkunft As String)\r\n Dim strKlassenname As String\r\n Dim strPraefixe() As String\r\n Dim strPraefix As String\r\n Dim i As Integer\r\n strPraefixe = Split(FLookup("TabelleAbfragePraefixErsetzen", "tblOptionen"), ";")\r\n strKlassenname = strDatenherkunft\r\n For i = LBound(strPraefixe) To UBound(strPraefixe)\r\n strKlassenname = Replace(strKlassenname, strPraefixe(i), "", 1, 1)\r\n Next i\r\n strPraefix = FLookup("Klassenpraefix", "tblOptionen")\r\n strKlassenname = strPraefix & strKlassenname\r\n KlassennameErmitteln = strKlassenname\r\nEnd Function<\/pre>\n![\"pic013.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic013.png\")
<\/p>\nPrivate Sub cmdErzeugen_Click()\r\n Dim strKlasse As String\r\n Dim strKopf As String\r\n Dim dbAddIn As DAO.Database\r\n Dim rstTabelle As DAO.Recordset\r\n Dim rstFelder As DAO.Recordset\r\n Dim strMembervariablen As String\r\n Dim strMemberpraefix As String\r\n Dim strEigenschaftsname As String\r\n Dim strDatentyp As String\r\n Dim strProperty As String\r\n Dim strPraefixDatentyp As String\r\n Dim strLetSet As String\r\n Dim bolObjekt As Boolean\r\n strKopf = strKopf & "Option Explicit" & vbCrLf\r\n strKopf = strKopf & "Option Compare Database" & vbCrLf\r\n strMemberpraefix = FLookup("Memberpraefix", "tblOptionen")\r\n Set dbAddIn = CodeDb\r\n Set rstTabelle = dbAddIn.OpenRecordset("SELECT * FROM tblTabellenAbfragen " _\r\n & "WHERE TabelleAbfrageID = " & Me!cboTabelleAbfrage, dbOpenDynaset)\r\n Set rstFelder = dbAddIn.OpenRecordset("SELECT * FROM tblFelder WHERE TabelleAbfrageID = " _\r\n & Me!cboTabelleAbfrage & " AND Erzeugen = -1", dbOpenDynaset)\r\n Do While Not rstFelder.EOF\r\n DatentypErmitteln rstFelder!Datentyp, strPraefixDatentyp, strDatentyp, bolObjekt\r\n If bolObjekt Then\r\n strLetSet = "Set"\r\n Else\r\n strLetSet = "Let"\r\n End If\r\n strEigenschaftsname = rstFelder!Eigenschaftsname\r\n strMembervariablen = strMembervariablen & "Dim " & strMemberpraefix & rstFelder!Feldname _\r\n & " As " & strDatentyp & vbCrLf\r\n strProperty = strProperty & "Public Property Get " & strEigenschaftsname & " As " _\r\n & strDatentyp & vbCrLf\r\n strProperty = strProperty & " " & strEigenschaftsname & " = " & strMemberpraefix _\r\n & strEigenschaftsname & vbCrLf\r\n strProperty = strProperty & "End Property" & vbCrLf & vbCrLf\r\n strProperty = strProperty & "Public Property " & strLetSet & " " & strEigenschaftsname _\r\n & "(" & strPraefixDatentyp & strEigenschaftsname & " As " & strDatentyp & ")" & vbCrLf\r\n strProperty = strProperty & " " & strMemberpraefix & strEigenschaftsname & " = " _\r\n & strPraefixDatentyp & strEigenschaftsname & vbCrLf\r\n strProperty = strProperty & "End Property" & vbCrLf & vbCrLf\r\n rstFelder.MoveNext\r\n Loop\r\n strKlasse = strKlasse & strKopf & vbCrLf\r\n strKlasse = strKlasse & strMembervariablen & vbCrLf\r\n strKlasse = strKlasse & strProperty\r\n Me!txtKlassencode = strKlasse\r\nEnd Sub<\/pre>\nPublic Property Let NichtObjekt(lngNichtObjekt As Long)<\/pre>\n
Public Property Set Objekt(objObjekt As Object)<\/pre>\n
Dim m_AbonnementID As Long<\/pre>\n
Private Sub DatentypErmitteln(intDatentyp As Integer, strPraefixDatentyp As String, _\r\n strDatentyp As String, bolObjekt As Boolean)\r\n Select Case intDatentyp\r\n Case dbBinary, dbLongBinary\r\n strDatentyp = "Object"\r\n strPraefixDatentyp = "obj"\r\n bolObjekt = True\r\n Case dbBoolean\r\n strDatentyp = "Boolean"\r\n strPraefixDatentyp = "bol"\r\n Case dbByte\r\n strDatentyp = "Byte"\r\n strPraefixDatentyp = "byt"\r\n Case ... weitere Datentypel\r\n Case Else ''dbTimeStamp, dbFloat, dbNumeric, dbBigInt, dbVarBinary, dbLongBinary\r\n MsgBox "Noch nicht implementierter Datentyp: " & intDatentyp\r\n End Select\r\nEnd Sub<\/pre>\n
Public Function ErzeugeKunden(lngID As Long) As clsKunden\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim objKunden As clsKunden\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset("SELECT * FROM tblKunden WHERE = " & lngID, dbOpenDynaset)\r\n Set objKunden = New clsKunden\r\n objKunden.KundeID = rst!KundeID\r\n objKunden.Kundenbezeichnung = rst!Kundenbezeichnung\r\n objKunden.AnredeID = rst!AnredeID\r\n objKunden.Vorname = rst!Vorname\r\n objKunden.Nachname = rst!Nachname\r\n objKunden.Firma = rst!Firma\r\n objKunden.Strasse = rst!Strasse\r\n objKunden.PLZ = rst!PLZ\r\n objKunden.Ort = rst!Ort\r\n objKunden.Land = rst!Land\r\n objKunden.EMail = rst!EMail\r\n Set ErzeugeKunden = objKunden\r\n Set db = Nothing\r\nEnd Function<\/pre>\nPublic Sub TestKundenklasse()\r\n Dim objKunde As clsKunden\r\n Set objKunde = ErzeugeKunden(71)\r\n With objKunde\r\n Debug.Print .EMail\r\n End With\r\nEnd Sub<\/pre>\n
![\"pic014.png\"](\"..\/fileadmin\/_temp_\/2013_01\/Klassengenerator-web-images\/pic014.png\")
<\/p>\n