C# Enums: Dein freundlicher Guide zu Enumerierten Typen

Hallo da draußen, zukünftiger Codingsuperstar! Heute tauchen wir ein in die wundersame Welt der Enums in C#. Keine Sorge, wenn du vorher noch nie von ihnen gehört hast – bis zum Ende dieses Tutorials wirst du ein Enum-Experte sein! Also, lasst uns gemeinsam diese aufregende Reise beginnen.

Was sind Enums?

Stell dir vor, du erstellst ein Spiel, bei dem Spieler verschiedene Charakterklassen wählen können. Du könntest Krieger, Magier, Bogenschützen und Heiler haben. Wie würdest du diese Optionen in deinem Code darstellen? Genau hier kommen Enums zur Rettung!

Ein Enum (kurz für enumeration) ist ein spezieller Typ in C#, der es dir ermöglicht, eine Reihe von benannten Konstanten zu definieren. Es ist so, als ob du einen benutzerdefinierten Typ mit einer festen Liste möglicher Werte erstellst. Cool, oder?

Warum Enums verwenden?

1. Sie machen deinen Code lesbarer.
2. Sie helfen, Fehler zu vermeiden, indem sie die Auswahl auf eine vordefinierte Liste beschränken.
3. Sie sind großartig zur Darstellung von Kategorien oder Optionen.

Deklaration eines Enums

Lass uns mit den Grundlagen beginnen. Hier ist, wie man ein Enum deklariert:

enum CharacterClass
{
Warrior,
Mage,
Archer,
Healer
}

In diesem Beispiel haben wir ein Enum namens CharacterClass mit vier möglichen Werten erstellt. Standardmäßig weist C# jedem Enum-Mitglied eine ganzzahlige Wert zu, beginnend bei 0.

Verwendung von Enums in deinem Code

Nun, da wir unser Enum deklariert haben, sehen wir uns an, wie wir es in unserem Code verwenden können:

class Program
{
static void Main(string[] args)
{
CharacterClass myClass = CharacterClass.Warrior;
Console.WriteLine($"Meine Charakterklasse ist: {myClass}");
}
}

Wenn du diesen Code ausführst, wird ausgegeben:

Meine Charakterklasse ist: Warrior

Ist das nicht toll? Wir haben gerade eine Variable vom Typ CharacterClass erstellt und ihr den Wert Warrior zugewiesen. Es ist, als ob man deinem Charakter eine Identitätskarte gibt!

Enum-Werte und Casten

Erinnern wir uns daran, dass Enums ganzzahlige Werte zugewiesen bekommen? Lassen wir uns das genauer ansehen:

Console.WriteLine($"Krieger Wert: {(int)CharacterClass.Warrior}");
Console.WriteLine($"Magier Wert: {(int)CharacterClass.Mage}");
Console.WriteLine($"Bogenschütze Wert: {(int)CharacterClass.Archer}");
Console.WriteLine($"Heiler Wert: {(int)CharacterClass.Healer}");

Dies wird ausgegeben:

Krieger Wert: 0
Magier Wert: 1
Bogenschütze Wert: 2
Heiler Wert: 3

Hier verwenden wir Casten (das ist, was der (int)-Teil macht), um unsere Enum-Werte in Ganzzahlen umzuwandeln. Es ist, als ob man hinter die Kulissen blickt, um zu sehen, wie C# unsere Enums organisiert!

Benutzerdefinierte Enum-Werte

Aber wait, es gibt mehr! Was ist, wenn du bestimmten Werten deinen Enum-Mitgliedern zuweisen möchtest? Das kannst du auch:

enum CharacterClass
{
Warrior = 1,
Mage = 5,
Archer = 10,
Healer = 15
}

Wenn wir unseren vorherigen Code zur Anzeige der Werte ausführen, erhalten wir:

Krieger Wert: 1
Magier Wert: 5
Bogenschütze Wert: 10
Heiler Wert: 15

Dies kann nützlich sein, wenn deine Enum-Werte bestimmten Zahlen in deinem Spiel oder deiner Anwendung entsprechen müssen.

