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.
1. 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
1.1. 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
2. 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
3. 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
4. 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)
5. 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
6. Ü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.
7. 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
8. 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!
Schreibe einen Kommentar