9 - Aufzählungstypen

Beispiel: Steuerung über einfache Zahlen

Die Methode Ausgabe() führt abhängig vom übergebenen Wert des Parameters modus eine andere Aktion aus. Da aber beliebige int-Werte zur Übergabe erlaubt sind, kann sich auch einmal ein ungültiger Wert einschleichen. Dies kann aber beispielsweise der Compiler nicht feststellen. Außerdem kann man keine Beziehung vom übergebenen Wert 2 an die Methode Ausgabe() herstellen.

void Ausgabe(int modus)
{
  switch(modus)
  {
    case 0: // tue dies;
            break;
    case 1: // tue das;
            break;
  }
}
...
Ausgabe(2);

Beispiel: Steuerung über Aufzählungstypen

Das eben gezeigte Beispiel ließe sich mit Aufzählungstypen folgendermaßen implementieren. Zuerst wird eine Aufzählung mit dem Namen Aktion deklariert. Diese besteht aus drei Konstanten. Als Parameter wird nun kein int-Wert, sondern ein Wert vom Typ Aktion an die Methode übergeben. Beim Aufruf der Methode muss eine der Aufzählungskonstanten übergeben werden. Jetzt kann der Compiler tatsächlich prüfen, dass nur eine der definierten Konstanten übergeben wurde. Auch innerhalb der switch-Anweisung in der Methode Ausgabe() können nun direkt die Aufzählungskonstanten verwendet werden. Dies ist wesentlich sprechender als einfache Zahlenwerte.

enum Aktion { Loeschen, Einfuegen, Aendern };
void Ausgabe(Aktion modus)
{
  switch(modus)
  {
    case Aktion.Loeschen:  // tue dies;
                           break;
    case Aktion.Einfuegen: // tue das;
                           break;
  }
}
...
Ausgabe(Aktion.Einfuegen);

Beispiel: Probleme bei gemeinsamen Konstantenwerten

Einer Konstante kann der Wert einer anderer Konstante zugewiesen werden, wenn diese Konstante bereits ihren Wert besitzt (1. Zeile). In der zweiten Zeile entsteht allerdings eine zirkuläre Referenz, da Wert1 von Wert2 abhängt und Wert2 implizit von Wert1 (sie erhält ja den um 1 höheren Wert als Wert1).

enum Daten { Wert1, Wert2, Wert3 = Wert1 }
enum Daten { Wert1 = Wert2, Wert2 }
enum Daten { Wert1 = 1, Wert2, Wert3 = Wert1 }

Beispiel: Konfigurieren der Anzeige über Aufzählungskonstanten

Auch wenn es "nur" eine Konsolenanwendung ist, soll diese farblich konfigurierbar gemacht werden. Dazu werden drei Farbschemas definiert. Diese Farbschemas werden als Auszählungskonstanten in der Aufzählung FarbSchema deklariert. Die Methode SetFarbSchema() übernimmt als Parameter das ausgewählte Farbschema und setzt die Vorder- und Hintergrundfarbe der Konsole entsprechend des gewählten Farbschemas auf die vordefinierten Werte. Zum Setzen dieser Werte dienen Eigenschaften der Klasse Console. Damit die Einstellungen sofort für den Inhalt des gesamten Konsolenfensters aktiv werden, wird zum Abschluss der Inhalt des Fensters durch den Aufruf von Clear() gelöscht. Der Hintergrund wird dann in der neu eingestellten Farbe gezeigt.

Die Konfiguration von Konsolenanwendungen wird später noch in einem eigenen Kapitel (kurz) besprochen.

using System;
namespace CSharpBuch.Kap09
{
  public enum FarbSchema { Ocean, Normal, Pink };
  
  public class EinfacheAufzaehlungen
  {
    static void Main(string[] args)
    {
      FarbSchema fs = FarbSchema.Ocean;
      SetFarbSchema(fs);
      Console.WriteLine("Ausgewähltes Farbschema ..." + fs.ToString());
      Console.ReadLine();
    }
    static void SetFarbSchema(FarbSchema fs)
    {
      switch(fs)
      {
        case FarbSchema.Normal: 
               Console.BackgroundColor = ConsoleColor.Black;
               Console.ForegroundColor = ConsoleColor.White;
               break;
        case FarbSchema.Ocean:  
               Console.BackgroundColor = ConsoleColor.Blue;
               Console.ForegroundColor = ConsoleColor.Yellow;
               break;
        case FarbSchema.Pink:   
               Console.BackgroundColor = ConsoleColor.Black;
               Console.ForegroundColor = ConsoleColor.White;
               break;
      }
      Console.Clear();
    }
  }
}

Listing 9.1: EinfacheAufzaehlungen.cs

Beispiel: Basistyp einer Aufzählung definieren

Als Basistyp der Aufzählung Wochentage wird der Datentyp byte verwendet. Durch einen Cast kann der numerische Wert einer Aufzählungskonstante, hier Mo, ermittelt werden.

enum Wochentage: byte { Mo, Di, Mi, Do, Fr, Sa, So };
...
byte b = (byte)Wochentage.Mo;

Beispiel: Auswerten einer Auflistung über die Struktur Enum

In diesem Beispiel werden die Methoden der Struktur Enum verwendet, um Informationen zu der Aufzählung FarbSchema zu erhalten (die diesmal etwas anders deklariert wurde). Auf diese Weise können Sie also auch Aufzählungen dynamisch auswerten, die Sie eventuell über fremde Bibliotheken bezogen haben. Eine größere Bedeutung kommt aber z.B. der Tatsache zu, dass sich bei Änderung der Aufzählungskonstanten (neue hinzufügen, Vergabe von Vorgabewerten etc.) die Werte der Aufzählungskonstanten ändern können. Dies können Sie nun feststellen und gegebenenfalls darauf reagieren.

using System;
namespace CSharpBuch.Kap09
{
  enum FarbSchema: byte { Ocean = 0, Normal = 3, Pink }

  public class SpezialAufzaehlungen
  {
    static void Main(string[] args)
    {
      FarbSchema fs = FarbSchema.Pink;
      Console.WriteLine("Methoden der Strukur Enum ...");
      Console.WriteLine("Format(): " + Enum.Format(typeof(FarbSchema), FarbSchema.Ocean, "G"));
      Console.WriteLine("GetName(): " + Enum.GetName(typeof(FarbSchema), fs));
      Console.WriteLine("Get(): " + Enum.GetUnderlyingType(typeof(FarbSchema)));
      if(Enum.IsDefined(typeof(FarbSchema), "Pink"))
      {
        Console.WriteLine("IsDefined(): Pink gibt's in FarbSchema");
        FarbSchema fs2 = (FarbSchema)Enum.Parse(typeof(FarbSchema), "Pink");
      }

      Console.WriteLine("\nAlle Namen der Aufzählungskonstanten: ");
      foreach(string s in Enum.GetNames(typeof(FarbSchema)))
        Console.WriteLine(s);
 
      Console.WriteLine("\nAlle Werte der Aufzählungskonstanten: ");
      foreach(byte b in Enum.GetValues(typeof(FarbSchema)))
        Console.WriteLine(b);
    }
  }
}

Listing 9.2: SpezialAufzaehlungen.cs