(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original
Dieser Artikel wurde noch nicht bewertet - Dieses Thema bewerten.

Enum-Klasse

Stellt die Basisklasse für Enumerationen bereit.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)
[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Enum : ValueType, 
	IComparable, IFormattable, IConvertible

Der Enum-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEnumInitialisiert eine neue Instanz der Enum-Klasse.
Zum Seitenanfang
  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareToVergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEqualsGibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. (Überschreibt ValueType.Equals(Object).)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsFinalize Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Von Object geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsFormatKonvertiert den angegebenen Wert eines angegebenen Enumerationstyps unter Berücksichtigung des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeGibt den Hashcode für den Wert dieser Instanz zurück. (Überschreibt ValueType.GetHashCode().)
Öffentliche MethodeStatischer MemberUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetNameRuft den Namen der Konstanten der angegebenen Enumeration mit dem angegebenen Wert ab.
Öffentliche MethodeStatischer MemberUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetNamesRuft ein Array mit den Namen der Konstanten einer angegebenen Enumeration ab.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkGetTypeCodeGibt den dieser Instanz zugrunde liegenden TypeCode zurück.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetUnderlyingTypeGibt den zugrunde liegenden Typ der angegebenen Enumeration zurück.
Öffentliche MethodeStatischer MemberUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetValuesRuft ein Array mit den Werten der Konstanten einer angegebenen Enumeration ab.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsHasFlagBestimmt, ob ein oder mehrere Bitfelder in der aktuellen Instanz festgelegt werden.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsDefinedGibt eine Angabe darüber zurück, ob eine angegebene Enumeration eine Konstante mit einem angegebenen Wert enthält.
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMemberwiseCloneErstellt eine flache Kopie des aktuellen Object. (Von Object geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsParse(Type, String)Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsParse(Type, String, Boolean)Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt. Ein Parameter gibt an, ob bei der Operation die Groß- und Kleinschreibung nicht berücksichtigt wird.
Öffentliche MethodeStatischer MemberToObject(Type, Byte)Konvertiert die angegebene 8-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.
Öffentliche MethodeStatischer MemberToObject(Type, Int16)Konvertiert die angegebene 16-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.
Öffentliche MethodeStatischer MemberToObject(Type, Int32)Konvertiert die angegebene 32-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.
Öffentliche MethodeStatischer MemberToObject(Type, Int64)Konvertiert die angegebene 64-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToObject(Type, Object)Konvertiert das angegebene Objekt mit einem ganzzahligen Wert in einen Enumerationsmember.
Öffentliche MethodeStatischer MemberToObject(Type, SByte)Konvertiert den angegebenen Wert einer 8-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.
Öffentliche MethodeStatischer MemberToObject(Type, UInt16)Konvertiert den angegebenen Wert einer 16-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.
Öffentliche MethodeStatischer MemberToObject(Type, UInt32)Konvertiert den angegebenen Wert einer 32-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.
Öffentliche MethodeStatischer MemberToObject(Type, UInt64)Konvertiert den angegebenen Wert einer 64-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString()Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung. (Überschreibt ValueType.ToString().)
Öffentliche MethodeUnterstützt von XNA FrameworkToString(IFormatProvider) Veraltet. Diese Methodenüberladung ist veraltet. Verwenden Sie Enum.ToString().
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString(String)Konvertiert den Wert dieser Instanz anhand des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.
Öffentliche MethodeUnterstützt von XNA FrameworkToString(String, IFormatProvider) Veraltet. Diese Methodenüberladung ist veraltet. Verwenden Sie Enum.ToString(String).
Öffentliche MethodeStatischer MemberUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTryParse<TEnum>(String, TEnum)Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt. Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.
Öffentliche MethodeStatischer MemberUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTryParse<TEnum>(String, Boolean, TEnum)Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt. Ein Parameter gibt an, ob bei der Operation die Groß- und Kleinschreibung berücksichtigt wird. Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.
Zum Seitenanfang
  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToBooleanInfrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in einen booleschen Wert.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToByteInfrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 8-Bit-Ganzzahl ohne Vorzeichen.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToCharInfrastruktur. Konvertiert den aktuellen Wert entsprechend dem zugrunde liegenden Typ in ein Unicode-Zeichen.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDateTimeInfrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine DateTime.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDecimalInfrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine Decimal.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDoubleInfrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine Gleitkommazahl mit doppelter Genauigkeit.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt16Infrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 16-Bit-Ganzzahl mit Vorzeichen.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt32Infrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 32-Bit-Ganzzahl mit Vorzeichen.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt64Infrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 64-Bit-Ganzzahl mit Vorzeichen.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToSByteInfrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 8-Bit-Ganzzahl ohne Vorzeichen.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToSingleInfrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine Gleitkommazahl mit einfacher Genauigkeit.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToTypeInfrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in einen angegebenen Typ.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt16Infrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 16-Bit-Ganzzahl ohne Vorzeichen.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt32Infrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 32-Bit-Ganzzahl ohne Vorzeichen.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt64Infrastruktur. Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 64-Bit-Ganzzahl ohne Vorzeichen.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIFormattable.ToStringInfrastruktur. Veraltet. Diese Methodenüberladung ist veraltet. Verwenden Sie Enum.ToString(String).
Zum Seitenanfang

Eine Enumeration ist ein Satz benannter Konstanten, deren zugrunde liegende Typ ein ganzzahliger Typ ist. Wenn kein zugrunde liegender Typ explizit deklariert wurde, wird Int32 verwendet. Enum ist die Basisklasse für alle Enumerationen in .NET Framework.

Enum stellt Methoden zum Vergleichen von Instanzen dieser Klasse bereit, zum Konvertieren des Werts einer Instanz in die entsprechende Zeichenfolgendarstellung, zum Konvertieren der Zeichenfolgendarstellung einer Zahl in eine Instanz dieser Klasse und zum Erstellen einer Instanz einer angegebenen Enumeration mit einem bestimmten Wert.

Eine Enumeration kann auch als Bitfeld behandelt werden. Weitere Informationen finden Sie im Abschnitt Nicht ausschließliche Member und das Flags-Attribut und im Thema FlagsAttribute.

Erstellen eines Enumerationstyps

Programmiersprachen stellen üblicherweise die Syntax zum Deklarieren einer Enumeration bereit, die aus einer Gruppe benannter Konstanten und deren Werten besteht. Im folgenden Beispiel wird die von C# und Visual Basic verwendete Syntax zum Definieren einer Enumeration veranschaulicht. Eine Enumeration mit dem Namen ArrivalStatus wird erstellt, der über drei Member verfügt: ArrivalStatus.Early, ArrivalStatus.OnTime und ArrivalStatus.Late. Beachten Sie, dass in beiden Fällen die Enumeration nicht explizit von Enum erbt; die Vererbungsbeziehung wird implizit vom Compiler behandelt.


public enum ArrivalStatus { Late=-1, OnTime=0, Early=1 };


WarnhinweisVorsicht

Sie können einen Enumerationstyp nie erstellen, dessen zugrunde liegende Typ keine Ganzzahl oder Char ist. Obwohl Sie solch einen Enumerationstyp mit Reflektion erstellen können, sind Methodenaufrufe, die den resultierenden Typ verwenden, unzuverlässig und lösen möglicherweise auch zusätzliche Ausnahmen aus.

Instanziieren eines Enumerationstyps

Sie können einen Enumerationstyp so instanziieren, wie Sie einen beliebigen anderen Werttyp instanziieren: durch das Deklarieren einer Variablen und Zuweisen einer der Konstanten der Enumeration. Im folgenden Beispiel wird ein ArrivalStatus, dessen Wert ArrivalStatus.OnTime ist, instanziiert.


public class Example
{
   public static void Main()
   {
      ArrivalStatus status = ArrivalStatus.OnTime;
      Console.WriteLine("Arrival Status: {0} ({0:D})", status);
   }
}
// The example displays the following output:
//       Arrival Status: OnTime (0)


Sie können auch auf die folgende Weise einen Enumerationswert instanziieren:

  • Mit den Funktionen einer bestimmten Programmiersprache, um einen ganzzahligen Wert in einen Enumerationswert umzuwandeln (wie in C#) oder zu konvertieren (wie in Visual Basic). Im folgenden Beispiel wird ein ArrivalStatus-Objekt erstellt, dessen Wert auf diese Weise gleich ArrivalStatus.Early ist.

    
    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    
    
  • Durch Aufrufen von dessen implizitem Standardkonstruktor. Wie das folgende Beispiel zeigt, beträgt der zugrunde liegende Wert der Enumerationsinstanz in diesem Fall 0. Dies ist notwendigerweise jedoch nicht der Wert einer gültigen Konstante in der Enumeration.

    
    ArrivalStatus status1 = new ArrivalStatus();
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
    // The example displays the following output:
    //       Arrival Status: OnTime (0)
    
    
    
  • Durch das Aufrufen der Parse-Methode oder TryParse-Methode, um eine Zeichenfolge zu analysieren, die den Namen einer Konstante in der Enumeration enthält. Weitere Informationen finden Sie im Abschnitt Analyse von Enumerationswerten.

  • Durch das Aufrufen der ToObject-Methode, um einen ganzzahligen Wert in einen Enumerationstyp zu konvertieren. Weitere Informationen finden Sie im Abschnitt Ausführen von Konvertierungen.

Best Practices für die Enumeration

Es empfiehlt sich, dass Sie die folgenden Best Practices verwenden, wenn Sie Enumerationstypen definieren:

  • Wenn Sie keinen Enumerationsmember definiert haben, dessen Wert 0 ist, erwägen Sie, eine aufgelistete None-Konstante zu erstellen. Der für die Enumeration verwendete Speicher wird von der Common Language Runtime standardmäßig mit 0 (null) initialisiert. Daher enthält die Enumeration einen ungültigen Wert, wenn Sie sie erstellen, ohne eine Konstante zu definieren, deren Wert 0 (null) ist.

  • Wenn für die Anwendung ein offensichtlicher Standardfall erforderlich ist, sollten Sie für dessen Darstellung eine Enumerationskonstante verwenden, deren Wert 0 (null) ist. Wenn kein Standardwert erforderlich ist, sollten Sie eine Enumerationskonstante mit dem Wert 0 (null) verwenden. Damit wird der Fall dargestellt, für den keine anderen Enumerationskonstanten festgelegt wurden.

  • Geben Sie keine Enumerationskonstanten an, die für die zukünftige Verwendung reserviert sind.

  • Wenn Sie eine Methode oder Eigenschaft definieren, die eine Enumerationskonstante als Wert akzeptiert, sollten Sie den Wert validieren. Sie können dann einen numerischen Wert in den Enumerationstyp konvertieren, auch wenn der numerische Wert nicht in der Enumeration definiert ist.

Weitere Best Practices für Enumerationstypen, deren Konstanten Bitfelder sind, sind im Abschnitt Nicht ausschließliche Member und das Flags-Attribut aufgeführt.

Ausführen von Vorgängen mit Enumerationen

Beim Erstellen einer Enumeration können Sie keine neuen Methoden definieren. Ein Enumerationstyp erbt jedoch einen vollständigen Satz von statischen Methoden und Instanzmethoden von der Enum-Klasse. Die folgenden Abschnitte untersuchen die meisten dieser Methoden, zusätzlich zu mehreren anderen Methoden, die häufig beim Arbeiten mit Enumerationswerten verwendet werden.

1zt1ybx4.collapse_all(de-de,VS.110).gifAusführen von Konvertierungen

Sie können zwischen einem Enumerationsmember und seinem zugrunde liegenden Typ mit einem Umwandlungs- oder einem Konvertierungsoperator (in C# bzw. in Visual Basic) konvertieren. Im folgenden Beispiel verwendet oder Umwandlung Konvertierungsoperatoren, um Konvertierungen von eine ganze Zahl zu einen Enumerationswert und einem Enumerationswert in eine ganze Zahl.


int value3 = 2;
ArrivalStatus status3 = (ArrivalStatus) value3;

int value4 = (int) status3;


Die Enum-Klasse schließt auch eine ToObject-Methode ein, die einen Wert eines beliebigen ganzzahligen Typs in einen Enumerationswert konvertiert. Im folgenden Beispiel wird mit der ToObject(Type, Int32)-Methode ein Int32-Wert in einen ArrivalStatus-Wert konvertiert. Beachten Sie, dass, da ToObject einen Wert vom Typ Object zurückgibt, die mithilfe einer Umwandlung oder eines Konvertierungsoperators möglicherweise weiterhin erforderlich ist, um das Objekt den Enumerationstyp umzuwandeln.


int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);


Beim Konvertieren einer ganzen Zahl in einen Enumerationswert ist es möglich, einen Wert zuzuweisen, der eigentlich kein Member der Enumeration ist. Um dies zu verhindern, können Sie die ganze Zahl vor dem Ausführen der Konvertierung an die IsDefined-Methode übergeben. Im folgenden Beispiel wird diese Methode verwendet, um zu ermitteln, ob die Elemente in einem Array ganzzahliger Werte in ArrivalStatus-Werte konvertiert werden können.


using System;

public enum ArrivalStatus { Unknown=-3, Late=-1, OnTime=0, Early=1 };

public class Example
{
   public static void Main()
   {
      int[] values = { -3, -1, 0, 1, 5, Int32.MaxValue };
      foreach (var value in values)
      {
         ArrivalStatus status;
         if (Enum.IsDefined(typeof(ArrivalStatus), value))
            status = (ArrivalStatus) value;
         else
            status = ArrivalStatus.Unknown;
         Console.WriteLine("Converted {0:N0} to {1}", value, status);
      }
   }
}
// The example displays the following output:
//       Converted -3 to Unknown
//       Converted -1 to Late
//       Converted 0 to OnTime
//       Converted 1 to Early
//       Converted 5 to Unknown
//       Converted 2,147,483,647 to Unknown


Obwohl die Enum-Klasse explizite Schnittstellenimplementierungen der IConvertible-Schnittstelle zum Konvertieren von einem Enumerationswert in einen ganzzahligen Typ bereitstellt, sollten Sie diese Konvertierungen mithilfe der Methoden der Convert-Klasse, z. B. ToInt32, ausführen. Im folgenden Beispiel wird veranschaulicht, wie Sie die GetUnderlyingType-Methode zusammen mit der Convert.ChangeType-Methode verwenden können, um einen Enumerationswert in seinen zugrunde liegenden Typ zu konvertieren. Beachten Sie, dass es bei diesem Beispiel nicht erforderlich ist, dass der zugrunde liegende Typ der Enumeration zur Kompilierzeit bekannt ist.


ArrivalStatus status = ArrivalStatus.Early;
var number = Convert.ChangeType(status, Enum.GetUnderlyingType(typeof(ArrivalStatus)));
Console.WriteLine("Converted {0} to {1}", status, number);
// The example displays the following output:
//       Converted Early to 1


1zt1ybx4.collapse_all(de-de,VS.110).gifAnalysieren von Enumerationswerten

Mit der Parse-Methode und TryParse-Methode können Sie die Zeichenfolgendarstellung eines Enumerationswerts in diesen Wert konvertieren. Die Zeichenfolgendarstellung kann entweder der Name oder der zugrunde liegende Wert einer Enumerationskonstante sein. Beachten Sie, dass die Analysemethoden Zeichenfolgendarstellungen von Zahlen, die keine Member einer bestimmten Enumeration sind, erfolgreich konvertieren, wenn die Zeichenfolgen in einen Wert vom zugrunde liegenden Typ der Enumeration konvertiert werden können. Um dies zu verhindern, kann die IsDefined-Methode aufgerufen werden, um sicherzustellen, dass das Ergebnis der Analysemethode ein gültiger Enumerationswert ist. Im Beispiel werden dieser Ansatz sowie Aufrufe zu den Methoden Parse(Type, String) und Enum.TryParse<TEnum>(String, TEnum) veranschaulicht. Beachten Sie, dass die nicht generische Analysemethode ein Objekt zurückgibt, das Sie möglicherweise in den entsprechenden Enumerationstyp umwandeln (in C#) oder konvertieren (in Visual Basic) müssen.


string number = "-1";
string name = "Early";

try {
   ArrivalStatus status1 = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), number);
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status1)))
      status1 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", number, status1);
}
catch (FormatException) {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}   

