Der Aufzählungstyp (ENUM) Dieser Text informiert über den Aufzählungstyp in VB, insbesondere über einige "unerwartete" Eigentümlichkeiten.
Autor:   Manfred Bohn	Bewertung:     [ Jetzt bewerten ]	Views:  41.548
ohne Homepage	System:  Win9x, WinNT, Win2k, WinXP, Win7, Win8, Win10, Win11	kein Beispielprojekt

Geben Sie hier Ihre persönliche Bewertung ab! Anzahl Bewertungen bisher: 28 Bewertung insgesamt: sehr gut Durchschnittliche Bewertung: 4.5 von 5 Sternen

sehr gut     gut     nützlich     mittelmäßig     mangelhaft

Dieser Text informiert über den Aufzählungstyp in VB, insbesondere über einige 'unerwartete' Eigentümlichkeiten.

1. Abkürzungen
Im folgenden Beispiel ist 'enmFrüchte' der Aufzählungs-Typ (AT). 'Apfel' ist der Bezeichner für die erste der Aufzählungs-Konstanten (AK). 'Frucht' ist eine Aufzählungs-Variable (AV).

Public Enum enmFrüchte
  Apfel
  Birne
  Erdbeere
  Himbeere
  Kirsche
  Andere
End Enum
 
Dim Frucht as enmFrüchte

Im Abschnitt 'Einführung' wird eine kurze Übersicht für Einsteiger gegeben. Fortgeschrittene lesen ab 'DETAILS'.

2. Einführung
Implizit (= inbegriffen, eingeschlossen, mitgemeint)
Falls man - wie im obigen Beispiel - in einer ENUM-Anweisung den AKn keinen numerischen Wert zuordnet, erfolgt eine 'implizite' Festlegung des Wertes der Konstanten. Die erste Konstante erhält den Wert 0, dann wird jeweils um 1 hochgezählt (im Beispiel: 'Andere' = 5).

Explizit ( = ausdrücklich)
Falls man in einer ENUM-Anweisung den Konstanten einen numerischen Wert 'ausdrücklich' (= durch eine Wertzuweisung) zuordnet, nennt man das eine explizite Wert-Zuweisung bzw. eine explizite Definition.

Qualifizierung:
Dieser Begriff wird verwendet für die Art, wie im Quellcode der Zusammenhang zwischen einem 'Bezeichner' und seiner Definition hergestellt wird. Bei einer expliziten Qualifizierung wird dem Bezeichner ggf. der Name der Bibliothek und der Klasse, in der er definiert ist, vorangestellt. Bei der impliziten Qualifizierung eines Bezeichners verlässt sich der Programmierer darauf, dass die Bezeichnung entweder eindeutig ist oder dass VB im jeweils gültigen 'Namensraum' einen korrekten Bezug zur Definition herstellt. (Durch das Setzen von 'Verweisen' auf ActiveX-Komponenten, das Hinzufügen neuer Module oder Definitionen sowie das Ändern der Schlüsselwörter Public/Private verändert sich der 'Namensraum' während des Programmierens). 'PUBLIC ENUM'-Anweisungen stellen im Hinblick auf die Qualifizierung einen Sonderfall dar, weil sie nicht dem Modul, sondern direkt dem globalen Namensraum zugeordnet werden.

Definition Aufzählung ( = Enumeration):
Eine Aufzählung ist eine abzählbare (und meist relativ kurze) Liste von Bezeichnungen, die gemeinsam einen Sachzusammenhang oder einen Oberbegriff abbilden (z. b. Liste der Wochentage, Liste der VB-Datentypen).

Die Elemente einer Aufzählung sollten eindeutig gegeneinander abgrenzbar sein (d.h. keine 'Mischtypen', Zweifels- oder Sonderfälle einbeziehen). Die Aufzählungs-Liste sollte zudem vollständig sein, d.h. alle möglichen Elemente umfassen. Falls man eine unvollständige Aufzählung definiert, ist es sinnvoll (oder notwendig), zusätzlich eine 'Restkategorie' für die nicht benannten Elemente einzuführen (z.B. Bezeichner 'sonstiges', 'andere').

