Enums (enum) in C#: praktische benannte Konstanten

1. Einführung

Beim Programmieren hat man oft mit Listen von vorher bekannten, begrenzten Optionen zu tun. Zum Beispiel: Wochentage, Ampelfarben, Schwierigkeitsgrade eines Spiels, Bestellstatus. Jede dieser Optionen ist normalerweise ein fester Wert. Und genau hier kommen wir zu unserem heutigen Thema – Enums (enum).

Enum ist ein spezieller Datentyp, mit dem du eine Menge benannter Konstanten deklarieren kannst.
enum ist wie eine Box mit Fächern, in denen Labels liegen – jedes Label ist ein einzigartiger Name, der mit einer Zahl verknüpft ist.

• Dein Code wird lesbar und selbstdokumentierend;
• Statt mysteriöser „magischer Zahlen“ wie 0, 1, 2 gibt es sprechende Namen: DayOfWeek.Monday oder TrafficLight.Red;
• Der Compiler meckert, wenn du einen ungültigen Wert zuweisen willst;
• Hinter jedem Element steckt… einfach eine ganz normale Ganzzahl! (Aber dazu kommen wir noch.)

2. Syntax für die Deklaration von Enums

Lass uns das erste Enum erstellen – Wettertypen für unsere zukünftige App. So sieht das aus:

// Wetterbedingungen-Enum
public enum WeatherCondition
{
    Sunny,       // 0
    Cloudy,      // 1
    Rainy,       // 2
    Stormy,      // 3
    Snowy        // 4
}

• Das Schlüsselwort enum definiert einen neuen Typ.
• In den geschweiften Klammern stehen die Namen der Optionen. Standardmäßig bekommt jede Option eine Ganzzahl, beginnend bei null (Sunny == 0, Cloudy == 1 usw.).
• Du kannst die Werte auch explizit angeben:

public enum WeatherCondition
{
    Sunny = 1,
    Cloudy = 2,
    Rainy = 4,
    Stormy = 8,
    Snowy = 16
}

Das ist praktisch, wenn die Werte zu externen Standards oder Protokollen passen müssen.

3. Verwendung von Enums

Stell dir vor, wir haben eine kleine Konsolen-App geschrieben, die auf das Wetter reagiert.

// App-Klasse
class Program
{
    static void Main()
    {
        // Wir benutzen unser Enum, um den Wetterzustand zu speichern
        WeatherCondition todayWeather = WeatherCondition.Sunny;

        // Auf dem Bildschirm ausgeben
        Console.WriteLine($"Heute ist das Wetter: {todayWeather} ({(int)todayWeather})");

        // Jetzt simulieren wir einen Wetterwechsel
        todayWeather = WeatherCondition.Rainy;
        Console.WriteLine($"Oh! Das Wetter hat sich geändert: {todayWeather} ({(int)todayWeather})");
    }
}

Was passiert?

Heute ist das Wetter: Sunny (0)
Oh! Das Wetter hat sich geändert: Rainy (2)

• todayWeather ist kein String, keine Zahl, sondern ein Enum-Element.
• Das Casten zu (int) zeigt dir den „Zahlenwert“ dieses Elements.

Übrigens: Enums passen super zu Bedingungen:

if (todayWeather == WeatherCondition.Rainy)
    Console.WriteLine("Nimm einen Regenschirm mit!");

4. Praktische Einsatzszenarien für enum

Wo begegnet man Enums?

• In Business-Apps: Bestellstatus (New, Processing, Shipped, Cancelled).
• In User-Management-Systemen: Zugriffslevel (User, Moderator, Admin).
• In Games: Charakterzustände (Idle, Moving, Jumping, Falling).
• Im GUI: Buttons, Nachrichten, Icon-Farben.

Und wenn du tiefer in .NET eintauchst – du findest sie fast in jeder zweiten Klasse der Standardbibliothek! Zum Beispiel gibt es bei Dateioperationen Enums, um den Öffnungsmodus anzugeben (lesen, schreiben, erstellen).

5. Explizite Werte und Wertebereiche

Manchmal willst du eine Menge von int-Werten, die du im Code benutzt, in ein enum umwandeln. Das geht ganz easy:

public enum CompassDirection
{
    North = 10,
    East = 20,
    South = 30,
    West = 40
}

Jetzt ist CompassDirection.North = 10, East = 20 usw. Wenn ein Element keinen Wert bekommt, nimmt es automatisch den Wert des vorherigen +1.

Speichertyp

Standardmäßig wird enum als int (4-Byte-Ganzzahl) gespeichert. Du kannst aber auch einen anderen Basistyp angeben, wenn du Speicher sparen willst:

public enum TinyEnum : byte
{
    First,  // 0
    Second, // 1
    Third   // 2
}

Jetzt ist jeder Enum-Wert nur ein Byte groß!

Alle möglichen Typen: byte, sbyte, short, ushort, int, uint, long, ulong.

6. Konvertierung zwischen enum und Zahlen/Strings

Konvertierung enum ↔ int:

Um ein Enum in ein int und zurück zu verwandeln, reicht ein einfacher Typecast:

WeatherCondition current = WeatherCondition.Cloudy;
int number = (int)current; // Gibt 1

WeatherCondition fromNumber = (WeatherCondition)2; // Gibt Rainy

Konvertierung enum ↔ string:

Ein Enum in einen String zu verwandeln ist easy: einfach ToString() aufrufen.

