Alles über das C# Enum (mit Codebeispielen)

Oft gibt es eine bestimmte Menge an Optionen für einen Sachverhalt, quasi eine Aufzählung. Mit solchen Aufzählungen können wir auch arbeiten, um festzulegen, wie sich unsere Programme verhalten sollen. Dafür können wir in C# enum verwenden.
Wie du damit arbeiten kannst, möchte ich im Folgenden genauer erklären.

Was ist ein C# Enum?

Generell sind Aufzählungen in C# Aneinanderreihungen von Zahlenwerten, die mit einem Namen aufgerufen werden können. Diese kannst du einfach mit dem Schlüsselwort enum definieren.
Aufzählungen ohne Flags:

enum Größe {
    Klein,  // 0
    Mittel, // 1
    Groß    // 2
}

Du kannst für enums auch einen zugrundeliegenden Datentyp angeben. Standardmäßig ist dieser Int32.
Aufzählungen mit Flags:

enum Größe : ushort {
    Klein,
    Mittel,
    Groß
}

Eine Variable daraus kannst du nun erstellen, indem du den Namen des gewünschten Wertes zuweist.

Größe größe = Größe.Mittel;
Console.WriteLine(größe);
// Mittel

Da jeder Name einem Zahlenwert entspricht, kannst du auch einen Integer zuweisen, um eine Variable auf Grundlage deiner Aufzählung zu erstellen.

Größe größe = 0;
Console.WriteLine(größe);
// Klein

C# Enums mit Flags

Es ist auch möglich, Aufzählungen mit Flags zu erstellen. Das bedeutet, dass bei einer solchen Aufzählung mehrere statt, wie zuvor, nur ein Wert zulässig sind. Diese müssen mit dem Attribut Flags und als Potenzen von 2 angegeben werden.

enum No_flags {
    eins = 1,
    zwei = 2
}

[Flags]
enum Flags {
    eins = 1,
    zwei = 2
}

Der Unterschied zwischen diesen beiden wird erst deutlich, wenn du mehrere Werte gleichzeitig versuchst zu setzen.

No_flags no_flags_1 = No_flags.eins | No_flags.zwei;
Console.WriteLine(no_flags_1);
// 3
Flags flags_1 = Flags.eins | Flags.zwei;
Console.WriteLine(flags_1);
// eins, zwei

Auf die gleiche Weise kannst du dies mit Zahlenwerten ausführen.

No_flags no_flags_2 = (No_flags)3;
Console.WriteLine(no_flags_2);
// 3
Flags flags_2 = (Flags)3;
Console.WriteLine(flags_2);
// eins, zwei

Du kannst entsprechend Zahlenwerte auch in Bits angeben. 

[Flags]
enum Tage {
    Montag = 0b_0000_0001,     // 1
    Dienstag = 0b_0000_0010,   // 2
    Mittwoch = 0b_0000_0100,   // 4
    Donnerstag = 0b_0000_1000, // 8
    Freitag = 0b_0001_0000,    // 16
    Samstag = 0b_0010_0000,    // 32
    Sonntag = 0b_0100_0000,    // 64
    Wochenende = Samstag | Sonntag // 64 + 32 = 96
}

Das folgende Beispiel zeigt, wie Potenzen von 2 in Tage konvertiert werden.

Tage tage = (Tage)64 + 32;
Console.WriteLine(tage);
// Wochenende
tage = (Tage)32 + 16;
Console.WriteLine(tage);
// Freitag, Samstag

So wandelst du einen String zu einem C# Enum um

Neben dem einfachen casting von Zahlenwerten in Enum-Objekte kannst du auch Strings in solche konvertieren. Eine der Methoden dafür ist Parse. Für die folgenden Beispiele verwende ich ebenfalls die Aufzählung Tage aus dem vorigen Beispiel.

var geparst = Enum.Parse(typeof(Tage), "Dienstag");
Console.WriteLine(geparst);
// Dienstag
Tage geparst_1 = Enum.Parse<Tage>("Wochenende");
Console.WriteLine(geparst_1);
// Wochenende