Beim Bezug auf hierarchische Klassifikationen ist darauf zu achten, dass die Aufzählung innerhalb einer Ebene angesiedelt ist. In der sachlich fehlerhaften Aufzählung <Säugetier, Vogel, Fisch, Delphin, ...> gehört die Bezeichnung 'Delphin' zu einer niedrigeren Ebene.

Obwohl üblicherweise Aufzählungen 'nominal' sind, d.h. nur Benennungen umfassen (sachlich zulässige Vergleichs-Operationen: =, <>), können aufgrund der 'intern' numerischen Ausprägung der AKn auch 'ordinale' Aufzählungen ( = Rangreihen) definiert werden (z.B. sehr_klein, klein, mittel, groß, sehr_groß), die dann im Programm die Verwendung aller Vergleichs-Operatoren ( <, <=, =, =>, >, <> ) zulassen (natürlich nur, falls die AKn in der korrekten [ = ansteigenden] Reihenfolge deklariert worden sind).

Um eindeutige Bezeichner für AKn zu erhalten, ist es üblich, den Bezeichnern ein Kürzel voranzustellen, aus dem hervorgeht, zu welcher Aufzählung die Konstante gehört. Im obigen Beispiel wird man statt 'Apfel', 'Birne' ... vielleicht 'fru_Apfel', 'fru_Birne' usw. wählen, um die Zugehörigkeit zur Aufzählung 'enmFrüchte' deutlich zu machen.

Manchmal wird es nötig sein zu erkennen, ob einer AV eine gültige Bezeichnung zugewiesen worden ist oder nicht. In diesem Fall nennt man die erste AK in der ENUM-Anweisung 'undefiniert' ( d.h. = 0 = AV-Initialwert). Zum Erkennen fehlerhafter Zuweisungen wird oft eine AK 'ungültig' eingefügt, der explizit ein negativer Wert (z.B. -1) zugeordnet ist.

Die ENUM-Anweisung darf nicht in einer Sub- oder Function-Prozedur auftreten, sondern nur im Deklarationsteil eines Moduls oder eines Formulars.

3. Details:
Aufzählungstypen (AT) sind in die Bezeichner-Hierarchie des 'Namensraums' eingebettet, d.h. AKn überschreiben ggf. gleichnamige globale VB-Konstanten und werden ihrerseits von lokalen (gleichnamigen) Variablen überschrieben. Alle als 'Public' deklarierten ATn werden im globalen Namensraum gelistet - unabhängig davon, ob sie in einem Formular, einem Standard- oder Klassenmodul definiert sind. Sie können deshalb nicht mit dem Namen des Formulars bzw. des Moduls qualifiziert werden, in dem sie deklariert sind - lediglich die Bibliothek kann angegeben werden. Das unterscheidet Enumerationen von öffentlichen Variablen und Funktionen. (VB-DOKU: Wenn zwei Enum-Typen in unterschiedlichen Bibliotheken denselben Namen, aber unterschiedliche Elemente haben, hängt die Referenz auf eine Variable des Typs davon ab, welche Typenbibliothek in 'Projekt --> Verweise' die höhere Priorität hat.)

Innerhalb eines Standard-Exe-Projekts können im Deklarationsteil von Klassenmodulen ENUM-Anweisungen mit dem Schlüsselwort 'Public' deklariert und als Parameter oder Rückgabetyp in Methoden und Eigenschaften verwendet werden. Will man Enumerationen allerdings global in ActiveX-Komponenten verwenden, muss die Deklaration in einem ActiveX-DLL-Projekt erfolgen und zwar am besten in einer öffentlich erstellbaren Klasse, deren Instancing-Eigenschaft = GlobalMultiUse eingestellt ist - mit den Schlüsselwörtern 'Public Enum'.

Details zu Aufzählungs-Konstanten (AK):

• Es ist zulässig, die gleiche Bezeichnung für AKn in mehreren ATn zu verwenden. In diesem Fall sollten - zur Sicherstellung der Eindeutigkeit - im Code diese Konstanten 'vollständig qualifiziert' werden (Bibliothek.Aufzählungstyp.Konstante).
   
