<\/p>\n
Mit Access 2007 ist wieder mal eine neue Version erschienen. Damit stellt sich für Softwareentwickler und auch für Anwender die Frage, ob man zu dieser Version wechseln sollte oder vielleicht versucht, eine Anwendung so weit anzupassen, dass diese auch mit der neuen Version zusammenarbeitet und gleichzeitig die vorhandenen Versionen unterstützt. Wie sich das für einzelne Features umsetzen lässt, zeigen wir am Beispiel PDF-Export.<\/b><\/p>\n
Eine Anwendung bauen, die unter Access 2003 und älter und auch unter Access 2007 läuft Was soll das bringen und vor allem: Wie soll das funktionieren Bei früheren Versionswechseln sah man sich in der Regel nicht solch gravierenden Neuerungen ausgesetzt wie es jetzt unter Access 2007 der Fall ist. Das gilt natürlich insbesondere für das Ribbon, das die bisher verwendeten Menüleisten ersetzt. Aber auch unter VBA und in anderen Bereichen sind einige Features hinzugekommen.<\/p>\n
Wir haben uns den PDF-Export vorgenommen, der unter Access 2003 und älter und unter Access 2007 auf unterschiedliche (kostenlose) Weise erfolgen kann, um zu untersuchen, wie man eine Anwendung für mehrere Access-Versionen und deren Eigenarten vorbereitet.<\/p>\n
Lebans vs. Microsoft<\/b><\/p>\n
Bis Office 2007 erschien und mit ihm ein Add-In, das den Export von Access-Berichten und auch von Office-Dokumenten ins PDF-Format erlaubte, konnte man sich entweder bei einer der kostenpflichtigen Lösungen bedienen oder etwas Handgemachtes einsetzen. Für Access-Berichte haben viele Entwickler zu einer Lösung von Stephen Lebans gegriffen (http:\/\/www.lebans.com\/reporttopdf.htm<\/b>). Diese Lösung verwendet zwei DLLs, die man einfach im Systempfad speichert und vom Programmcode aus aufruft. Details dazu erfahren Sie im Beitrag Vom Bericht zum PDF-Dokument <\/b>(Shortlink 430).<\/p>\n
Ab Access 2007 bietet Microsoft unter folgendem Link ein Add-In an, mit dem man wahlweise über einen Eintrag des Office-Menüs oder über den Befehl DoCmd.OutputTo <\/b>ein Objekt (in der Regel einen Bericht) im PDF-Format speichert: http:\/\/www.microsoft.com\/downloads\/details.aspxdisplaylang=de&FamilyID=f1fc413c-6d89-4f15-991b-63b07ba5f2e5<\/b><\/p>\n
Alles in einem<\/b><\/p>\n
Für beide Lösungen ist eine gewisse Menge Code notwendig. Wenn Sie die Anwendung unter Access 2003 kompilieren, möchten Sie normalerweise nur den dafür nötigen Code dort unterbringen, unter Access 2007 sieht das genauso aus.<\/p>\n
VBA bietet für solche Fälle die bedingte Kompilierung an. Damit können Sie für ein Modul eine Konstante festlegen und in Abhängigkeit vom Wert dieser Konstanten in einer speziell markierten If…Then<\/b>-Anweisung den jeweiligen Code unterbringen. Das sieht etwa so aus:<\/p>\n Im aktuellen Fall, also mit dem Konstantenwert 2000, wird Access die erste MsgBox<\/b>-Anweisung ausführen.<\/p>\n Der Unterschied zu einer herkömmlichen If…Then<\/b>-Bedingung und der Clou an der Sache ist, dass VBA nur den Teil des Codes kompiliert, der beim aktuellen Wert der Konstanten AccessVersion <\/b>angesprungen wird. Das bedeutet, dass die .mdb\/.accdb-Datei zwar den kompletten Code im Rohformat enthält (also das, was Sie auch im VBA-Editor sehen, auch kanonischer Code genannt), aber nur den Teil in kompilierter Fassung (P-Code), den Sie durch die #If…#Then<\/b>-Bedingung zur bedingten Kompilierung freigegeben haben. Wenn Sie schon die gleiche Funktion für zwei verschiedene Access-Versionen im Projekt haben, brauchen Sie ja nicht auch noch das Kompilat des jeweils nicht benötigten Teils mitzuschleppen.<\/p>\n Noch besser wird es, wenn Sie eine .mde\/.accde-Datenbank aus der Originaldatenbank erzeugen: Hier wirft Access ja bekanntlich den kompletten kanonischen Code raus und behält nur den P-Code. Auf unser Beispiel bezogen fällt, wenn Sie beispielsweise eine Version für Access 2000 bis 2003 kompilieren, der Code weg, der für die Ausgabe von PDFs mit dem Microsoft'schen Add-In nötig war.<\/p>\n Pro Modul<\/b><\/p>\n Leider ist die Gültigkeit der Konstanten für die bedingte Kompilierung auf ein Modul beschränkt, und es gibt auch immer nur eine solche Konstante. Dabei spielt es allerdings keine Rolle, ob Sie die Konstante innerhalb einer Routine oder im Modulkopf festlegen. Es ist sogar egal, ob Sie die #If…#Then<\/b>-Anweisung zur bedingten Kompilierung innerhalb oder außerhalb von Routinen unterbringen. Das kann zum Beispiel auch so aussehen:<\/p>\n <\/p>\n In diesem Beispiel gibt es dieselbe Routine gleich zweimal. Welche der beiden ausgeführt wird, entscheidet der Wert der Konstanten AccessVersion<\/b>, die sich hier einmal innerhalb einer Routine befindet. Der Grund für die lockere Handhabung ist, dass VBA sich vor dem Kompilieren zunächst die mit dem Raute-Zeichen (#) beginnenden Zeilen ansieht und rauswirft, was nicht kompiliert werden soll. In diesem Fall liefert der Aufruf der Routine BeispielBedingteKompilierung <\/b>erwartungsgemäß den Wert 2000<\/b>.<\/p>\n Globale Konstante<\/b><\/p>\n Wenn sich der bedingt zu kompilierende Code über mehrere Module verteilt, bedeutet das Kompilieren für verschiedene Versionen auf die Dauer viel Arbeit. Zum Glück gibt es eine Einstellung in den Eigenschaften eines VBA-Projekts, mit der Sie eine globale Konstante für diesen Zweck festlegen können. Diese Einstellung finden Sie im Eigenschaften-Dialog des VBA-Projekts (Extras|Eigenschaften von <Projektname>…<\/b>).<\/p>\n Löschen Sie zunächst die entsprechende Zeile aus dem VBA-Code und probieren Sie, ob die bedingte Kompilierung noch wie erwartet arbeitet. Da die Routine BeispielBedingteKompilierung <\/b>nur aufgerufen werden dürfte, wenn die Konstante den Wert 2000 <\/b>oder 2007 <\/b>enthält, sollte nun eine Fehlermeldung erscheinen, da überhaupt kein Wert festgelegt ist.<\/p>\n Tragen Sie nun im Eigenschaftsfenster unter Argumente für bedingte Kompilierung <\/b>den Ausdruck ein, den Sie normalerweise im VBA-Code hinter #Const <\/b>eingefügt haben (siehe Bild 1). Ein erneuter Aufruf von BeispielBedingteKompilierung <\/b>dürfte nun wieder funktionieren und das Meldungsfenster mit der entsprechenden Versionsnummer anzeigen. Somit können Sie zumindest eine globale Konstante festlegen, statt diese gegebenenfalls in mehreren Modulen ändern zu müssen.<\/p>\n Bild 1: Das Eigenschaftsfenster eines VBA-Projekts<\/span><\/b><\/p>\n Dynamische bedingte Kompilierung<\/b><\/p>\n Nach aktuellem Stand müssen Sie zum Kompilieren die Konstante, wenn auch global, von Hand setzen. Konstanten heißen nun einmal so, weil man sie nicht wie eine Variable nach Lust und Laune ändern kann, ohne in den Code einzugreifen. Das ist schade, denn es wäre praktisch, wenn diese Konstante automatisch auf die Access-Version eingestellt werden könnte, in der die Anwendung gerade geöffnet wird.<\/p>\n Mit der im VBA-Code definierten Konstanten geht dies tatsächlich nicht, aber haben wir diese nicht gerade in ein Eigenschaftsfenster eingetragen Vielleicht kommt man da ja irgendwie heran – das klappt doch sonst immer recht gut. Und siehe da: Es gibt tatsächlich eine per VBA erreichbare Option, mit der sich diese Eigenschaft ändern lässt. Führen Sie einfach einmal die folgende Anweisung im Direktfenster des VBA-Editors aus:<\/p>\n Öffnen Sie dann die Projekteigenschaften und schauen Sie sich die Argumente für die bedingte Kompilierung an. Dort steht der soeben festgelegte Wert! Schließen Sie das Fenster wieder und prüfen Sie mit einem Aufruf von BeispielBedingteKompilierung<\/b>, ob die bedingte Kompilierung wie erwartet arbeitet. Stellen Sie den Wert nun auf 2007 ein:<\/p>\n Auch das funktioniert. Wie können Sie davon profitieren Ganz einfach: Sie müssen nur beim Start der Anwendung prüfen, unter welcher Access-Version diese geöffnet wurde, und die Konstante AccessVersion <\/b>entsprechend einstellen. Access wird dann zur Laufzeit nur die durch die #If…#Then<\/b>-Anweisung festgelegten Routinen oder Anweisungen kompilieren und ausführen.<\/p>\n Konstante per Makro festlegen<\/b><\/p>\n Die Konstante müssen Sie natürlich direkt beim Start der Anwendung festlegen. Den Aufruf der dazu benötigten Funktion erledigt das Makro Autoexec<\/b>, das Access beim Start automatisch ausführt (siehe Bild 2). Das Makro ruft die VBA-Funktion Start <\/b>auf, die mit der Eigenschaft Version <\/b>die Access-Version abfragt. Diese liefert einen Wert wie 11.0<\/b> oder 12.0<\/b>. Dabei ist nur die Zahl vor dem Komma relevant, die man mit der Val<\/b>-Funktion erhält. <\/p>\n Bild 2: Das Makro AutoExec ruft beim Start der Anwendung die Funktion Start() auf.<\/span><\/b><\/p>\n Für dieses Beispiel ist es interessant, ob die Anwendung in Access 2007 oder einer älteren Version geöffnet wurde. Access 2000 entspricht 9.0, Access 2002 10.0, Access 2003 11.0 und Access 2007 12.0. Die Routine muss also nur prüfen, ob die Versionsnummer den Wert 12 aufweist. Im Hinblick auf die kommende Version 14 verwenden wir aber nicht den Vergleichswert =12<\/b>, sondern >11<\/b>:<\/p>\n Bedingter PDF-Export<\/b><\/p>\n Damit das Ganze auch noch einen praktischen Anstrich erhält, schauen wir uns noch das Beispiel zum versionsabhängigen Export von Berichten im PDF-Format an. Voraussetzung für die Funktion ist das Vorhandensein der oben genannten Office 2007-Erweiterung um PDF-Funktionen von Microsoft sowie die beiden DLLs für die Version für Access 2000 bis 2003 von Stephen Lebans (Download siehe oben). Die Beispieldatenbank enthält eine modifizierte Fassung des notwendigen Codes von Stephen Lebans im Modul mdlReportToPDF<\/b>.<\/p>\n Es soll sowohl unter Access 2007 als auch für die älteren Versionen eine Funktion namens PDFExport <\/b>bereitstehen, die den Bericht mit dem angegebenen Namen in die gewünschte Datei schreibt:<\/p>\n Wenn Sie die bedingte Kompilierung konsequent fortsetzen möchten, müssen Sie natürlich auch alle Funktionen durch eine #If…#Then<\/b>-Anweisung ausklammern, die nur für den Lebans'schen PDF-Export benötigt werden. Dazu fassen Sie den kompletten Inhalt des Moduls wie folgt ein:<\/p>\n Kombinierte Konstanten<\/b><\/p>\n Leider gibt es immer nur eine globale Konstante. In dieser kann man aber durchaus mehrere Informationen unterbringen, indem man beispielsweise Betriebssystem und Access-Version durch einen Unterstrich trennt und diesen Ausdruck dann in der #If…#Then<\/b>-Anweisung entsprechend auswertet, zum Beispiel mit den Ausdrücken Vista_2007<\/b>, XP_2007<\/b>, Vista_2003 <\/b>oder XP_2003<\/b>.<\/p>\n Diese Ausdrücke müssten Sie dann in vier verschiedenen Zweigen abarbeiten. Damit ist spätestens hier der Hinweis angebracht, dass Sie selbstverständlich auch #ElseIf <\/b>und #Else <\/b>im #If…#Then<\/b>-Konstrukt verwenden können.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Die bedingte Kompilierung können Sie hervorragend einsetzen, wenn Sie versionsübergreifende Access-Anwendungen programmieren möchten, die versionsabhängige Funktionen nutzen.<\/p>\n Es gibt aber noch weitere wichtige Einsatzorte: So können Sie beispielsweise eine Anwendung programmieren, die speziellen Code sowohl für den Entwicklungsrechner als auch für den späteren produktiven Einsatz benötigt.<\/p>\n Und wie der Beitrag Debugging im VBA-Editor zeigt, gibt es auch beim Debugging von Code sinnvolle Einsatzmöglichkeiten für die bedingte Kompilierung: Beispielsweise, damit der Entwickler zum Testen angelegte MsgBox<\/b>-Anweisungen wahlweise aktivieren oder deaktivieren kann.<\/p>\n Enthaltene Beispieldateien:<\/p>\n BedingteKompilierung.mdb<\/p>\n#Const AccessVersion = 2000\r\nPublic Sub BeispielBedingteKompilierung()\r\n#If AccessVersion = 2000 Then\r\n MsgBox "2000"\r\n#ElseIf AccessVersion = 2007 Then\r\n MsgBox "2007"\r\n#End If\r\nEnd Sub<\/pre>\n
Public Sub Test()\r\n#Const AccessVersion = 2000\r\nEnd Sub\r\n#If AccessVersion = 2000 Then\r\nPublic Sub BeispielBedingteKompilierung()\r\n MsgBox "2000"\r\nEnd Sub\r\n#ElseIf AccessVersion = 2007 Then\r\nPublic Sub BeispielBedingteKompilierung()\r\n MsgBox "2007"\r\nEnd Sub\r\n#End If<\/pre>\n
![\"pic001.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/BedingteCompilierung-web-images\/pic001_opt.jpeg\")
<\/p>\nApplication.SetOption "Conditional Compilation Arguments","AccessVersion=2000"<\/pre>\n
Application.SetOption "Conditional Compilation Arguments","AccessVersion=2007"<\/pre>\n
![\"pic002.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/BedingteCompilierung-web-images\/pic002_opt.jpeg\")
<\/p>\nPublic Function Start()\r\n If Val(Application.Version) > 11 Then\r\n Application.SetOption _\r\n "Conditional Compilation Arguments", _\r\n "AccessVersion=2007"\r\n Else\r\n Application.SetOption _\r\n "Conditional Compilation Arguments", _\r\n "AccessVersion=2000"\r\n End If\r\nEnd Function<\/pre>\n
#If AccessVersion = 2000 Then\r\nPublic Sub PDFExport(strReport As String, _\r\n strFilename As String)\r\n ConvertReportToPDF strReport, , _\r\n strFilename\r\nEnd Sub\r\n#ElseIf AccessVersion = 2007 Then\r\nPublic Sub PDFExport(strReport As String, _\r\n strFilename As String)\r\n DoCmd.OutputTo acOutputReport, strReport, _\r\n acFormatPDF, strFilename\r\nEnd Sub\r\n#End If<\/pre>\n
#If AccessVersion = 2000 Then\r\n'... Modulinhalt\r\n#End If<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n