Die vorigen Methodenaufrufe achten auf Groß- und Kleinschreibung.  Mit einem zusätzlichen Parameter kannst du die Methode anweisen, diese zu ignorieren.

var geparst_2 = Enum.Parse(typeof(Tage), "dienstag", true);
Console.WriteLine(geparst_2);
// Dienstag
Tage geparst_3 = Enum.Parse<Tage>("wochenende", true);
Console.WriteLine(geparst_3);
// Wochenende

Wenn Parse einen ungültigen Wert erhält, wird eine System.ArgumentException produziert. Um dies zu vermeiden, kannst du stattdessen die Methode TryParse verwenden. Diese gibt zurück, ob ein Wert konvertiert werden kann. Dabei kannst du einen out-Parameter definieren, der dann den konvertierten Wert enthält.

bool erfolg = Enum.TryParse(typeof(Tage), "Dienstag", out var ergebnis);
Console.WriteLine(erfolg);
// True
Console.WriteLine(ergebnis);
// Dienstag

Auch hier kannst du mit einem weiteren Parameter die Groß- und Kleinschreibung ignorieren.

erfolg = Enum.TryParse(typeof(Tage), "dienstag", true, out ergebnis);
Console.WriteLine(erfolg);
// True
Console.WriteLine(ergebnis);
// Dienstag

Bei Fehlern gibt der out-Parameter NULL zurück.

erfolg = Enum.TryParse(typeof(Tage), "tuesday", true, out ergebnis);
Console.WriteLine(erfolg);
// False
Console.WriteLine(ergebnis);
//

Eine weitere Option, um einen Wert in ein Objekt unseres Enums zu konvertieren, ist ToObject.

var obj = Enum.ToObject(typeof(Tage), 4);
Console.WriteLine(obj);
// Mittwoch
Tage tag = (Tage)4;
if (tag.Equals(obj))
    Console.WriteLine("True");
// True

So wandelst du einen C# Enum zu Integer um

Nachdem unsere Aufzählungen Zahlen repräsentieren, kannst du diese natürlich auch einfach in verschiedene numerische Datentypen konvertieren. Der einfachste Weg dazu ist das casting.

Console.WriteLine((int)Tage.Freitag);
// 16

Dazu gibt es noch die Methode Format.
Damit kannst du deine Variable als String, Dezimalzahl oder in Hexadezimal ausgeben.

Console.WriteLine(Enum.Format(typeof(Tage), tag, "G"));
// Freitag
Console.WriteLine(Enum.Format(typeof(Tage), tag, "X"));
// 00000010
Console.WriteLine(Enum.Format(typeof(Tage), tag, "D"));
// 16
Console.WriteLine(Enum.Format(typeof(Tage), tag, "F"));
// Freitag

Alle Optionen für das Ausgabeformat findest du hier:
https://docs.microsoft.com/en-us/dotnet/api/system.enum.format?view=netcore-3.1#remarks

Mit der Methode GetValues kannst du auch alle möglichen Werte eines Enums ausgeben lassen.

foreach (int wert in Enum.GetValues(typeof(Tage))) {
    Console.WriteLine(wert);
}

1
2
4
8
16
32
64
96

C# Enum in String umwandeln

Die Methode ToString gibt die Standardstringrepräsentation des Objektes zurück.

Tage tag = Tage.Dienstag;
Console.WriteLine(tag.ToString());
// Dienstag
tag = Tage.Wochenende;
Console.WriteLine(tag.ToString());
// Wochenende

Mit der Funktion GetName erhältst du den Namen eines Objektes. In den meisten Fällen ist dieser gleich der normalen Stringrepräsentation.

var name = Enum.GetName(typeof(Tage), 8);
Console.WriteLine(name);
// Donnerstag
name = Enum.GetName(typeof(Tage), Tage.Freitag);
Console.WriteLine(name);
// Freitag
Tage tag = Tage.Donnerstag;
name = Enum.GetName(typeof(Tage), tag);
Console.WriteLine(name);
// Donnerstag
tag = Tage.Wochenende;
name = Enum.GetName(typeof(Tage), tag);
Console.WriteLine(name);
// Wochenende