ArrivalStatus status2;
if (Enum.TryParse<ArrivalStatus>(name, out status2)) {
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status2)))
      status2 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", name, status2);
}
else {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}
// The example displays the following output:
//       Converted '-1' to Late
//       Converted 'Early' to Early


1zt1ybx4.collapse_all(de-de,VS.110).gifFormatieren von Enumerationswerten

Sie können Enumerationswerte in ihre Zeichenfolgendarstellungen konvertieren, indem Sie die statische Format-Methode sowie die Überladungen der Instanz-ToString-Methode aufrufen. Sie können eine Formatzeichenfolge verwenden, um genau zu steuern, welcher Enumerationswert als Zeichenfolge dargestellt wird. Weitere Informationen finden Sie unter Enumerationsformatzeichenfolgen. Das folgende Beispiel konvertiert einen Member der ArrivalStatus-Enumeration mithilfe der unterstützten Enumerationsformatzeichenfolgen in seine Zeichenfolgendarstellungen.


string[] formats= { "G", "F", "D", "X"};
ArrivalStatus status = ArrivalStatus.Late;
foreach (var fmt in formats)
   Console.WriteLine(status.ToString(fmt));

// The example displays the following output:
//       Late
//       Late
//       -1
//       FFFFFFFF


1zt1ybx4.collapse_all(de-de,VS.110).gifDurchlaufen von Enumerationsmembern