// Enum zu String konvertieren
string name = WeatherCondition.Stormy.ToString(); // "Stormy"

// String zu Enum mit Enum.Parse konvertieren
WeatherCondition parsed = (WeatherCondition)Enum.Parse(typeof(WeatherCondition), "Stormy");

// Oder mit Enum.TryParse
WeatherCondition parsedOk;
if (Enum.TryParse("Snowy", out parsedOk))
{
    Console.WriteLine(parsedOk); // Snowy
}

Typischer Fehler:
Wenn du eine Zahl zu einem enum castest, für die es kein Element gibt, meckert der Compiler nicht, aber du bekommst einen „virtuellen“ Zustand.
Zum Beispiel:

WeatherCondition weird = (WeatherCondition)999;
Console.WriteLine(weird); // 999 (wird nicht zu "Unbekannt"!)

Das heißt, als Entwickler solltest du bei solchen Konvertierungen aufpassen.

7. switch und enum – ein Dream-Team

Enums (enum) passen perfekt zum switch-Statement. Das ist ein praktischer und übersichtlicher Weg, auf verschiedene Enum-Werte zu reagieren – ohne lange „if-else“-Ketten.

Beispiel: Wetterreaktion

public enum WeatherCondition
{
    Sunny,
    Cloudy,
    Rainy,
    Stormy,
    Snowy
}

WeatherCondition today = WeatherCondition.Rainy;

switch (today)
{
    case WeatherCondition.Sunny:
        Console.WriteLine("Sonnig! Perfekt zum Spazierengehen.");
        break;
    case WeatherCondition.Cloudy:
        Console.WriteLine("Bewölkt. Vielleicht eine Jacke mitnehmen.");
        break;
    case WeatherCondition.Rainy:
        Console.WriteLine("Es regnet. Vergiss den Schirm nicht!");
        break;
    case WeatherCondition.Stormy:
        Console.WriteLine("Sturm! Bleib lieber zu Hause.");
        break;
    case WeatherCondition.Snowy:
        Console.WriteLine("Es schneit – zieh eine Mütze an!");
        break;
    default:
        Console.WriteLine("Unbekanntes Wetter...");
        break;
}

• Jeder case entspricht einem Enum-Wert.
• Wenn der Wert zu keinem bekannten Fall passt, wird default ausgeführt (praktisch, falls jemand eine Zahl direkt zum Enum gecastet hat).

Warum ist enum + switch so cool?

• Lesbarkeit: Alle möglichen Fälle sieht man sofort in der case-Liste.
• Einfach zu erweitern: Neuer Wettertyp? Einfach einen weiteren case hinzufügen.
• Sicherheit: Der Compiler warnt dich, wenn du einen Fall vergisst (ab C# 8.0 kannst du sogar Exhaustiveness-Checks aktivieren).

Beispiel: Enum mit Logik für ein Spiel

public enum GameState
{
    Start,
    Playing,
    Paused,
    GameOver
}

void PrintState(GameState state)
{
    switch (state)
    {
        case GameState.Start:
            Console.WriteLine("Willkommen im Spiel!");
            break;
        case GameState.Playing:
            Console.WriteLine("Das Spiel läuft. Viel Glück!");
            break;
        case GameState.Paused:
            Console.WriteLine("Pause. Zeit zum Durchatmen.");
            break;
        case GameState.GameOver:
            Console.WriteLine("Spiel vorbei. Versuch's nochmal!");
            break;
        default:
            Console.WriteLine("Unbekannter Spielzustand.");
            break;
    }
}

Tipps:

• Wenn du für mehrere Fälle das Gleiche machen willst, kannst du sie zusammenfassen:

switch (today)
{
    case WeatherCondition.Rainy:
    case WeatherCondition.Stormy:
        Console.WriteLine("Vergiss Schirm und warme Klamotten nicht!");
        break;
}

• Vergiss default nicht, um unerwartete Werte abzufangen (z.B. falls jemand eine Zahl direkt zum Enum gecastet hat).
• Mit switch kannst du easy State Machines, Menüs und alle Systeme mit festen Optionen bauen.

8. Enums und wichtige .NET-Methoden/Services

.NET bietet viele nützliche Methoden für Enums:

• Enum.GetNames(typeof(WeatherCondition)) – alle Namen holen.
• Enum.GetValues(typeof(WeatherCondition)) – alle Werte holen.
• Enum.IsDefined(typeof(WeatherCondition), "Rainy") – checken, ob es ein Element mit diesem Namen gibt.
• Doku: System.Enum

Beispiel: Alle Wettertypen ausgeben:

foreach (var name in Enum.GetNames(typeof(WeatherCondition)))
{
    Console.WriteLine(name);
}

9. Häufige Fehler und „Fallen“

• Man benutzt „magische Zahlen“ statt Enums und verliert so Lesbarkeit.
• Man behandelt Werte nicht, die im Enum nicht definiert sind (siehe Cast von Zahlen).
• Man gibt den Enum-Elementen keine sinnvollen Namen (Value1, Value2... – und keiner weiß mehr, was das bedeutet).
• Man verletzt das Single-Responsibility-Prinzip – ein Enum für verschiedene, nicht zusammenhängende Dinge.

Beste Lösung: Immer Enums verwenden, wenn es eine endliche Menge an Optionen gibt, und den Elementen sinnvolle, selbstdokumentierende Namen geben.