Mit der Methode GetNames kannst du die Namen aller Felder einer Aufzählung ausgeben lassen.

var names = Enum.GetNames(typeof(Tage));
foreach (string name in names) {
    Console.WriteLine(name);
}

Montag
Dienstag
Mittwoch
Donnerstag
Freitag
Samstag
Sonntag
Wochenende

Mit der Methode GetValues kannst du ebenfalls alle Namen ausgeben lassen.

foreach (var wert in Enum.GetValues(typeof(Tage))) {
    Console.WriteLine(wert);
}

Montag
Dienstag
Mittwoch
Donnerstag
Freitag
Samstag
Sonntag
Wochenende

Wenn du in der foreach-Schleife statt var vor wert int angibst, erhältst du alle Werte als Integer. (siehe auch 3. Aufzählungen in Zahlen konvertieren)

Objekte mit Equals vergleichen

Du kannst überprüfen, ob dein Objekt gleich einem anderen ist mit der Methode Equals.

Tage tag = Tage.Sonntag;
Console.WriteLine(tag.Equals(Tage.Sonntag));
// True
Console.WriteLine(tag.Equals(Tage.Mittwoch));
// False

Mit CompareTo kannst du überprüfen, ob ein Objekt einen höheren, niedrigeren oder den gleichen Wert hat wie ein anderes.

Tage tag = Tage.Mittwoch;
Console.WriteLine(tag.CompareTo(Tage.Mittwoch));
// 0
Console.WriteLine(tag.CompareTo(Tage.Montag));
// 1
Console.WriteLine(tag.CompareTo(Tage.Sonntag));
// -1

Wenn die Objekte den gleichen Wert haben, ist das Ergebnis 0. Wenn der Wert des Objektes auf das CompareTo angewendet wird, größer ist, ist der Rückgabewert größer als 0. Im umgekehrten Fall ist er kleiner als 0.

Mit der Funktion HasFlag kannst du überprüfen ob ein Objekt einer Aufzählung mit dem Attribut Flags einen bestimmten Wert enthält.

Tage tage = Tage.Montag | Tage.Wochenende;
Console.WriteLine(tage.HasFlag(Tage.Sonntag));
// True
Console.WriteLine(tage.HasFlag(Tage.Dienstag));
// False

Überprüfen, ob ein Wert in einer Aufzählung definiert ist

Um zu prüfen ob eine Aufzählung einen speziellen Wert enthält, kannst du die Methode IsDefined verwenden.

bool ist_definiert = Enum.IsDefined(typeof(Tage), 21);
Console.WriteLine(ist_definiert);
// False
ist_definiert = Enum.IsDefined(typeof(Tage), 2);
Console.WriteLine(ist_definiert);
// True

IsDefined gibt einen Boolean zurück. True, wenn der Wert definiert ist, False, wenn nicht.

Typ eines C# Enums ermitteln

Mit der Methode GetUnderlyingType kannst du herausfinden, welchen Datentyp die Werte einer Auflistung haben.

var ergebnis = Enum.GetUnderlyingType(typeof(Tage));
Console.WriteLine(ergebnis);
// System.Int32
ergebnis = Enum.GetUnderlyingType(typeof(Größe));
Console.WriteLine(ergebnis);
// System.UInt16

Um den Datentyp anhand einer Variablen zu ermitteln, kannst du GetTypeCode verwenden.

Tage tag = Tage.Freitag;
Console.WriteLine(tag.GetTypeCode());
// Int32
Größe größe = Größe.Mittel;
Console.WriteLine(größe.GetTypeCode());
// UInt16

Fazit – Aufzählungen in C#

Aufzählungen/Enums sind mehr als praktisch, um verschiedene vorgegebene Optionen und Kombinationen daraus zur Verfügung zu stellen. Uns stehen alle nötigen Methoden zum Vergleich mit anderen Objekten sowie zur Konvertierung in andere Objekte zur Verfügung.

Wenn du noch Fragen, Anmerkungen, Lob oder Kritik hast, dann schreib doch bitte einen Kommentar!