Der Enum-Typ implementiert die IEnumerable-Schnittstelle oder IEnumerable<T>-Schnittstelle nicht, was Ihnen ermöglichen würde, Member einer Auflistung mit einem foreach-Konstrukt (in C#) oder einem For Each-Konstrukt (in Visual Basic) zu durchlaufen. Sie können jedoch Member auf zwei Arten auflisten.

  • Sie können die GetNames-Methode aufrufen, um ein Zeichenfolgenarray abzurufen, das die Namen der Enumerationsmember enthält. Danach können Sie für jedes Element des Zeichenfolgenarrays die Parse-Methode aufrufen, um die Zeichenfolge in ihren entsprechenden Enumerationswert zu konvertieren. Dieser Ansatz wird anhand des folgenden Beispiels veranschaulicht.

    
    string[] names = Enum.GetNames(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    Array.Sort(names);
    foreach (var name in names) {
       ArrivalStatus status = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), name);
       Console.WriteLine("   {0} ({0:D})", status);
    }
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          Early (1)
    //          Late (-1)
    //          OnTime (0)
    //          Unknown (-3)      
    
    
    
  • Sie können die GetValues-Methode aufrufen, um ein Array abzurufen, das die zugrunde liegenden Werte in der Enumeration enthält. Danach können Sie für jedes Element des Arrays die ToObject-Methode aufrufen, um die ganze Zahl in ihren entsprechenden Enumerationswert zu konvertieren. Dieser Ansatz wird anhand des folgenden Beispiels veranschaulicht.

    
    var values = Enum.GetValues(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    foreach (var value in values) {
       ArrivalStatus status = (ArrivalStatus) Enum.ToObject(typeof(ArrivalStatus), value);
       Console.WriteLine("   {0} ({0:D})", status);
    }                                       
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          OnTime (0)
    //          Early (1)
    //          Unknown (-3)
    //          Late (-1)
    
    
    

Nicht ausschließliche Member und das Flags-Attribut

Eine allgemeine Verwendung einer Enumeration ist, einen Satz sich gegenseitig ausschließender Werte darzustellen. Eine ArrivalStatus-Instanz kann z. B. über den Wert Early, OnTime oder Late verfügen. Es ergibt keinen Sinn für den Wert einer ArrivalStatus-Instanz, mehr als eine Enumerationskonstante zu reflektieren.

In anderen Fällen jedoch kann der Wert eines Enumerationsobjekts mehrere Enumerationsmember enthalten, und jeder Member vertritt ein Bitfeld im Enumerationswert. Das FlagsAttribute-Attribut kann verwendet werden, um anzugeben, dass die Enumeration aus Bitfeldern besteht. Eine Enumeration mit dem Namen Pets könnte z. B. verwendet werden, um die Arten von Haustieren in einem Haushalt anzugeben. Folgende Definition ist möglich.


[Flags] public enum Pets { None=0, Dog=1, Cat=2, Bird=4, Rodent=8,
                           Reptile=16, Other=32 };



Die Pets-Enumeration kann dann verwendet werden, wie im folgenden Beispiel gezeigt.


Pets familyPets = Pets.Dog | Pets.Cat;
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets);
// The example displays the following output:
//       Pets: Dog, Cat (3)      