• Bei der Deklaration von AKn in einem ENUM ... END ENUM-Anweisungsblock können den einzelnen Konstanten explizite Ganzzahl-Werte des Typs LONG zugewiesen werden. Beim Kompilieren wird aber nicht überprüft, ob diese Werte auch 'eindeutig' sind. Falls eine Konstante einen bereits zuvor in der Aufzählung vergebenen Wert erhält, tritt kein Fehler auf. Eine Folge davon ist, dass in einer SELECT CASE- oder IF ... THEN-Verzweigung diese zweite AK nie erkannt wird - immer die erste. Man sollte deshalb nur in Ausnahmefällen - wenn die numerischen Werte zugleich eine sachliche Bedeutung besitzen - die AK im ENUM-Block mit expliziten Werten belegen.
   
• Wenn man eine AK explizit mit irgendeiner Ganzzahl belegt, werden die darauf folgenden AKn im ENUM-Anweisungsblock - falls ihnen nicht ebenfalls ein numerischer Wert zugeordnet wird - automatisch mit einen um 1 hochgesetzten relativen Wert deklariert. (Auch dabei können ggf. Doppelwerte entstehen, falls danach wieder explizite Deklarationen erfolgen!) Falls es bei diesem 'impliziten' Hochzählen zu einem Überlauf des LONG-Geltungsbereichs kommen sollte, wird automatisch auf die niedrigste zulässige Long-Ausprägung umgestellt und ab da weiter hochgezählt. Es kommt deshalb nicht zu einem Überlauf-Fehler.
   
• Bei der Deklaration von AKn können auch die vordefinierten VB-Konstanten oder die im Code deklarierten modulglobalen öffentlichen Konstanten als Wert zugewiesen werden.
   
• AKn können im Code auf jede beliebige Variable zugewiesen werden, die den Datentyp 'LONG' akzeptiert.
   
• Bei der Übergabe einer AK an das ByRef-Argument einer Funktion wird kein Fehler ausgelöst, die AK behält ihren Wert und die ByRef-Rückgabe der Funktion wird ggf. ignoriert!

Details zu Aufzählungs-Variablen (AV):
AVn werden in VB wie Variable des Typs LONG behandelt. Das hat eine ganze Reihe von Auswirkungen, über die man sich beim Programmieren mit ATn im Klaren sein muss:

• Die VB-Funktionen 'VarType' bzw. 'TypeName' geben für AVn 'vbLong' bzw. 'LONG' zurück.
   
• AVn sind nach der Deklaration immer mit dem Wert 0 initialisiert, auch wenn 0 keiner der zugehörigen AKn des AT entspricht.
   
• AVn sind nicht auf die AKn 'beschränkt', d.h. sie kennen bei Wert-Zuweisungen keine 'unzulässige' Ausprägung, sondern akzeptieren beliebige LONG-Ganzzahlen. Die Vereinbarungen im ENUM-Definitionsblock werden insofern ignoriert! Zuweisungen werden weder in der IDE noch beim Kompilieren oder zur Laufzeit überwacht. Es macht deshalb keinen Unterschied, ob man einer AV eine der zugehörigen AKn, eine 'fremde' AK oder die entsprechende Ganzzahl bzw. das Ergebnis eines Ausdrucks zuweist.
   
• Bei der Zuweisung nicht-ganzzahliger Werte wird bei einer AV 'mathematisch' gerundet wie bei 'LONG'-Variablen (Funktion: 'CLng') üblich: Sowohl die Zuweisung von 3.5 als auch von 4.5 ergibt deshalb den Wert 4. Die Zuweisung kann auch das Ergebnis eines numerischen Ausdrucks, eine DATE-Variable oder ein numerisch interpretierbarer String sein.
   
• Beim Aufruf von Funktionen akzeptieren Argumente vom Typ einer 'Aufzählung' alle Variable, deren Ausprägung bei der Übergabe (implizit) in eine beliebige Ganzzahl gewandelt werden kann, die auf den Datentyp 'LONG' zuzuweisen ist. Und auch umgekehrt gilt: AVn können bei Funktionsaufrufen auf jedes Argument zugewiesen werden, das einen numerischen Wert akzeptiert.

