Freigeben über

Enumerationstypen (C#-Referenz)

Ein Enumerationstyp (oder Enumerationstyp) ist ein Werttyp , der durch einen Satz benannter Konstanten des zugrunde liegenden integralen numerischen Typs definiert wird. Verwenden Sie zum Definieren eines Enumerationstyps das enum Schlüsselwort, und geben Sie die Namen der Enumerationselemente an:

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Standardmäßig sind die zugehörigen Konstantenwerte von Aufzählungselementen vom Typ int; sie beginnen mit Null und nehmen im Textverlauf der Definition um eins zu. Sie können einen beliebigen anderen integralen numerischen Typ explizit als zugrunde liegenden Typ eines Enumerationstyps angeben. Sie können auch explizit die zugeordneten Konstantenwerte angeben, wie das folgende Beispiel zeigt:

enum ErrorCode : ushort
{
    None = 0,
    Unknown = 1,
    ConnectionLost = 100,
    OutlierReading = 200
}

Sie können eine Methode innerhalb der Definition eines Enumerationstyps nicht definieren. Wenn Sie einem Enumerationstyp Funktionen hinzufügen möchten, erstellen Sie ein Erweiterungselement.

Der Standardwert eines Enumerationstyps E ist der wert, der vom Ausdruck (E)0erzeugt wird, auch wenn null nicht über das entsprechende Enumerationselement verfügt.

Implizite Konvertierungen von Null

C# ermöglicht implizite Konvertierungen vom Literalwert 0 in einen beliebigen Enumerationstyp und von const Werten gleich Null. Dieses Verhalten kann zu unerwarteten Ergebnissen führen, wenn eine Enumeration kein Element mit dem Wert Null enthält:

public enum GpioPort
{
    GpioA = 1,
    GpioB,
    GpioC,
    GpioD
}

public class ZeroConversionExample
{
    public static void Main()
    {
        // This compiles without warning but creates an invalid enum value
        GpioPort port1 = (GpioPort)0;
        Console.WriteLine($"port1: {port1}"); // Output: port1: 0

        // This also compiles due to implicit conversion from zero
        GpioPort port2 = GetPort(0);
        Console.WriteLine($"port2: {port2}"); // Output: port2: 0

        // Check if the enum value is valid
        bool isValid1 = Enum.IsDefined(typeof(GpioPort), port1);
        bool isValid2 = Enum.IsDefined(typeof(GpioPort), port2);
        Console.WriteLine($"port1 is valid: {isValid1}"); // Output: port1 is valid: False
        Console.WriteLine($"port2 is valid: {isValid2}"); // Output: port2 is valid: False

        // Safer approach - validate enum values
        if (Enum.IsDefined(typeof(GpioPort), 0))
        {
            GpioPort safePort = (GpioPort)0;
        }
        else
        {
            Console.WriteLine("Value 0 is not a valid GpioPort");
            // Handle the invalid case appropriately
        }
    }

    public static GpioPort GetPort(GpioPort port)
    {
        return port;
    }
}

Im vorangehenden Beispiel wird der Wert port1sowohl port20 zugewiesen als auch der Wert zugewiesen, hat jedoch GpioPort kein Element mit diesem Wert. Die Enum.IsDefined Methode bestätigt, dass dies ungültige Enumerationswerte sind.

Diese implizite Konvertierung ist vorhanden, da das 0-Bit-Muster die Standardeinstellung für alle Strukturtypen ist, einschließlich aller Enumerationstypen. Es kann jedoch Fehler in Ihrem Code auftreten. Um diese Probleme zu vermeiden:

  • Sie sollten in Ihren Enumerationen fast immer ein Element mit Wert 0 definieren.
  • Wird Enum.IsDefined verwendet, um Enumerationswerte beim Konvertieren aus numerischen Typen zu überprüfen.
  • Seien Sie vorsichtig, wenn Sie numerische Parameter verwenden, die implizit in Enumerationstypen konvertiert werden können.

Sie verwenden einen Enumerationstyp, um eine Auswahl aus einer Reihe sich gegenseitig ausschließenden Werten oder einer Kombination von Auswahlmöglichkeiten darzustellen. Um eine Kombination von Auswahlmöglichkeiten darzustellen, definieren Sie einen Enumerationstyp als Bitkennzeichnungen.

Enumerationstypen als Bitflags

Wenn ein Enumerationstyp eine Kombination aus Auswahlmöglichkeiten darstellen soll, definieren Sie Enumerationsmember für diese Auswahlmöglichkeiten, sodass eine einzelne Auswahl ein Bitfeld ist. Das heißt, die zugeordneten Werte dieser Enumerationsmember sollten Zweierpotenzen sein. Anschließend können Sie die bitweisen logischen Operatoren | oder & verwenden, um Auswahlmöglichkeiten bzw. Schnittmengen von Auswahlmöglichkeiten zu kombinieren. Um anzugeben, dass ein Enumerationstyp Bitfelder deklariert, wenden Sie das Attribut "Flags " darauf an. Wie im folgenden Beispiel gezeigt, können Sie auch einige typische Kombinationen in die Definition eines Enumerationstyps einschließen.

[Flags]
public enum Days
{
    None      = 0b_0000_0000,  // 0
    Monday    = 0b_0000_0001,  // 1
    Tuesday   = 0b_0000_0010,  // 2
    Wednesday = 0b_0000_0100,  // 4
    Thursday  = 0b_0000_1000,  // 8
    Friday    = 0b_0001_0000,  // 16
    Saturday  = 0b_0010_0000,  // 32
    Sunday    = 0b_0100_0000,  // 64
    Weekend   = Saturday | Sunday
}

public class FlagsEnumExample
{
    public static void Main()
    {
        Days meetingDays = Days.Monday | Days.Wednesday | Days.Friday;
        Console.WriteLine(meetingDays);
        // Output:
        // Monday, Wednesday, Friday

        Days workingFromHomeDays = Days.Thursday | Days.Friday;
        Console.WriteLine($"Join a meeting by phone on {meetingDays & workingFromHomeDays}");
        // Output:
        // Join a meeting by phone on Friday

        bool isMeetingOnTuesday = (meetingDays & Days.Tuesday) == Days.Tuesday;
        Console.WriteLine($"Is there a meeting on Tuesday: {isMeetingOnTuesday}");
        // Output:
        // Is there a meeting on Tuesday: False

        var a = (Days)37;
        Console.WriteLine(a);
        // Output:
        // Monday, Wednesday, Saturday
    }
}

Weitere Informationen und Beispiele finden Sie auf der System.FlagsAttribute API-Referenzseite sowie im Abschnitt „Nicht-exklusive Mitglieder und das Flags-Attribut“ der System.Enum API-Referenzseite.

Der System.Enum-Typ und die enum-Einschränkung

Der System.Enum Typ ist die abstrakte Basisklasse aller Enumerationstypen. Es stellt eine Reihe von Methoden zum Abrufen von Informationen zu einem Enumerationstyp und dessen Werten bereit. Weitere Informationen und Beispiele finden Sie auf der System.Enum API-Referenzseite.

Sie können in einer Basisklasseneinschränkung (die als System.Enum bezeichnet wird) verwenden, um anzugeben, dass ein Typparameter ein Enumerationstyp ist. Jeder Enumerationstyp erfüllt auch die struct Einschränkung, die verwendet wird, um anzugeben, dass ein Typparameter ein nicht nullabler Werttyp ist.

Konvertierungen

Für jeden Enumerationstyp gibt es explizite Konvertierungen zwischen dem Enumerationstyp und dem zugrunde liegenden integralen Typ. Wenn Sie einen Enumerationswert in den zugrunde liegenden Typ umwandeln , ist das Ergebnis der zugeordnete integrale Wert eines Enumerationselements.

public enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

public class EnumConversionExample
{
    public static void Main()
    {
        Season a = Season.Autumn;
        Console.WriteLine($"Integral value of {a} is {(int)a}");  // output: Integral value of Autumn is 2

        var b = (Season)1;
        Console.WriteLine(b);  // output: Summer

        var c = (Season)4;
        Console.WriteLine(c);  // output: 4
    }
}

Verwenden Sie die Enum.IsDefined Methode, um zu bestimmen, ob ein Enumerationstyp ein Enumerationselement mit dem bestimmten zugeordneten Wert enthält.

Für jeden Enumerationstyp gibt es Boxing- und Unboxing-Konvertierungen in bzw. aus dem System.Enum-Typ.

C#-Sprachspezifikation

Weitere Informationen finden Sie in den folgenden Abschnitten der C#-Sprachspezifikation:

Siehe auch

  • Last updated on