Access Anfänger: Verwendung von Enum-Auflistungen

Aus DBWiki
Wechseln zu: Navigation, Suche

Beschreibung

Eine Enum-Anweisung fasst eine Gruppe von Konstanten des Datentyps Long zusammen.

Zweck und Aufbau

Enum-Auflistungen helfen, den Code transparent und lesbar zu gestalten. Auch in Access kommen eine Vielzahl von Enum-Auflistungen zum Einsatz. Beispiele hierfür sind die SysCmd-Methode oder die Docmd.RunCommand-Methode, die mit über 500 Enum-Konstanten aufwarten kann.

[Private/Public] Enum enEinBeispiel
   mbWert1 = 123
   mbWert2 = 568
   mbWert3 = 756
End Enum

Lässt man die Folgewerte (hier ab mbWert2) weg, wird der Wert automatisch vom Startwert (hier: 123) ausgehend um 1 erhöht. Lässt man den Startwert weg, fängt die Zählung bei 0 an.

Um Enum-Auflistungen von anderen Konstanten zu unterscheiden, stellt man dem Namen in der Regel das Präfix ‚en’ voran. Die einzelnen Konstanten innerhalb der Auflistung erhalten ein Präfix, das auf den Namen der Enum-Auflistung schließen lässt (mb = MeinBeispiel).

Wer mit der Enum-Anweisung arbeitet, kann seine eigenen Prozeduren mit einer Art IntelliSense ausstatten. Der Vorteil ist, dass die Enum-Anweisung als Parameter an eine Prozedur übergeben werden kann, und man sofort beim Eintippen der Parameter die zuvor definierte Auswahl mittels der IntelliSense erhält.

Ausführliche Informationen können der Online-Hilfe von Access entnommen werden. Dazu im VBE (Visual-Basic-Editor) den Cursor in das Wort Enum setzen, und F1 drücken.

Beispiel

Was man mit einer Enum-Auflistung erreichen kann, soll das nachfolgende Beispiel zeigen. Hier wird eine Standardfunktion beschrieben, die ein paar Grundinformationen zur aktuellen Datenbank kapselt. Das Beispiel ist recht einfach gehalten. Natürlich kann man auch schwerverdaulicheres in so eine praktische Mehrzweckfunktion verpacken.

Erzeuge ein allgemeines Modul und füge folgenden Code ein:

Option Compare Database
Option Explicit
 
Public Enum enInfo
   ifAnwendungspfad             '= 0
   ifAnwendungsName             '= 1
   ifAnwendungsPfadUndName      '= 2 usw.
   ifAnwendungsDateiEndung
   ifIstRuntime
   ifArbeitsgruppenDatei
   ifAccessPfad
   ifAccessVersion
   ifAnwenderName
End Enum
 
Public Function DBInfo(Info As enInfo) As Variant
   Select Case Info
      Case ifAnwendungspfad
         DBInfo = Left$(CurrentDb.Name, Len(CurrentDb.Name) - Len(Dir(CurrentDb.Name)))
      Case ifAnwendungsName
         DBInfo = Dir$(CurrentDb.Name)
      Case ifAnwendungsPfadUndName
         DBInfo = CurrentDb.Name
      Case ifAnwendungsDateiEndung
         DBInfo = Right$(CurrentDb.Name, 3)
      Case ifIstRuntime
         DBInfo = SysCmd(acSysCmdRuntime)
      Case ifArbeitsgruppenDatei
         DBInfo = SysCmd(acSysCmdGetWorkgroupFile)
      Case ifAccessPfad
         DBInfo = SysCmd(acSysCmdAccessDir)
      Case ifAccessVersion
         DBInfo = SysCmd(acSysCmdAccessVer)
      Case ifAnwenderName
         DBInfo = CurrentUser()
      Case Else
         DBInfo = "ungültiger Parameter"
   End Select
End Function

Aufruf

Der Aufruf der Funktion erfolgt z.B. im Direktfenster mit

   Debug.Print DBInfo(ifArbeitsgruppenDatei)

und das Ergebnis ist z.B.

C:\PROGRAMME\GEMEINSAME DATEIEN\SYSTEM\SYSTEM.MDW

Zusätzliche Hinweise

  • Enums eignen sich auch hervorragend für Klassenmodule, da man sie hier (im Gegensatz zu normalen Konstanten) als Public deklarieren kann.
  • In den allermeisten Fällen, in denen man eine Enum deklariert, ist es am besten, eine explizite Wertedefinition wegzulassen, da eine Enum meist nur zur Unterscheidung von Fällen (wie im Beispiel oben), und nicht wegen ihrer Werte verwendet wird. Dadurch ist es leichter, später neue Einträge an beliebiger Stelle der Enum-Deklaration hinzuzufügen.
  • Es ist empfehlenswert, die einzelnen Einträge einer Enum mit einem Präfix zu beginnen, der auf den Namen der Enum schließen lässt, da die Enum-Einträge nicht nur innerhalb der Enum-Deklaration eindeutig sein müssen, sondern auch innerhalb des verwendeten Namensraums der Enum (Public oder Private) eindeutig sein sollen, so als hätte man einzelne Konstanten deklariert. Auf diese Weise kann es nie zu Namensüberschneidungen kommen. Kann ein eindeutiger Name nicht sichergestellt werden, was z.B. bei Verwendung von fremdem Code oder Bibliotheken eintreten kann, sollte man unbedingt den Auflistungswert vollständig referenzieren: Statt fbBar dann FooBar.fbBar verwenden.
  • Enums können auch Compilerprobleme verursachen. Hat man Enums definiert und im Code verwendet, und ruft den Menüpunkt Debuggen - Kompilieren von ... aus dem VBA-Editor auf, kann es sein, dass eine Enum-Deklaration als nicht vorhanden angezeigt wird, obwohl sie vorhanden ist, und in der Vergangenheit vielleicht schon längst funktioniert hat. Abhilfe: Irgendeine der definierten Enums (am besten die, die das Problem verursacht hat) namentlich verändern, die Zeile verlassen, und den Namen wieder zurück ändern (nicht per Undo). Dadurch wird der Namespace des VBA-Editors/Compilers neu gefüllt, und der Compile-Vorgang funktioniert wieder. Diese Prozedur kann im Laufe der Entwicklung einer Datenbank häufiger notwendig sein. Sie sollte einen aber nicht davon abhalten, sie zu benutzen.
  • Vorsicht bei der Namensvergabe: Bevor die Zeile Enum NamederEnum mit dem Cursor verlassen wird, sollte NamederEnum ein Name sein, der nicht schon anderweitig für eine Enum vergeben wurde. Ansonsten kann es zu einem Totalabsturz des VBA-Editors kommen. Vor der Definition einer neuen Enum also am besten immer erst speichern. Das kann auch bei Sub-, Function- oder Type-Deklarationen passieren.
  • Wird eine Auflisting im Code verwendet, und deren Groß- oder Kleinschreibung verändert, so wirkt sich das direkt auf die Deklaration aus, und ändert auch deren Schreibweise. Deshalb kann man nach der Deklaration einen Zeilenblock aufnehmen, in dem alle Auflistungswerte gegen versehentliches Überschreiben geschützt werden.
Public Enum FooBar
   fbBar
   fbFoo
End Enum
 
#If False Then 'Schutz gegen Änderung der Schreibweisen
Dim fbBar, fbFoo 'entsprechend erweitern
#End If