{"id":55000761,"date":"2011-02-01T00:00:00","date_gmt":"2020-05-22T22:01:30","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=761"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"CodeBibliotheken","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/CodeBibliotheken\/","title":{"rendered":"Code-Bibliotheken"},"content":{"rendered":"

\"\"<\/p>\n

Wer bereits eine Reihe von Projekten durchgeführt hat, verfügt in der Regel über einen Fundus immer wiederkehrender Elemente wie Prozeduren, Module oder Klassen. Diese kopiert man dann von bestehenden in neue Datenbanken und kann so getestete, funktionierende Elemente weiternutzen. Aber was ist, wenn man in einer Datenbank Fehler an einem solchen Element findet und behebt oder das Element gar weiterentwickelt Wie gewährleistet man, dass die übrigen Anwendungen, die dieses Element verwenden, auch davon profitieren Dies gelingt zum Beispiel durch den Einsatz von Code-Bibliotheken. Wie dieser in der Praxis aussieht, erfahren Sie in diesem Beitrag.<\/b><\/p>\n

Auch wer nur ganz wenige Zeilen seines Codes in anderen Anwendungen weiterverwendet: Standardfunktionen wie etwa zum Ermitteln eines SQL-formatierten Datums (#2010\/10\/01#) oder FLookup und Co. (schnellere Varianten der eingebauten Domänenfunktionen) oder ähnliche wird wohl jeder Entwickler bereits einmal aus einer Anwendung kopiert und in eine weitere Anwendung eingefügt haben.<\/p>\n

Hin und wieder zeigt sich jedoch, dass das eine oder andere Element nicht wie gewünscht funktioniert oder gar Fehler verursacht. Nach der änderung der verantwortlichen Codezeilen tritt der Fehler nicht mehr auf – aber nur in der Anwendung, in der Sie ihn behoben haben.<\/p>\n

Also ermitteln Sie alle Anwendungen, in denen die entsprechende Funktion noch vorkommt, was je nach Verbreitung gar nicht so einfach ist, und beheben den Fehler an allen betroffenen Stellen. <\/p>\n

Noch interessanter wird es, wenn Sie komplette Sätze, bestehend aus Elementen wie Tabellen, Abfragen, Formularen, Standard- und Klassenmodulen, immer wieder verwenden und diese wiederum auf gemeinsame Elemente zugreifen.<\/p>\n

Ein Beispiel ist ein Modul mit einer einfachen Funktion zur Fehlerbehandlung. Wenn alle Elemente in der gleichen Datenbankdatei stecken, können auch alle auf die gleiche Fehlerbehandlung zugreifen.<\/p>\n

Wenn Sie nun einen Satz von Elementen (eine Komponente), der auch die Fehlerbehandlung verwendet, von Anwendung A nach Anwendung B kopieren, läuft alles rund.<\/p>\n

Wenn Sie jetzt einen anderen Satz von Elementen von Anwendung C nach Anwendung B importieren, der die gleiche Fehlerbehandlung verwendet, ist diese doppelt vorhanden, was einen Kompilierfehler auslöst.<\/p>\n

Dies ist kein Problem, wenn Sie die Komponenten komplett in eigene Datenbankdateien auslagern und diese von den eigentlichen Datenbank-Anwendungen aus referenzieren: Jede Komponente kann dann ihre eigene Fehlerbehandlung verwenden.<\/p>\n

Oder, um das Spiel noch ein wenig weiterzutreiben: Die Fehlerbehandlung wird ihrerseits in eine weitere Datenbankdatei ausgelagert und von allen anderen Komponenten und auch von der Hauptanwendung referenziert.<\/p>\n

Und damit kommen wir zum Thema Codebibliotheken: Darunter versteht man im Allgemeinen herkömmliche Datenbankdateien, die über den Verweise-Dialog in die Hauptanwendung eingebunden werden.<\/p>\n

Bibliothek erstellen<\/b><\/p>\n

Als Bibliothek verwenden Sie eine herkömmliche Access-Datenbank (in den Beispieldateien heißt diese DBMitBibliothek.mdb<\/b>).<\/p>\n

Legen Sie fest, welche Access-Versionen auf diese Bibliothek zugreifen sollen und verwenden Sie die kleinste Version als Datenbankformat (viele verwenden noch Access 2000, weshalb dies größtmögliche Kompatibilität bietet – aber beachten Sie, dass beispielsweise nicht alle VBA-Befehle <\/b>hiermit funktionieren).<\/p>\n

Elemente, die Sie in anderen Datenbanken verwenden möchten, müssen als Public <\/b>deklariert werden. Beginnen wir mit einer kleinen Beispielfunktion namens BibMsgBox<\/b>, die wie folgt aussieht und in einem Standardmodul namens mdlBibliothek <\/b>landet:<\/p>\n

Public Sub BibMsgBox()\r\n    MsgBox "Meldung aus der Bibliothek"\r\nEnd Sub<\/pre>\n
Die Prozedur zeigt ein einfaches Meldungsfenster an. Damit die Bibliothek beim Einbinden in andere Datenbanken keinen Konflikt auslöst, vergeben Sie einen eindeutigen Namen für das VBA-Projekt. Dies erledigen Sie in den Projekteigenschaften (Extras|Projekteigenschaften<\/b>, s. Bild 1).<\/p>\n
\"pic001.png\"<\/p>\n
Bild 1: Einstellen des Namens eines VBA-Projekts<\/span><\/b><\/p>\n
Bibliothek referenzieren<\/b><\/p>\n
Nun öffnen oder erstellen Sie die Datenbank, welche die in der Bibliothek befindliche Routine aufrufen soll. Dort müssen Sie die Bibliothek zunächst referenzieren, was Sie über den Verweise<\/b>-Dialog erledigen.<\/p>\n
Aktivieren Sie mit Alt + F11 <\/b>den VBA-Editor und wählen Sie den Menüeintrag Extras|Verweise <\/b>aus. Klicken Sie auf Durchsuchen und wählen Sie die soeben erstellte Bibliotheksdatenbank aus. Diese erscheint anschließend in der Liste der Verweise (s. Bild 2).<\/p>\n
\"pic002.png\"<\/p>\n
Bild 2: Ein Verweis auf eine Bibliotheksdatenbank<\/span><\/b><\/p>\n
Sollte dies nicht der Fall sein, ist möglicherweise im Projekt-Explorer des VBA-Editors das falsche Projekt aktiviert. Der Projekt-Explorer zeigt nämlich nach dem Einbinden der Bibliothek nicht mehr nur das zur aktuellen Datenbankdatei gehörende VBA-Projekt in der Übersicht an, sondern auch das per Verweis eingebundene (s. Bild 3). Ist dieses aktiviert, zeigt der Verweise<\/b>-Dialog die für dieses VBA-Projekt festgelegten Verweise an.<\/p>\n
\"pic003.png\"<\/p>\n
Bild 3: Auch in Bibliotheksdatenbanken enthaltene Projekte werden im Projekt-Explorer angezeigt.<\/span><\/b><\/p>\n
ändern von Bibliotheken<\/b><\/p>\n
Wenn Sie Bibliotheken verwenden, stellen sich oft erst im Einsatz in der Zielanwendung Programmierfehler heraus. Sie werden dann normalerweies schnell in den VBA-Editor wechseln, um das Problem zu beheben.<\/p>\n
Auch wenn dies im ersten Moment gelingt: änderungen an Bibliotheken von anderen Anwendungen aus sind, genau wie bei Access-Add-Ins auch, nur temporär und halten genau solange, bis Sie die Anwendung schließen.<\/p>\n
Das reicht zum Testen, ob ein Bugfix funktioniert, zum Durchführen der eigentlichen änderung müssen Sie die Bibliotheksdatenbank jedoch allein öffnen. Ein kleiner Praxistipp: Nehmen Sie kleinere änderungen direkt von der Host-Anwendung aus vor und testen Sie diese.<\/p>\n
<\/p>\n
Dann kopieren Sie das komplette Modul, schließen die Hauptanwendung, öffnen die Bibliotheksdatenbank und fügen den geänderten Code in das entsprechende Modul ein. Größere änderungen sollten Sie jedoch direkt in der Bibliotheksanwendung durchführen, da änderungen sonst schnell versehentlich verloren gehen.<\/p>\n
Komplette Klassen aus Bibliotheken verwenden<\/b><\/p>\n
Der Anlass für diesen Beitrag ist eigentlich der Einsatz verschiedener Klassenmodule beziehungsweise kompletter Sammlungen von Modulen und anderen Elementen in unterschiedlichen Anwendungen (ein Beispiel folgt in der kommenden Ausgabe von Access im Unternehmen).<\/p>\n
Damit jede Anwendung gleich von eventuellen änderungen profitiert, sollen alle die gleiche Bibliothek anzapfen und den dort enthaltenen Code verwenden.<\/p>\n
In vielen Fällen reicht es aus, lediglich auf die öffentlich deklarierten Funktionen und Prozeduren der Bibliothek zuzugreifen. Der TreeViewHandler beispielsweise wird jedoch enger mit der Host-Anwendung verzahnt.<\/p>\n
Diese soll beispielsweise auf Ereignisse reagieren, die durch den Zugriff auf die Elemente des mit dem TreeViewHandler gesteuerten TreeViews ausgelöst werden – ein Klick auf ein Element, das Anzeigen des Kontextmenüs und so weiter. Damit dies funktioniert, müssen Sie in der Host-Anwendung gleich eine komplette Klasse instanzieren.<\/p>\n
Wir zeigen an einem kleinen Beispiel, wie das funktioniert. Die Beispieldatenbank Bibliothek.mdb <\/b>enthält eine Klasse namens clsEreignisklasse <\/b>mit folgendem Inhalt:<\/p>\n
Public Event EreignisWurdeAusgeloest()\r\nPublic Sub Ereignisausloesen()\r\n    RaiseEvent EreignisWurdeAusgeloest\r\nEnd Sub\r\nPublic Sub Methode()\r\n    MsgBox "Methode funktioniert"\r\nEnd Sub<\/pre>\n
Wenn Sie diese Datenbank nun schließen und die oben bereits verwendete Host-Datenbank DBMitBibliothek<\/b> öffnen, sollten Sie die Klasse eigentlich referenzieren können – beispielsweise wie bei der Deklaration in Bild 4.<\/p>\n
\"pic005.png\"<\/p>\n
Bild 4: Die Klasse ist trotz Verweis nicht sichtbar.<\/span><\/b><\/p>\n
Allerdings bietet nicht nur IntelliSense keine solche Klasse zur Auswahl an, die Deklaration wie in folgender Zeile führt sogar zu einem Kompilierfehler (Benutzerdefinierter Typ nicht deklariert<\/b>):<\/p>\n
Public objEreignisklasse As clsEreignisklasse<\/pre>\n
Das Problem ist die für diesen Zweck falsche Deklaration des Klassenmoduls in der Bibliotheksdatenbank. Für diese müssen Sie die Eigenschaft Instancing <\/b>auf PublicNonCreatable<\/b> einstellen (s. Bild 5).<\/p>\n
\"pic004.png\"<\/p>\n
Bild 5: Deklarieren der Klasse als öffentliches Element<\/span><\/b><\/p>\n
Diese Einstellung ermöglicht nun zwar die Deklaration, allerdings hapert es mit der Instanzierung. Wenn Sie dies mit der folgenden Anweisung erledigen möchten, lösen Sie damit einen Fehler aus, der die unzulässige Verwendung des Schlüsselworts New anmahnt:<\/p>\n
Set objEreignisklasse = New clsEreignisklasse<\/pre>\n
Letztlich teilt die Einstellung PublicNonCreatable <\/b>ja bereits mit, dass die Klasse nun wohl öffentlich verfügbar ist, aber nicht instanziert werden kann. Kein Problem, denn dies funktioniert zumindest im privaten Rahmen eines Standardmoduls der Bibliotheksdatenbank Bibliothek.mdb<\/b>.<\/p>\n
Dieses Modul heißt mdlBibliothek <\/b>und enthält die folgende Funktion:<\/p>\n
Public Function NeueEreignisklasse() As clsEreignisklasse\r\n    Set NeueEreignisklasse = New clsEreignisklasse\r\nEnd Function<\/pre>\n
In der Host-Datenbank DBMitVerweis <\/b>legen Sie nun folgende Prozedur an, um ein Objekt auf Basis der Klasse clsEreignisklasse <\/b>der Bibliotheksdatenbank zu erstellen:<\/p>\n
Public Sub TestEreignisklasse()\r\n    Set objEreignisklasse = NeueEreignisklasse\r\nEnd Sub<\/pre>\n
Leider führt dies zumindest bei der Beispieldatenbank und der Beispielbibliothek zu reproduzierbaren Abstürzen, zumindest unter Access 2010.<\/p>\n
Also gehen wir noch einen Schritt weiter, indem wir Folgendes durchführen:<\/p>\n