Enums und Switch-Anweisungen

Enums und Switch-Anweisungen sind wie Erdnussbutter und Jelly – sie passen einfach perfekt zusammen! Hier ist ein Beispiel:

static void DescribeClass(CharacterClass characterClass)
{
switch (characterClass)
{
case CharacterClass.Warrior:
Console.WriteLine("Du bist ein mutiger Krieger, stark im Kampf!");
break;
case CharacterClass.Mage:
Console.WriteLine("Du bist ein weiser Magier, Meister der arkane Künste!");
break;
case CharacterClass.Archer:
Console.WriteLine("Du bist ein geschickter Bogenschütze, tödlich aus der Ferne!");
break;
case CharacterClass.Healer:
Console.WriteLine("Du bist ein einfühlsamer Heiler, Hüter des Lebens!");
break;
default:
Console.WriteLine("Unbekannte Klasse. Bist du eine geheime Klasse?");
break;
}
}

Jetzt können wir diese Funktion so verwenden:

DescribeClass(CharacterClass.Mage);

Und sie wird ausgegeben:

Du bist ein weiser Magier, Meister der arkane Künste!

Enum-Parsing

Manchmal musst du eine Zeichenkette in einen Enum-Wert umwandeln. Zum Beispiel, wenn ein Spieler seine gewählte Klasse eingibt. Hier ist, wie du das machen kannst:

string input = "Archer";
if (Enum.TryParse(input, out CharacterClass playerClass))
{
Console.WriteLine($"Du hast dich für einen {playerClass} entschieden!");
}
else
{
Console.WriteLine("Das ist keine gültige Charakterklasse!");
}

Dieser Code wird versuchen, die Zeichenkette "Archer" in unser CharacterClass-Enum umzuwandeln. Wenn es ihm gelingt, wird ausgegeben:

Du hast dich für einen Bogenschütze entschieden!

Enum-Methoden

Lassen wir es mit einer Tabelle nützlicher Enum-Methoden abschließen:

Methode	Beschreibung	Beispiel
Enum.GetNames()	Gibt ein Array der Namen der Konstanten in einer angegebenen Enumeration zurück	string[] names = Enum.GetNames(typeof(CharacterClass));
Enum.GetValues()	Gibt ein Array der Werte der Konstanten in einer angegebenen Enumeration zurück	CharacterClass[] values = (CharacterClass[])Enum.GetValues(typeof(CharacterClass));
Enum.IsDefined()	Gibt einen booleschen Wert zurück, der angibt, ob eine Konstante mit einem angegebenen Wert in einer angegebenen Enumeration existiert	bool isDefined = Enum.IsDefined(typeof(CharacterClass), "Warrior");
Enum.Parse()	Konvertiert die Zeichenkettenrepräsentation des Namens oder der numerischen Werte eines oder mehrerer enumerierter Konstanten in ein äquivalentes enumeriertes Objekt	CharacterClass parsedEnum = (CharacterClass)Enum.Parse(typeof(CharacterClass), "Mage");
Enum.TryParse()	Konvertiert die Zeichenkettenrepräsentation des Namens oder der numerischen Werte eines oder mehrerer enumerierter Konstanten in ein äquivalentes enumeriertes Objekt. Der Rückgabewert gibt an, ob die Konvertierung erfolgreich war	bool success = Enum.TryParse("Healer", out CharacterClass result);

Und das war's, meine lieben Schüler! Du hast gerade deine C#-Fähigkeiten durch das Beherrschen von Enums aufgestockt. Denke daran, Übung macht den Meister, also versuche, deine eigenen Enums für verschiedene Szenarien zu erstellen. Vielleicht könntest du ein Enum für die Wochentage, Pizza-Zutaten oder sogar deine Lieblingsprogrammier-Sprachen machen!

Weiter codieren, weiter lernen und vor allem: Viel Spaß! Bis zum nächsten Mal, möge dein Code frei von Fehlern sein und deine Compile-Zeiten flink sein!

Credits: Image by storyset