Man sollte in SELECT .. CASE .. und in IF .. THEN .. Konstruktionen prinzipiell eine ELSE-Bedingung einführen, die angesprungen wird, falls die verzweigende AV einen Wert enthält, dem keine AK entspricht (evt. einen Fehler in der ELSE-Bedingung auslösen). In vielen Fällen wird es zweckmäßig sein, die Zuweisung auf eine AV prinzipiell über eine Funktion vorzunehmen, die zunächst überprüft, ob der Wert des zuzuweisenden Arguments gleich dem Wert einer der AKn ist.

4. Aufzählungs-Typ mit 'Mehrfachauswahl'
Da AVn nicht nur die zugeordneten AKn akzeptieren, sondern beliebige LONG-Werte, kann man auch ATn mit 'Mehrfachauswahl' erstellen. Damit die Kombination von AKn in einer AV funktioniert, ist lediglich darauf zu achten, dass die AKn explizit mit unterscheidbaren Zweierpotenzen deklariert werden: 1, 2, 4, 8, 16, 32 ..... 1073741824 ( = 2^30 / 31. Bit). Auf diese Weise wird durch jede AK bei der Zuweisung auf eine AV jeweils ein bestimmtes Bit gesetzt (näheres unter Tipp 1276 'Abfragen, Setzen und Löschen von Bits').

Die Kombination von solchen AKn in einer AV geschieht durch Verwendung des bitweisen Operators 'OR' bei der Zuweisung: AV = AK1 Or AK2 Or AK6
Als Alternative kann bei der Zuweisung der arithmetische Operator '+' verwendet werden: AV = AK1 + AK2 + AK6
Der bitweise AND-Operator ist bei Zuweisungen NICHT verwendbar!

Die Abfrage, ob eine bestimmte AK in einer AV enthalten ist, erfolgt durch den bitweisen 'AND'-Operator: If AV And AK1 Then ...
Die IDE unterstützt die Verwendung der logischen Operatoren bei der automatischen Auflistung der AKn.