Die folgenden Best Practices sollten verwendet werden, wenn Sie eine bitweise Enumeration definieren und das FlagsAttribute-Attribut übernehmen.

  • Verwenden Sie das benutzerdefinierte FlagsAttribute-Attribut nur dann für eine Enumeration, wenn eine bitweise Operation (AND, OR, EXCLUSIVE OR) mit einem numerischen Werte ausgeführt werden soll.

  • Definieren Sie Enumerationskonstanten in Potenzen von zwei, d. h., 1, 2, 4, 8 usw. Dies bedeutet, dass sich die einzelnen Flags in kombinierten Enumerationskonstanten nicht überschneiden.

  • Sie sollten eine Enumerationskonstante für häufig verwendete Flagkombinationen erstellen. Wenn Sie z. B. über eine Enumeration für Datei-E/A-Vorgänge verwenden, die die Enumerationskonstanten Read = 1 und Write = 2 enthält, sollten Sie die Enumerationskonstante ReadWrite = Read OR Write erstellen, die das Read-Flag und das Write-Flag zusammenfasst. Außerdem könnte der zum Kombinieren der Flags verwendete bitweise OR-Vorgang in bestimmten Situationen als erweitertes Konzept angesehen werden, in denen einfache Aufgaben ausgeführt werden sollten.

  • Seien Sie beim Definieren negativer Zahlen als Flagenumerationskonstanten umsichtig, da viele Flagpositionen auf 1 festgelegt werden, wodurch der Code verwirren und Codierungsfehler verursachen könnte.

  • Eine zweckmäßige Möglichkeit, zu testen, ob ein Flag in einem numerischen Wert festgelegt wird, besteht im Aufrufen der HasFlag-Instanzmethode, wie im folgenden Beispiel gezeigt.

    
    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets.HasFlag(Pets.Dog))
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.      
    
    
    

    Dies entspricht der Ausführung eines bitweisen AND-Vorgangs zwischen dem numerischen Wert und der Flagenumerationskonstante, bei dem alle Bits der numerischen Werte, die nicht dem Flag entsprechen, auf 0 (null) festgelegt werden, und dem anschließenden Test, ob das Ergebnis des Vorgangs gleich der Flagenumerationskonstante ist. Dies ist im folgenden Codebeispiel gezeigt.

    
    Pets familyPets = Pets.Dog | Pets.Cat;
    if ((familyPets & Pets.Dog) == Pets.Dog)
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.      
    
    
    
  • Verwenden Sie als Namen der Flagenumerationskonstante None, dessen Wert 0 (null) ist. Sie können die None-Enumerationskonstante nicht in einem bitweisen AND-Vorgang zum Testen eines Flags verwenden, da das Ergebnis immer 0 (null) ist. Sie können aber einen logischen (nicht bitweisen) Vergleich des numerischen Werts und der None-Enumerationskonstante durchführen, um zu bestimmen, ob in dem numerischen Wert Bits festgelegt wurden. Dies ist im folgenden Codebeispiel gezeigt.

    
    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets == Pets.None)
       Console.WriteLine("The family has no pets.");
    else
       Console.WriteLine("The family has pets.");   
    // The example displays the following output:
    //       The family has pets.      
    
    
    
  • Definieren Sie keinen Enumerationswert, um ausschließlich den Zustand der Enumeration selbst darzustellen. Definieren Sie beispielsweise keine Enumerationskonstante, die lediglich das Ende der Enumeration kennzeichnet. Wenn Sie den letzten Wert der Enumeration bestimmen müssen, überprüfen Sie diesen Wert explizit. Sie können des Weiteren eine Bereichsprüfung für die erste und letzte Enumerationskonstante durchführen, wenn alle Werte in dem Bereich gültig sind.

