## 6.2 Enumerationen (Aufzählungen) Eine Enumeration ist als Gruppierung mehrerer Konstanten zu verstehen, die zur Laufzeit nicht verändert werden können. Alle in der Enumeration enthaltenen Konstanten sind vom gleichen Datentyp. Dabei kann es sich um byte, short, int oder long handeln. Andere Datentypen sind nicht zugelassen. Die Angabe des Typs einer Enumeration ist optional. Wird darauf verzichtet, handelt es sich um int-Elemente. Enumerationen sind von der gemeinsamen Basisklasse System.Enum abgeleitet. Betrachten Sie das folgende Beispiel der Enumeration Spielkarte:
    public enum Spielkarte : long {
      Karo = 9,
      Herz = 10,
      Pik = 11,
      Kreuz = 12
    }
Eine Enumeration wird mit dem Schlüsselwort enum eingeleitet. Hinter der Angabe des Bezeichners kann optional der Datentyp aller in der Enumeration enthaltenen Konstanten angegeben werden. Dabei wird der Datentyp (im Beispiel handelt es sich um den Typ long) mit einem Doppelpunkt vom Bezeichner der Aufzählung getrennt. Der enum-Block enthält alle erforderlichen Konstanten, die ihrerseits durch ein Komma getrennt werden. Der von ihnen beschriebene Wert kann optional zugewiesen werden. Andernfalls wird er nach einem bestimmten Algorithmus automatisch vergeben, wie unten noch erläutert wird. ### 6.2.1 Wertzuweisung an »enum«-Mitglieder Die Wertzuweisung an die enum-Elemente ist optional. Wird darauf verzichtet, steht das erste Element für den Wert 0. Es gilt die Regel, dass jedes Element, dem nicht ausdrücklich ein Wert zugewiesen wird, einen Wert repräsentiert, der sich aus dem Wert des Vorgängerelements plus 1 ermittelt. Natürlich können die Werte auch negativ sein. Sehen wir uns dazu ein Beispiel an:
    public enum TestEnum {
      a = -2,
      b,
      c = 3,
      d
    }
Da das erste Element (a) für den Wert -2 steht, hat das Folgeelement (b) den Wert -1. Das Element (c) repräsentiert die Zahl 3, und das Folgeelement (d) steht für 4. Bei der Angabe muss keine Reihenfolge eingehalten werden. Es dürfen sogar mehrere Elemente gleiche Werte aufweisen. Eine enum-Aufzählung wird von der Laufzeitumgebung wie ein Wertetyp behandelt. Daher ist eine Variablendeklaration notwendig:
    Spielkarte myGame;
Die Variable myGame kann nun für ein beliebiges Element der Aufzählung stehen. Um welches Element es sich genau handelt, muss mit der Punktnotation angegeben werden:
    myGame = Spielkarte.Herz;
Wenn Sie am Zahlenwert, der dieser Konstanten zugeordnet ist, interessiert sind, müssen Sie explizit konvertieren:
    long myGame = (long)Spielkarte.Herz;
### 6.2.2 Alle Mitglieder einer Aufzählung durchlaufen Enumerationen werden uns im zweiten Teil dieses Buches häufig begegnen, wenn wir uns der Programmierung von Windows-Anwendungen widmen. Dabei wird es manchmal sinnvoll sein, die Mitglieder einer Aufzählung in einer Schleife abzugreifen. Ich möchte Ihnen am Beispiel der Aufzählung Spielkarte demonstrieren, wie das programmiertechnisch realisiert wird.
    // ---------------------------------------------------------
    // Beispiel: ...\Kapitel 6\EnumerationDemo
    // ---------------------------------------------------------
    class Program {
      static void Main(string[] args) {
        foreach (Spielkarte karte in Enum.GetValues(typeof(Spielkarte)))
          Console.WriteLine(karte.ToString());
          Console.ReadLine();
        }
      }
      public enum Spielkarte : long {
        Karo = 9,
        Herz = 10,
        Pik = 11,
        Kreuz = 12
      }
    }
Wir können in solchen Fällen nicht mit einer herkömmlichen for-Schleife operieren, sondern müssen dazu die foreach-Schleife benutzen, die ein Array elementweise durchläuft und deren allgemeine Syntax wie folgt lautet:
    foreach (<Datentyp> <Variable> in <Ausdruck>) {...}
Zuerst wird eine Variable deklariert, deren Lebensdauer sich auf die Ausführung der Schleife beschränkt. Der Datentyp entspricht dem Datentyp der Konstanten in der Enumeration, deren Mitglieder wir in Erfahrung bringen wollen. Ausdruck ist das Array, das in der Schleife elementweise durchlaufen wird. Dieses Array müssen wir uns noch besorgen. Eingangs wurde bereits erwähnt, dass alle Enumerationen aus der Klasse Enum abgeleitet werden. Diese stellt mit GetValues eine statische Methode zur Verfügung, die uns eine Array-Referenz aller in der Aufzählung enthaltenen Konstanten zurückliefert. GetValues ist wie folgt definiert:
    public static Array GetValues(Type enumType);
Der Rückgabewert ist vom Typ Array, das Übergabeargument vom Typ Type. Dieser Typ liefert Informationen über einen Datentyp, beispielsweise über die von einer Klasse veröffentlichten Methoden und Felder. Dazu müssen wir uns nur den Type eines bestimmten Datentyps besorgen. Hier hilft die C#-spezifische Funktion typeof weiter, der wir als Argument den Typbezeichner übergeben. Der Ausdruck
    Enum.GetValues(typeof(Spielkarte)))