Bei Zuweisung von -1 werden alle 32 Bits in einer LONG-Variable gesetzt, bei der Zuweisung von 0 alle gelöscht. Des 32.Bit wird gesetzt - wegen der LONG-Skalierung - durch Zuweisung von -2^31 ( = -2147483648). Man darf sích dabei nicht davon irritieren lassen, wenn die IDE bei diesem Wert im Code automatisch die DOUBLE-Kennung (#) an die Zahl anhängt.

Ein bekanntes Beispiel für Mehrfachauswahl-ATn enthält das CommonDialog-Steuerelement (Komponente: 'Microsoft Common Dialog Control 6.0'). Die 'Flags'-Eigenschaft dieses Controls kann durch eine Kombination von AKn belegt werden. Weil der erforderliche AT dialogspezifisch ist, kann die IDE die AKn bei der Zuweisung zur Flags-Eigenschaft nicht anzeigen. Will man die automatische Auflistung sehen, muss man die jeweils für den Dialog benötigte AV deklarieren und sie - nach der Belegung mit der gewünschten AKn-Kombination - der 'Flags'-Eigenschaft zuweisen:

Dim AV_FOS As MSComDlg.FileOpenConstants                 
Dim AV_COC As MSComDlg.ColorConstants
Dim AV_FOC As MSComDlg.FontsConstants
 
Dim AV_HEC As MSComDlg.HelpConstants
Dim AV_PRC As MSComDlg.PrinterConstants
Dim AV_PROC As MSComDlg.PrinterOrientationConstants

5. Ergänzende Hinweise:
Die Bezeichner von AKn können von den üblichen VB-Namensbezeichnern abweichen, falls man eckige Klammern benutzt (vgl. Tipp 815: 'Leerzeichen in Enumerationen').

Die folgende ENUM-Deklaration ist zulässig:

Public Enum enmTest
  [@] = 1000        ' Sonderzeichen --> Klammern notwendig
  [*******]         ' =1001  (Wert wird automatisch hochgesetzt)
  [#####]           ' =1002
  [sowas aber auch] ' =1003  Leerzeichen --> Klammern notwendig
  [2005] = 2005     ' Bezeichnung beginnt mit einer Ziffer --> Klammern notwendig
  xxx = [@]         ' =1000 / Doublette !!
  [Int] = vbInteger ' =2 (Klammern sind notwendig, weil 'INT' sonst als Schlüsselwort betrachtet wird)
  [ ] = -1          ' einfaches Leerzeichen --> Klammern notwendig
  [] = -2           ' die beiden Klammern funktionieren als Enum-Konstante
End Enum

Nach dieser Deklaration ist die folgende Zuweisung auf eine Variable des Typs 'enmTest' oder auf eine beliebige LONG-Variable möglich:

Dim y As Long
 
y = [sowas aber auch]
 
If y = [sowas aber auch] Then
  MsgBox "sowas aber auch"
End If
 
y = [Int]
If y <> 2 Then 
  MsgBox "Y <> 2 !"
End If
 
y = [ ]
If y <> - 1 then 
  MsgBox "Y <> -1 !"
End If

Auch bei der vollständigen Qualifizierung einer AK müssen die eckigen Klammern geschrieben werden (z.B. a = enmTest.[sowas aber auch] ), sonst meldet die IDE evt. ein ungültiges Zeichen.

Die VB-IDE schreibt die eckigen Klammern bei Wert-Zuweisungen, die durch einen Maus-Click auf die 'Mitglieder-Auflistung' in den Code eingefügt werden, nur, wenn sie syntaktisch notwendig sind. (Das funktioniert aber nicht, wenn die Konstante wie eine VB-Funktion benannt ist - vgl. Beispiel). Die eckigen Klammern werden in der IDE-Auflistung der AKn eines AT nicht angezeigt, bei der direkten Eingabe in den Code aber ggf. von der IDE ergänzt (erforderliche Editor-Option: 'Mitglieder automatisch auflisten').

Durch die Verwendung eckiger Klammern ist es möglich, in Aufzählungen auch E-Mail-Adressen, komplexe (z.B. gruppierte) Bestellnummern, Typenbezeichnungen, Währungskennzeichen u.v.a. in korrekter Schreibweise einschließlich Sonderzeichen als Aufzählungs-Konstanten zu deklarieren. Das kann zu einem besser lesbaren Quellcode beitragen. VB6 akzeptiert solche Bezeichner bis zu einer Länge von 255 Zeichen. Die Verwendung von Enumerations-Konstanten scheint - im Vergleich zur direkten Verwendung von LONG-Variablen - die Programm-Ausführung nicht zu verlangsamen.

Beliebig wählbar sind die Zeichenfolgen auch in eckigen Klammern allerdings nicht. Die Bezeichnung [local] wird akzeptiert, [global] löst einen Fehler aus. Viele VB-Schlüsselwörter sind ausgeschlossen - aber z.B. die VB-Funktionsbezeichner und die VB-Operatoren nicht. Zugelassen als Bezeichner für AKn sind z.b. [sin], [round], [/]. Die Groß-/Kleinschreibung in Bezeichnern wird von der IDE - wie auch sonst gewohnt - automatisch vereinheitlicht.

Falls eine AK durch eine gleichnamige lokale Variable überschrieben worden ist, nützt es nichts, wenn man den Namen der AK in eckige Klammern setzt. Der VB-Compiler akzeptiert dies zwar, der Bezeichner bezieht sich aber immer noch auf die lokale Variable!

6. Fazit:
Der Begriff 'Aufzählungstyp' für die ENUM-Anweisung ist in gewisser Hinsicht irreführend. Er spiegelt die Definition einer abzählbaren Menge von Elementen bzw. Zuständen nur vor. Zutreffender wäre deshalb die Bezeichnung 'Hervorhebung': Einige numerische Ausprägungen einer Variable des Datentyps LONG werden im Quellcode durch eine Liste von Benennungen gegenüber allen anderen Ganzzahlen besonders hervorgehoben.

7. Vorschlag mit Beispiel
Will man eine 'echte' Aufzählung haben, die Alarm gibt, wenn unzulässige Werte zugewiesen werden sollen, muss man eine öffentliche ENUM-Anweisung in einer Klasse definieren und für die Zuweisung/Abfrage eine Eigenschaft programmieren. Diese Eigenschaft wird als 'Voreinstellung' der Klasse festgelegt. Dabei macht man sich zunutze, dass die 'PUBLIC ENUM'-Deklaration von VB in den globalen Namensraum eingetragen wird. Bei der Verwendung mehrerer Instanzen einer ENUM-Klasse gibt es deshalb keine Kollisionen der öffentlichen Definition. Das gilt auch, wenn die ENUM-Klasse in einem ActiveX-Projekt definiert ist (Instancing-Eigenschaft = GlobalMultiUse).

Die Klasse 'clsGröße' kapselt die ordinale Aufzählung 'enmGröße' (winzig --> riesig).

Die Eigenschaft 'Fehler_Auslösen' bestimmt, ob bei einer ungültigen Zuweisung ein Fehler ausgelöst wird - sonst wird nur der Wert 'ungültig' gesetzt.

Die Eigenschaft 'Größe' weist kontrolliert einen Aufzählungs-Wert zu bzw. fragt ihn ab.

Die Eigenschaft 'Größe_CM' demonstriert, wie man durch eine Eigenschaft metrische Werte (im Beispiel: Größen-Angabe in Zentimetern) in eine ordinale Aufzählung transformieren kann.

Die AV werden in diesem Fall als Instanzen der Klasse deklariert.

' ============================================================
' Start Quellcode Klasse 'clsGröße'
' Kapselung einer Aufzählung für kontrollierte Zuweisungen
' zu 'Aufzählungs-Variablen' = Instanzen der Klasse 'clsGröße'
' ============================================================
Option Explicit
 
' Die Werte der Aufzählungs-Konstanten werden ab -1 hochgezählt
Public Enum enmGröße
  ungültig = -1
  unbekannt          ' = 0 = Initialwert
  [winzig]           ' =1
  [sehr klein]
  klein
  mittel
  groß
  [sehr groß]
  [riesig]           ' =7
End Enum
 
' Skalierungs-Obergrenzen
' belegt bei Initialisierung der Instanz
Dim gSkalierung() As Variant
 
' gespeicherte Aufzählungs-Konstante
Dim gGröße As enmGröße
 
' Fehler bei ungültiger Zuweisung auslösen?
Dim gError As Boolean

Private Sub Class_Initialize()
  ' Obergrenzen bei der Skalierung von Zentimeterangaben
  ' zu Aufzählungskonstanten
  ' für Eigenschaft 'Größe_CM'
 
  ' winzig ---> 120 < x <= 140
  '  ....       ... < x <= ...
  ' riesig ---> 200 < x <= 220
  gSkalierung = Array(120, 140, 150, 165, 180, 190, 200, 220)   
End Sub

Public Property Let Fehler_Auslösen(f_a As Boolean)
  ' Fehler bei ungültiger Zuweisung auslösen?
  gError = f_a
End Property

Public Property Let Größe(g As enmGröße)
  ' kontrollierte Zuweisung
  ' einer Aufzählungs-Konstanten
  If g < 0 Or g > [riesig] Then
    ' Zuweisung ausserhalb des gültigen Bereichs
    gGröße = ungültig
    If gError Then Err.Raise 6 'Überlauf
  Else
    gGröße = g
  End If
End Property
 
Public Property Get Größe() As enmGröße
  ' Abfrage der aktuell zugewiesenen
  ' Aufzählungs-Konstante
  Größe = gGröße
End Property

Public Property Let Größe_CM(g As Double)
  ' Skalierung einer metrischen Zuweisung (in Zentimeter)
  ' auf zulässige Werte der 'ordinalen' Aufzählung 'Größe'
  Dim i As Long   ' Loop
 
  ' Gültiger (=skalierbarer) Zentimeter-Wert in 'g' ?
  If g <= gSkalierung(0) Or _
    g > gSkalierung(UBound(gSkalierung)) Then
    gGröße = ungültig
    If gError Then Err.Raise 6   ' Überlauf
    Exit Property
  End If
 
  ' Skalierung durchführen
  For i = 1 To UBound(gSkalierung)
    If g <= gSkalierung(i) Then gGröße = i: Exit For
  Next i      
End Property
 
' ============================================================
' Ende Quellcode Klasse 'clsGröße'
' ============================================================