Im folgenden Beispiel wird die Verwendung einer Enumeration zur Darstellung benannter Werte sowie einer weiteren Enumeration zur Darstellung benannter Bitfelder veranschaulicht.


using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [FlagsAttribute]
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static void Main() {

        Type weekdays = typeof(Days);
        Type boiling = typeof(BoilingPoints);

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:");

        foreach ( string s in Enum.GetNames(weekdays) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format( weekdays, Enum.Parse(weekdays, s), "d"));

        Console.WriteLine();
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.");
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:");

        foreach ( string s in Enum.GetNames(boiling) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format(boiling, Enum.Parse(boiling, s), "d"));

        Colors myColors = Colors.Red | Colors.Blue | Colors.Yellow;
        Console.WriteLine();
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors);
    }
}


.NET Framework

Unterstützt in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

Es werden nicht alle Versionen sämtlicher Plattformen von .NET Framework unterstützt.. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Dieser Typ ist threadsicher.

Community-Beiträge

HINZUFÜGEN
Microsoft führt eine Onlineumfrage durch, um Ihre Meinung zur MSDN-Website zu erfahren. Wenn Sie sich zur Teilnahme entscheiden, wird Ihnen die Onlineumfrage angezeigt, sobald Sie die MSDN-Website verlassen.

Möchten Sie an der Umfrage teilnehmen?
Anzeigen:
© 2014 Microsoft. Alle Rechte vorbehalten.