Freigeben über


enum-Anweisung

Deklariert den Namen eines aufgelisteten Datentyps sowie die Namen der Member der Enumeration.

[modifiers] enum enumName [ : typeAnnotation]{
   enumValue1 [ = initializer1]
   [,enumValue2 [ = initializer2]
   [, ... [,enumValueN [ = initializerN ] ]]]
}

Argumente

  • modifiers
    Optional. Modifizierer, die die Sichtbarkeit und das Verhalten der Enumeration steuern.

  • enumName
    Erforderlich. Der Name des aufgelisteten Typs.

  • typeAnnotation
    Optional. Der der Enumeration zugrunde liegende Datentyp. Es muss sich um einen ganzzahligen Datentyp handeln. Der Standardtyp ist int.

  • enumValue1, enumValue2, ..., enumValueN
    Optional. Ein aufgelisteter Typenmember.

  • initializer1, initializer2, ..., initializerN
    Optional. Ein konstanter Ausdruck, der den numerischen Standardwert eines Enumerationsmembers überschreibt.

Hinweise

Eine enum-Deklaration führt im Programm einen neuen aufgelisteten Datentyp ein. Eine enum-Deklaration kann nur in einem Kontext auftreten, in dem auch eine Klassendeklaration möglich ist, d. h. im globalen Gültigkeitsbereich, in einem Paketgültigkeitsbereich oder in einem Klassengültigkeitsbereich, jedoch nicht innerhalb einer Funktion oder Methode.

Sie können den einer Enumeration zugrunde liegenden Typ als beliebigen ganzzahligen Datentyp deklarieren (int, short, long, byte, uint, ushort, ulong oder sbyte). Enumerationsmember werden implizit in und aus dem zugrunde liegenden Datentyp umgewandelt und bieten so die Möglichkeit, numerische Daten direkt Variablen mit enum-Typisierung zuzuweisen. Der einer Enumeration zugrunde liegende Standarddatentyp ist int.

Jeder aufgelistete Typenmember hat einen Namen und eine optionale Initialisierung. Eine Initialisierung muss ein konstanter Kompilierzeitausdruck vom gleichen Typ sein wie die angegebene Enumeration bzw. in diesen Typ konvertierbar sein. Der erste aufgelistete Typenmember hat den Wert 0 oder den Wert der Initalisierung, sofern vorhanden. Der Wert jedes folgenden aufgelisteten Typenmembers ist jeweils um eins höher als der des vorhergehenden Members bzw. der Wert der Initalisierung, sofern vorhanden.

Auf einen enum-Wert wird auf ähnliche Weise zugegriffen wie auf einen statischen Klassenmember. Der Name des Members muss mit dem Namen der Enumeration gekennzeichnet sein, z. B. Color.Red. Wenn einer Variablen eines enum-Typs ein Wert zugewiesen wird, kann dafür entweder ein voll gekennzeichneter Name (z. B. Color.Red), eine Zeichenfolgendarstellung des Namens (z. B. "Red") oder ein numerischer Wert verwendet werden.

Wenn einer enum eine zur Kompilierzeit bekannte Zeichenfolge zugewiesen wird, führt der Compiler die erforderliche Konvertierung durch. Beispiel: "Red" wird durch Color.Red ersetzt. Wenn die Zeichenfolge zur Kompilierzeit unbekannt ist, wird die Konvertierung zur Laufzeit durchgeführt. Diese Konvertierung kann fehlschlagen, wenn die Zeichenfolge kein gültiger Member des aufgelisteten Typs ist. Die Konvertierung ist zeitaufwendig, und es können u. U. Laufzeitfehler auftreten. Aus diesem Grund empfiehlt es sich, enum keiner Variablenzeichenfolge zuzuweisen.

Eine Variable eines aufgelisteten Typs kann Werte aufnehmen, die außerhalb des gültigen Bereichs deklarierter Werte liegen. Mit diesem Feature können u. a. als Bitflags verwendete Member miteinander kombiniert werden, wie im unten stehenden Beispiel veranschaulicht. Wenn eine enum-Variable in eine Zeichenfolge konvertiert wird, hat das zur Folge, dass der Membername als Zeichenfolge dargestellt wird.

Beispiel 1

Das folgende Beispiel veranschaulicht das Verhalten von Enumerationen. Es wird eine einfache Enumeration mit dem Namen CarType mit den Membern Honda, Toyota und Nissan deklariert.

enum CarType {
   Honda,    // Value of zero, since it is first.
   Toyota,   // Value of 1, the successor of zero.
   Nissan    // Value of 2.
}

// Declare a variable of type CarType, and give it the value Honda.
var myCar : CarType = CarType.Honda;
print(int(myCar) + ": " + myCar);

myCar = "Nissan"; // Change the value to "Nissan".
print(int(myCar) + ": " + myCar);

myCar = 1; // 1 is the value of the Toyota member.
print(int(myCar) + ": " + myCar);

Ausgabe dieses Codes:

0: Honda
2: Nissan
1: Toyota

Beispiel 2

Das folgende Beispiel veranschaulicht die Verwendung einer Enumeration zum Speichern von Bitflags. Außerdem wird gezeigt, dass eine enum-Variable in der Lage sein muss, nicht explizit in der Memberliste aufgelistete Werte aufzunehmen. Es wird eine FormatFlags-Enumeration definiert, mit der das Verhalten einer Format-Funktion verändert werden kann.

// Explicitly set the type to byte, as there are only a few flags.
enum FormatFlags : byte {
   // Can't use the default values, since we need explicit bits
   ToUpperCase = 1,   // Should not combine ToUpper and ToLower.
   ToLowerCase = 2,
   TrimLeft    = 4,   // Trim leading spaces.
   TrimRight   = 8,   // Trim trailing spaces.
   UriEncode   = 16   // Encode string as a URI.
}

function Format(s : String, flags : FormatFlags) : String {
   var ret : String = s;
   if(flags & FormatFlags.ToUpperCase) ret = ret.toUpperCase();
   if(flags & FormatFlags.ToLowerCase) ret = ret.toLowerCase();
   if(flags & FormatFlags.TrimLeft)    ret = ret.replace(/^\s+/g, "");
   if(flags & FormatFlags.TrimRight)   ret = ret.replace(/\s+$/g, "");
   if(flags & FormatFlags.UriEncode)   ret = encodeURI(ret);
   return ret;
}

// Combine two enumeration values and store in a FormatFlags variable.
var trim : FormatFlags = FormatFlags.TrimLeft | FormatFlags.TrimRight;
// Combine two enumeration values and store in a byte variable.
var lowerURI : byte = FormatFlags.UriEncode | FormatFlags.ToLowerCase;

var str : String = "  hello, WORLD  ";

print(trim + ": " + Format(str, trim));
print(FormatFlags.ToUpperCase + ": " + Format(str, FormatFlags.ToUpperCase));
print(lowerURI + ": " + Format(str, lowerURI));

Ausgabe dieses Codes:

12: hello, WORLD
ToUpperCase:   HELLO, WORLD  
18: %20%20hello,%20world%20%20

Anforderungen

Version .NET

Siehe auch

Konzepte

Typkonvertierung

Typanmerkung

Weitere Ressourcen

Modifizierer