Enum Klasse

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt die Basisklasse für Enumerationen bereit.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable

public ref class Enum abstract : ValueType, IComparable, IConvertible, ISpanFormattable

public ref class Enum abstract : ValueType, IComparable, IFormattable

public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable

public abstract class Enum : ValueType, IComparable, IConvertible, ISpanFormattable

[System.Serializable]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable

public abstract class Enum : ValueType, IComparable, IFormattable

type Enum = class
    inherit ValueType
    interface IComparable
    interface IConvertible
    interface IFormattable

type Enum = class
    inherit ValueType
    interface IComparable
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

[<System.Serializable>]
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible

type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable

Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, IFormattable

Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, ISpanFormattable

Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IFormattable

Vererbung: Object

ValueType
Enum

Abgeleitet: Accessibility.AnnoScope

Microsoft.Aspnet.Snapin.MMC_CONTROL_TYPE

Microsoft.CSharp.ErrorLevel

Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags

Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags

Mehr …

Attribute: SerializableAttribute ComVisibleAttribute

Implementiert: IComparable IConvertible IFormattable ISpanFormattable

Beispiele

Im folgenden Beispiel wird die Verwendung einer -Enumeration zum Darstellen benannter Werte und einer anderen Enumeration zur Darstellung benannter Bitfelder veranschaulicht.

using namespace System;
enum class Days
{
   Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday
};

enum class BoilingPoints
{
   Celsius = 100,
   Fahrenheit = 212
};

[Flags]

enum class Colors
{
   Red = 1,
   Green = 2,
   Blue = 4,
   Yellow = 8
};

int main()
{
   Type^ weekdays = Days::typeid;
   Type^ boiling = BoilingPoints::typeid;
   Console::WriteLine(  "The days of the week, and their corresponding values in the Days Enum are:" );
   Array^ a = Enum::GetNames( weekdays );
   Int32 i = 0;
   do
   {
      Object^ o = a->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( weekdays, Enum::Parse( weekdays, o->ToString() ),  "d" ) );
   }
   while ( ++i < a->Length );

   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:" );
   i = 0;
   Array^ b = Enum::GetNames( boiling );
   do
   {
      Object^ o = b->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( boiling, Enum::Parse( boiling, o->ToString() ),  "d" ) );
   }
   while ( ++i < b->Length );

   Array^ c = Enum::GetNames( Colors::typeid );
   Colors myColors = Colors::Red | Colors::Blue | Colors::Yellow;
   Console::WriteLine();
   Console::Write(  "myColors holds a combination of colors. Namely:" );
   for ( i = 0; i < 3; i++ )
      Console::Write(  " {0}", c->GetValue( i ) );
}

using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [Flags]
    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);
    }
}

open System

type Days =
    | Saturday = 0
    | Sunday = 1
    | Monday = 2
    | Tuesday = 3
    | Wednesday = 4
    | Thursday = 5
    | Friday = 6

type BoilingPoints =
    | Celsius = 100
    | Fahrenheit = 212

[<Flags>]
type Colors =
    | Red = 1
    | Green = 2
    | Blue = 4
    | Yellow = 8

let weekdays = typeof<Days>
let boiling = typeof<BoilingPoints>

printfn "The days of the week, and their corresponding values in the Days Enum are:"

for s in Enum.GetNames weekdays do
    printfn $"""{s,-11}= {Enum.Format(weekdays, Enum.Parse(weekdays, s), "d")}"""

printfn "\nEnums can also be created which have values that represent some meaningful amount."
printfn "The BoilingPoints Enum defines the following items, and corresponding values:"

for s in Enum.GetNames boiling do
    printfn $"""{s,-11}= {Enum.Format(boiling, Enum.Parse(boiling, s), "d")}"""

let myColors = Colors.Red ||| Colors.Blue ||| Colors.Yellow
printfn $"\nmyColors holds a combination of colors. Namely: {myColors}"

Public Class EnumTest
    Enum Days
        Saturday
        Sunday
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
    End Enum 
    
    Enum BoilingPoints
        Celsius = 100
        Fahrenheit = 212
    End Enum 
    
    <Flags()> _
    Enum Colors
        Red = 1
        Green = 2
        Blue = 4
        Yellow = 8
    End Enum 

    Public Shared Sub Main()
        Dim weekdays As Type = GetType(Days)
        Dim boiling As Type = GetType(BoilingPoints)

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

        Dim s As String
        For Each s In  [Enum].GetNames(weekdays)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(weekdays, [Enum].Parse(weekdays, s), "d"))
        
        Next s
        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:")

        For Each s In  [Enum].GetNames(boiling)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(boiling, [Enum].Parse(boiling, s), "d"))
        Next s

        Dim myColors As Colors = Colors.Red Or Colors.Blue Or Colors.Yellow
        Console.WriteLine()
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors)
    End Sub 
End Class

Hinweise

Eine Enumeration ist ein Satz benannter Konstanten, deren zugrunde liegender Typ ein integraler Typ ist. Wenn kein zugrunde liegender Typ explizit deklariert wird, Int32 wird verwendet. Enumist die Basisklasse für alle Enumerationen im .NET Framework. Enumerationstypen werden durch die enum Schlüsselwort (keyword) in C#, das Enum...End Enum-Konstrukt in Visual Basic und die type Schlüsselwort (keyword) in F# definiert.

Enumstellt Methoden zum Vergleichen von Instanzen dieser Klasse bereit, konvertiert den Wert eines instance in seine Zeichenfolgendarstellung, konvertiert die Zeichenfolgendarstellung einer Zahl in eine instance dieser Klasse und erstellt eine instance einer angegebenen Enumeration und eines angegebenen Werts.

Sie können eine Enumeration auch als Bitfeld behandeln. Weitere Informationen finden Sie im Abschnitt Nicht exklusive Member und flags Attribute und im FlagsAttribute Thema.

In diesem Thema:

Erstellen eines Enumerationstyps Instanziieren eines Enumerationstyps Enumeration Bewährte Methoden Ausführen von Vorgängen mit Enumerationen Durchführen von Konvertierungen Analysieren von Enumerationswerten Formatierung von Enumerationswerten Iterieren von Enumerationselementen Nicht exklusive Member und das Flags-Attribut Hinzufügen von Enumerationsmethoden

Erstellen eines Enumerationstyps

Programmiersprachen stellen in der Regel Syntax bereit, um eine Enumeration zu deklarieren, die aus einem Satz benannter Konstanten und deren Werten besteht. Das folgende Beispiel veranschaulicht die Syntax, die von C#, F# und Visual Basic zum Definieren einer Enumeration verwendet wird. Es wird eine Enumeration mit dem Namen erstellt ArrivalStatus , die über drei Member verfügt: ArrivalStatus.Early, ArrivalStatus.OnTimeund ArrivalStatus.Late. Beachten Sie, dass die Enumeration in allen Fällen nicht explizit von Enumerbt. Die Vererbungsbeziehung wird implizit vom Compiler behandelt.

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

type ArrivalStatus =
    | Late = -1
    | OnTime = 0
    | Early = 1

Public Enum ArrivalStatus As Integer
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Warnung

Sie sollten niemals einen Enumerationstyp erstellen, dessen zugrunde liegender Typ nicht integral oder ist Char. Obwohl Sie einen solchen Enumerationstyp mithilfe von Reflektion erstellen können, sind Methodenaufrufe, die den resultierenden Typ verwenden, unzuverlässig und können auch zusätzliche Ausnahmen auslösen.

Instanziieren eines Enumerationstyps

Sie können einen Enumerationstyp so instanziieren, wie Sie einen beliebigen anderen Werttyp instanziieren: indem Sie eine Variable deklarieren und ihr eine der Konstanten der Enumeration zuweisen. Im folgenden Beispiel wird ein ArrivalStatus instanziiert, dessen Wert ist ArrivalStatus.OnTime.

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)

let status = ArrivalStatus.OnTime
printfn $"Arrival Status: {status} ({status:D})"
// The example displays the following output:
//       Arrival Status: OnTime (0)

Public Module Example
   Public Sub Main()
      Dim status As ArrivalStatus = ArrivalStatus.OnTime
      Console.WriteLine("Arrival Status: {0} ({0:D})", status)
   End Sub
End Module
' The example displays the following output:
'        Arrival Status: OnTime (0)

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

Indem Sie die Features einer bestimmten Programmiersprache verwenden, um (wie in C#) oder (wie in Visual Basic) einen ganzzahligen Wert in einen Enumerationswert zu konvertieren. Im folgenden Beispiel wird ein ArrivalStatus Objekt erstellt, dessen Wert auf diese Weise lautet ArrivalStatus.Early .

ArrivalStatus status2 = (ArrivalStatus) 1;
Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
// The example displays the following output:
//       Arrival Status: Early (1)

let status2 = enum<ArrivalStatus> 1
printfn $"Arrival Status: {status2} ({status2:D})"
// The example displays the following output:
//       Arrival Status: Early (1)

Dim status2 As ArrivalStatus = CType(1, ArrivalStatus)
Console.WriteLine("Arrival Status: {0} ({0:D})", status2)
' The example displays the following output:
'       Arrival Status: Early (1)

Durch Aufrufen des impliziten parameterlosen Konstruktors. Wie das folgende Beispiel zeigt, ist in diesem Fall der zugrunde liegende Wert der Enumeration instance 0. Dies ist jedoch nicht unbedingt 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)

let status1 = ArrivalStatus()
printfn $"Arrival Status: {status1} ({status1:D})"
// The example displays the following output:
//       Arrival Status: OnTime (0)

Dim status1 As New ArrivalStatus()
Console.WriteLine("Arrival Status: {0} ({0:D})", status1)
' The example displays the following output:
'        Arrival Status: OnTime (0)

Indem Sie die Parse -Methode oder TryParse aufrufen, um eine Zeichenfolge zu analysieren, die den Namen einer Konstanten in der Enumeration enthält. Weitere Informationen finden Sie im Abschnitt Analyse von Enumerationswerten .
Indem Sie die ToObject -Methode aufrufen, um einen integralen Wert in einen Enumerationstyp zu konvertieren. Weitere Informationen finden Sie im Abschnitt Ausführen von Konvertierungen .

Bewährte Methoden für Enumerationen

Es wird empfohlen, die folgenden bewährten Methoden zu verwenden, wenn Sie Enumerationstypen definieren:

Wenn Sie keinen Enumerationsmember definiert haben, dessen Wert 0 ist, sollten Sie eine None aufgezählte Konstante erstellen. Standardmäßig wird der für die Enumeration verwendete Arbeitsspeicher von der Common Language Runtime auf Null initialisiert. Wenn Sie also keine Konstante definieren, deren Wert 0 ist, enthält die Enumeration beim Erstellen einen ungültigen Wert.
Wenn es einen offensichtlichen Standardfall gibt, den Ihre Anwendung darstellen muss, sollten Sie eine aufgezählte Konstante verwenden, deren Wert 0 ist, um sie darzustellen. Wenn kein Standardfall vorhanden ist, sollten Sie eine enumerierte Konstante verwenden, deren Wert 0 ist, um die Groß- und Kleinschreibung anzugeben, die nicht durch eine der anderen aufgezählten Konstanten dargestellt wird.
Geben Sie keine aufgezählten Konstanten an, die für die zukünftige Verwendung reserviert sind.
Wenn Sie eine Methode oder Eigenschaft definieren, die eine aufgezählte Konstante als Wert akzeptiert, sollten Sie den Wert überprüfen. Der Grund ist, dass Sie einen numerischen Wert in den Enumerationstyp umwandeln können, auch wenn dieser numerische Wert in der Enumeration nicht definiert ist.

Weitere bewährte Methoden für Enumerationstypen, deren Konstanten Bitfelder sind, werden im Abschnitt Nicht exklusive Elemente und Flags-Attribut aufgeführt.

Ausführen von Vorgängen mit Enumerationen

Sie können keine neuen Methoden definieren, wenn Sie eine Enumeration erstellen. Ein Enumerationstyp erbt jedoch einen vollständigen Satz statischer und instance Methoden von der Enum -Klasse. In den folgenden Abschnitten werden die meisten dieser Methoden sowie mehrere andere Methoden untersucht, die häufig bei der Arbeit mit Enumerationswerten verwendet werden.

Ausführen von Konvertierungen

Sie können zwischen einem Enumerationsmember und dem zugrunde liegenden Typ konvertieren, indem Sie einen Umwandlungsoperator (in C# und F#) oder einen Konvertierungsoperator (in Visual Basic) verwenden. In F# wird die enum Funktion auch verwendet. Im folgenden Beispiel werden Umwandlungs- oder Konvertierungsoperatoren verwendet, um Konvertierungen von einer ganzen Zahl in einen Enumerationswert und von einem Enumerationswert in eine ganze Zahl durchzuführen.

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

int value4 = (int) status3;

let value3 = 2
let status3 = enum<ArrivalStatus> value3

let value4 = int status3

Dim value3 As Integer = 2
Dim status3 As ArrivalStatus = CType(value3, ArrivalStatus)

Dim value4 As Integer = CInt(status3)

Die Enum -Klasse enthält auch eine ToObject -Methode, die einen Wert eines beliebigen integralen Typs in einen Enumerationswert konvertiert. Im folgenden Beispiel wird die ToObject(Type, Int32) -Methode verwendet, um einen Int32 in einen ArrivalStatus Wert zu konvertieren. Beachten Sie, dass, da der ToObject einen Wert vom Typ Objectzurückgibt, möglicherweise die Verwendung eines Umwandlungs- oder Konvertierungsoperators erforderlich ist, um das Objekt in den Enumerationstyp zu umwandeln.

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

let number = -1
let arrived = ArrivalStatus.ToObject(typeof<ArrivalStatus>, number) :?> ArrivalStatus

Dim number As Integer = -1
Dim arrived As ArrivalStatus = CType(ArrivalStatus.ToObject(GetType(ArrivalStatus), number), ArrivalStatus)

Beim Konvertieren einer ganzen Zahl in einen Enumerationswert ist es möglich, einen Wert zuzuweisen, der kein Element der Enumeration ist. Um dies zu verhindern, können Sie die ganze Zahl an die IsDefined -Methode übergeben, bevor Sie die Konvertierung ausführen. Im folgenden Beispiel wird diese Methode verwendet, um zu bestimmen, ob die Elemente in einem Array von ganzzahligen Werten 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

open System

type ArrivalStatus =
    | Unknown = -3
    | Late = -1
    | OnTime = 0
    | Early = 1

let values = [ -3; -1; 0; 1; 5; Int32.MaxValue ]
for value in values do
    let status =
        if Enum.IsDefined(typeof<ArrivalStatus>, value) then
            enum value
        else
            ArrivalStatus.Unknown
    printfn $"Converted {value:N0} to {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

Public Enum ArrivalStatus As Integer
   Unknown = -3
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Module Example
   Public Sub Main()
      Dim values() As Integer = { -3, -1, 0, 1, 5, Int32.MaxValue }
      For Each value In values
         Dim status As ArrivalStatus
         If [Enum].IsDefined(GetType(ArrivalStatus), value)
            status = CType(value, ArrivalStatus) 
         Else
            status = ArrivalStatus.Unknown
         End If
         Console.WriteLine("Converted {0:N0} to {1}", value, status)
      Next   
   End Sub
End Module
' 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 integralen Typ bereitstellt, sollten Sie die Methoden der Convert -Klasse verwenden, z ToInt32. B. , um diese Konvertierungen durchzuführen. Das folgende Beispiel veranschaulicht, wie Sie die -Methode zusammen mit der GetUnderlyingType Convert.ChangeType -Methode verwenden können, um einen Enumerationswert in den zugrunde liegenden Typ zu konvertieren. Beachten Sie, dass für dieses 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

let status = ArrivalStatus.Early
let number = Convert.ChangeType(status, Enum.GetUnderlyingType typeof<ArrivalStatus>)
printfn $"Converted {status} to {number}"
// The example displays the following output:
//       Converted Early to 1

Dim status As ArrivalStatus = ArrivalStatus.Early
Dim number = Convert.ChangeType(status, [Enum].GetUnderlyingType(GetType(ArrivalStatus)))
Console.WriteLine("Converted {0} to {1}", status, number)
' The example displays the following output:
'       Converted Early to 1

Analysieren von Enumerationswerten

Mit Parse den Methoden und TryParse 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 erfolgreich Zeichenfolgendarstellungen von Zahlen konvertieren, die keine Member einer bestimmten Enumeration sind, wenn die Zeichenfolgen in einen Wert des zugrunde liegenden Enumerationstyps 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. Das Beispiel veranschaulicht diesen Ansatz und zeigt Aufrufe der -Methode und Enum.TryParse<TEnum>(String, TEnum) der Parse(Type, String) -Methode. Beachten Sie, dass die nicht generische Analysemethode ein Objekt zurückgibt, das Sie möglicherweise (in C# und F#) umwandeln oder (in Visual Basic) in den entsprechenden Enumerationstyp konvertieren 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

let number = "-1"
let name = "Early"

try
    let status1 = Enum.Parse(typeof<ArrivalStatus>, number) :?> ArrivalStatus
    let status1 =
        if not (Enum.IsDefined(typeof<ArrivalStatus>, status1) ) then
            ArrivalStatus.Unknown
        else 
            status1
        
    printfn $"Converted '{number}' to {status1}"
with :? FormatException ->
    printfn $"Unable to convert '{number}' to an ArrivalStatus value."

match Enum.TryParse<ArrivalStatus> name with
| true, status2 ->
    let status2 = 
        if not (Enum.IsDefined(typeof<ArrivalStatus>, status2) ) then
            ArrivalStatus.Unknown
        else 
            status2
    printfn $"Converted '{name}' to {status2}"
| _ ->
    printfn $"Unable to convert '{number}' to an ArrivalStatus value."
// The example displays the following output:
//       Converted '-1' to Late
//       Converted 'Early' to Early

Dim number As String = "-1"
Dim name As String = "Early"
Dim invalid As String = "32"

Try 
   Dim status1 As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), number), ArrivalStatus)
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status1) Then status1 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", number, status1)
Catch e As FormatException
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End Try   
   
Dim status2 As ArrivalStatus
If [Enum].TryParse(Of ArrivalStatus)(name, status2) Then
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status2) Then status2 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", name, status2)
Else
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End If
' The example displays the following output:
'       Converted '-1' to Late
'       Converted 'Early' to Early

Formatieren von Enumerationswerten

Sie können Enumerationswerte in ihre Zeichenfolgendarstellungen konvertieren, indem Sie die statische Format Methode sowie die Überladungen der instance-Methode ToString aufrufen. Sie können eine Formatzeichenfolge verwenden, um die genaue Darstellung eines Enumerationswerts als Zeichenfolge zu steuern. Weitere Informationen finden Sie unter Enumerationsformatzeichenfolgen. Im folgenden Beispiel werden alle unterstützten Enumerationsformatzeichenfolgen ("G" oder "g", "D" oder "d", "X" oder "x" und "F" oder "f" ) verwendet, um ein Element der ArrivalStatus Enumeration in ihre Zeichenfolgendarstellungen zu konvertieren.

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

let formats = [ "G"; "F"; "D"; "X" ]
let status = ArrivalStatus.Late
for fmt in formats do
    printfn $"{status.ToString fmt}"

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

Dim formats() As String = { "G", "F", "D", "X"}
Dim status As ArrivalStatus = ArrivalStatus.Late
For Each fmt As String In formats
   Console.WriteLine(status.ToString(fmt))
Next
' The example displays the following output:
'       Late
'       Late
'       -1
'       FFFFFFFF

Iterierende Enumerationsmber

Der Enum Typ implementiert IEnumerable die -Schnittstelle oder IEnumerable<T> nicht, wodurch Sie Elemente einer Auflistung mithilfe eines foreach (in C#), for..in (in F#) oder For Each (in Visual Basic) Konstrukts durchlaufen können. Sie können Elemente jedoch auf zwei Arten auflisten.

Sie können die GetNames -Methode aufrufen, um ein Zeichenfolgenarray abzurufen, das die Namen der Enumerationsmember enthält. Als Nächstes können Sie für jedes Element des Zeichenfolgenarrays die Parse -Methode aufrufen, um die Zeichenfolge in den 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)

let names = Enum.GetNames typeof<ArrivalStatus>
printfn $"Members of {nameof ArrivalStatus}:"
let names = Array.sort names
for name in names do
    let status = Enum.Parse(typeof<ArrivalStatus>, name) :?> ArrivalStatus
    printfn $"   {status} ({status:D})"
// The example displays the following output:
//       Members of ArrivalStatus:
//          Early (1)
//          Late (-1)
//          OnTime (0)
//          Unknown (-3)

Dim names() As String = [Enum].GetNames(GetType(ArrivalStatus))
Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
Array.Sort(names)
For Each name In names
   Dim status As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), name),
                                 ArrivalStatus)
   Console.WriteLine("   {0} ({0:D})", status)
Next
' 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. Als Nächstes können Sie für jedes Element des Arrays die -Methode aufrufen, um die ToObject ganze Zahl in den 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 (ArrivalStatus status in values) {
   Console.WriteLine("   {0} ({0:D})", status);
}
// The example displays the following output:
//       Members of ArrivalStatus:
//          OnTime (0)
//          Early (1)
//          Unknown (-3)
//          Late (-1)

let values = Enum.GetValues typeof<ArrivalStatus>
printfn $"Members of {nameof ArrivalStatus}:"
for status in values do
    printfn $"   {status} ({status:D})"
// The example displays the following output:
//       Members of ArrivalStatus:
//          OnTime (0)
//          Early (1)
//          Unknown (-3)
//          Late (-1)

Dim values = [Enum].GetValues(GetType(ArrivalStatus))
Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
For Each value In values
   Dim status As ArrivalStatus = CType([Enum].ToObject(GetType(ArrivalStatus), value),
                                       ArrivalStatus)
   Console.WriteLine("   {0} ({0:D})", status)
Next                                       
' The example displays the following output:
'       Members of ArrivalStatus:
'          OnTime (0)
'          Early (1)
'          Unknown (-3)
'          Late (-1)

Nicht exklusive Mitglieder und das Flags-Attribut

Eine häufige Verwendung einer Enumeration besteht darin, einen Satz von Werten darzustellen, die sich gegenseitig ausschließen. Ein ArrivalStatus instance kann beispielsweise den Wert Early, OnTimeoder Lateaufweisen. Es ist nicht sinnvoll, dass der Wert einer ArrivalStatus instance mehr als eine Enumerationskonstante widerspiegelt.

In anderen Fällen kann der Wert eines Enumerationsobjekts jedoch mehrere Enumerationsmember enthalten, und jedes Element stellt ein Bitfeld im Enumerationswert dar. Das FlagsAttribute Attribut kann verwendet werden, um anzugeben, dass die Enumeration aus Bitfeldern besteht. Beispielsweise kann eine Enumeration namens Pets verwendet werden, um die Arten von Haustieren in einem Haushalt anzugeben. Sie kann wie folgt definiert werden.

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

[<Flags>] 
type Pets =
    | None = 0
    | Dog = 1
    | Cat = 2
    | Bird = 4
    | Rodent = 8
    | Reptile = 16
    | Other = 32

<Flags> Public Enum Pets As Integer
   None = 0
   Dog = 1
   Cat = 2
   Bird = 4
   Rodent = 8
   Reptile = 16
   Other = 32
End Enum

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

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

let familyPets = Pets.Dog ||| Pets.Cat
printfn $"Pets: {familyPets:G} ({familyPets:D})"
// The example displays the following output:
//       Pets: Dog, Cat (3)

Dim familyPets As Pets = Pets.Dog Or Pets.Cat
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets)
' The example displays the following output:
'       Pets: Dog, Cat (3)

Die folgenden bewährten Methoden sollten verwendet werden, wenn Sie eine bitweise Enumeration definieren und das FlagsAttribute Attribut anwenden.

Verwenden Sie das FlagsAttribute benutzerdefinierte Attribut nur für eine Enumeration, wenn ein bitweiser Vorgang (AND, OR, EXCLUSIVE OR) für einen numerischen Wert ausgeführt werden soll.
Definieren Sie Enumerationskonstanten in Mächten von zwei, d. h. 1, 2, 4, 8 usw. Dies bedeutet, dass sich die einzelnen Flags in kombinierten Enumerationskonstanten nicht überlappen.
Erwägen Sie, eine aufgezählte Konstante für häufig verwendete Flagkombinationen zu erstellen. Wenn Sie beispielsweise über eine Enumeration verfügen, die für Datei-E/A-Vorgänge verwendet wird, die die aufgezählten Konstanten Read = 1 und Write = 2enthält, sollten Sie die Aufzählungskonstante ReadWrite = Read OR Writeerstellen, die die Read Flags und Write kombiniert. Darüber hinaus kann der bitweise OR-Vorgang, der zum Kombinieren der Flags verwendet wird, unter bestimmten Umständen als erweitertes Konzept angesehen werden, das für einfache Aufgaben nicht erforderlich sein sollte.
Seien Sie vorsichtig, wenn Sie eine negative Zahl als aufgezählte Flagkonstante definieren, da viele Flagpositionen möglicherweise auf 1 festgelegt werden, was Ihren Code verwirrend machen und Codierungsfehler fördern kann.

Eine praktische Möglichkeit zum Testen, ob ein Flag in einem numerischen Wert festgelegt ist, besteht darin, die instance-Methode HasFlag aufzurufen, 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.

let familyPets = Pets.Dog ||| Pets.Cat
if familyPets.HasFlag Pets.Dog then
    printfn "The family has a dog."
// The example displays the following output:
//       The family has a dog.

Dim familyPets As Pets = Pets.Dog Or Pets.Cat
If familyPets.HasFlag(Pets.Dog) Then
   Console.WriteLine("The family has a dog.")
End If
' The example displays the following output:
'       The family has a dog.

Es entspricht einer bitweisen AND-Operation zwischen dem numerischen Wert und der flag enumerierten Konstanten, die alle Bits im numerischen Wert auf 0 festgelegt, die nicht dem Flag entsprechen, und dann zu testen, ob das Ergebnis dieses Vorgangs der aufgezählten Flagkonstante entspricht. Dies wird im folgenden Beispiel illustriert.

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.

let familyPets = Pets.Dog ||| Pets.Cat
if (familyPets &&& Pets.Dog) = Pets.Dog then
    printfn "The family has a dog."
// The example displays the following output:
//       The family has a dog.

Dim familyPets As Pets = Pets.Dog Or Pets.Cat
If familyPets And Pets.Dog = Pets.Dog Then
   Console.WriteLine("The family has a dog.")
End If   
' The example displays the following output:
'       The family has a dog.

Verwenden Sie None als Name der aufgezählten Flagkonstante, deren Wert 0 ist. Sie können die None aufgezählte Konstante in einem bitweisen AND-Vorgang nicht verwenden, um auf ein Flag zu testen, da das Ergebnis immer 0 ist. Sie können jedoch einen logischen, nicht bitweisen Vergleich zwischen dem numerischen Wert und der None aufgezählten Konstanten durchführen, um zu bestimmen, ob Bits im numerischen Wert festgelegt sind. Dies wird im folgenden Beispiel illustriert.

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.

let familyPets = Pets.Dog ||| Pets.Cat
if familyPets = Pets.None then
    printfn "The family has no pets."
else
    printfn "The family has pets."
// The example displays the following output:
//       The family has pets.

Dim familyPets As Pets = Pets.Dog Or Pets.Cat
If familyPets = Pets.None Then
   Console.WriteLine("The family has no pets.")
Else
   Console.WriteLine("The family has pets.")   
End If
' The example displays the following output:
'       The family has pets.

Definieren Sie einen Enumerationswert nicht nur, um den Zustand der Enumeration selbst zu Spiegel. Definieren Sie beispielsweise keine aufgezählte Konstante, die lediglich das Ende der Enumeration markiert. Wenn Sie den letzten Wert der Enumeration ermitteln müssen, suchen Sie explizit nach diesem Wert. Darüber hinaus können Sie eine Bereichsprüfung für die erste und letzte aufgezählte Konstante durchführen, wenn alle Werte innerhalb des Bereichs gültig sind.

Hinzufügen von Enumerationsmethoden

Da Enumerationstypen durch Sprachstrukturen wie enum (C#) und Enum (Visual Basic) definiert werden, können Sie keine benutzerdefinierten Methoden für einen anderen Enumerationstyp als die von der Enum -Klasse geerbten Methoden definieren. Sie können jedoch Erweiterungsmethoden verwenden, um einem bestimmten Enumerationstyp Funktionalität hinzuzufügen.

Im folgenden Beispiel stellt die Grades-Enumeration die möglichen Noten in Buchstaben dar, die ein Schüler im Unterricht erhalten kann. Eine Erweiterungsmethode mit dem Namen Passing wird dem Grades-Typ hinzugefügt, sodass jede Instanz dieses Typs nun „weiß“, ob sie eine Note darstellt, mit der der Schüler bestanden hat. Die Extensions -Klasse enthält auch eine statische Lese-/Schreibvariable, die die Mindesthaltbarkeit definiert. Der Rückgabewert der Passing Erweiterungsmethode spiegelt den aktuellen Wert dieser Variablen wider.

using System;

// Define an enumeration to represent student grades.
public enum Grades { F = 0, D = 1, C = 2, B = 3, A = 4 };

// Define an extension method for the Grades enumeration.
public static class Extensions
{
  public static Grades minPassing = Grades.D;

  public static bool Passing(this Grades grade)
  {
      return grade >= minPassing;
  }
}

class Example
{
  static void Main()
  {
      Grades g1 = Grades.D;
      Grades g2 = Grades.F;
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");

      Extensions.minPassing = Grades.C;
      Console.WriteLine("\nRaising the bar!\n");
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");
  }
}
// The exmaple displays the following output:
//       D is a passing grade.
//       F is not a passing grade.
//
//       Raising the bar!
//
//       D is not a passing grade.
//       F is not a passing grade.

open System
open System.Runtime.CompilerServices
// Define an enumeration to represent student grades.
type Grades =
    | F = 0
    | D = 1
    | C = 2
    | B = 3
    | A = 4

let mutable minPassing = Grades.D

// Define an extension method for the Grades enumeration.
[<Extension>]
type Extensions =
    [<Extension>]
    static member Passing(grade) = grade >= minPassing

let g1 = Grades.D
let g2 = Grades.F
printfn $"""{g1} {if g1.Passing() then "is" else "is not"} a passing grade."""
printfn $"""{g2} {if g2.Passing() then "is" else "is not"} a passing grade."""

minPassing <- Grades.C
printfn "\nRaising the bar!\n"
printfn $"""{g1} {if g1.Passing() then "is" else "is not"} a passing grade."""
printfn $"""{g2} {if g2.Passing() then "is" else "is not"} a passing grade."""
// The exmaple displays the following output:
//       D is a passing grade.
//       F is not a passing grade.
//
//       Raising the bar!
//
//       D is not a passing grade.
//       F is not a passing grade.

Imports System.Runtime.CompilerServices

' Define an enumeration to represent student grades.
Public Enum Grades As Integer
   F = 0
   D = 1
   C = 2
   B = 3
   A = 4
End Enum   

' Define an extension method for the Grades enumeration.
Public Module Extensions
  Public minPassing As Grades = Grades.D
 
  <Extension>
  Public Function Passing(grade As Grades) As Boolean
     Return grade >= minPassing
  End Function
End Module

Public Module Example
  Public Sub Main()
      Dim g1 As Grades = Grades.D
      Dim g2 As Grades = Grades.F
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
      Console.WriteLine()
      
      Extensions.minPassing = Grades.C
      Console.WriteLine("Raising the bar!")
      Console.WriteLine()
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
  End Sub
End Module
' The exmaple displays the following output:
'       D is a passing grade.
'       F is not a passing grade.
'       
'       Raising the bar!
'       
'       D is not a passing grade.
'       F is not a passing grade.

Konstruktoren

Enum()

Initialisiert eine neue Instanz der Enum-Klasse.

Methoden

CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.
Format(Type, Object, String)	Konvertiert den angegebenen Wert eines angegebenen Enumerationstyps unter Berücksichtigung des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.
GetHashCode()	Gibt den Hashcode für den Wert dieser Instanz zurück.
GetName(Type, Object)	Ruft den Namen der Konstanten der angegebenen Enumeration mit dem angegebenen Wert ab.
GetName<TEnum>(TEnum)	Ruft den Namen der Konstanten im angegebenen Enumerationstyp mit dem angegebenen Wert ab.
GetNames(Type)	Ruft ein Array mit den Namen der Konstanten einer angegebenen Enumeration ab.
GetNames<TEnum>()	Ruft ein Array mit den Namen der Konstanten in eines angegebenen Enumerationstyps ab.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
GetTypeCode()	Gibt den Typcode des zugrunde liegenden Typs dieses Enumerationsmembers zurück.
GetUnderlyingType(Type)	Gibt den zugrunde liegenden Typ der angegebenen Enumeration zurück.
GetValues(Type)	Ruft ein Array mit den Werten der Konstanten einer angegebenen Enumeration ab.
GetValues<TEnum>()	Ruft ein Array der Werte der Konstanten in einem angegebenen Enumerationstyp ab.
GetValuesAsUnderlyingType(Type)	Ruft ein Array der Werte der zugrunde liegenden Typkonstanten in einer angegebenen Enumeration ab.
GetValuesAsUnderlyingType<TEnum>()	Ruft ein Array der Werte der zugrunde liegenden Typkonstanten in einem angegebenen Enumerationstyp ab.
HasFlag(Enum)	Bestimmt, ob ein oder mehrere Bitfelder in der aktuellen Instanz festgelegt werden.
IsDefined(Type, Object)	Gibt einen booleschen Wert zurück, der angibt, ob ein angegebener Integralwert (oder dessen Name als Zeichenfolge) in einer angegebenen Enumeration vorhanden ist.
IsDefined<TEnum>(TEnum)	Gibt einen booleschen Wert zurück, der angibt, ob ein angegebener Integralwert (oder dessen Name als Zeichenfolge) in einer angegebenen Enumeration vorhanden ist.
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Parse(Type, ReadOnlySpan<Char>)	Konvertiert die Zeichenspanne der Darstellung des Namens oder numerischen Werts einer oder mehrerer aufgezählter Konstanten in ein entsprechendes aufgezähltes Objekt.
Parse(Type, ReadOnlySpan<Char>, Boolean)	Konvertiert die Zeichenspanne der Darstellung des Namens oder numerischen Werts einer oder mehrerer aufgezählter Konstanten in ein entsprechendes aufgezähltes Objekt. Ein Parameter gibt an, ob beim Vorgang die Groß-/Kleinschreibung nicht beachtet wird.
Parse(Type, String)	Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.
Parse(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.
Parse<TEnum>(ReadOnlySpan<Char>)	Konvertiert die Spanne der Zeichendarstellung des Namens oder numerischen Werts einer oder mehrerer aufgezählter Konstanten, die durch angegeben werden `TEnum` , in ein entsprechendes aufgezähltes Objekt.
Parse<TEnum>(ReadOnlySpan<Char>, Boolean)	Konvertiert die Spanne der Zeichendarstellung des Namens oder numerischen Werts einer oder mehrerer aufgezählter Konstanten, die durch angegeben werden `TEnum` , in ein entsprechendes aufgezähltes Objekt. Ein Parameter gibt an, ob beim Vorgang die Groß-/Kleinschreibung nicht beachtet wird.
Parse<TEnum>(String)	Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts mindestens einer von `TEnum` angegebenen Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.
Parse<TEnum>(String, Boolean)	Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts mindestens einer von `TEnum` angegebenen Enumerationskonstanten in ein entsprechendes Enumerationsobjekt. Ein Parameter gibt an, ob beim Vorgang die Groß-/Kleinschreibung nicht beachtet wird.
ToObject(Type, Byte)	Konvertiert die angegebene 8-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.
ToObject(Type, Int16)	Konvertiert die angegebene 16-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.
ToObject(Type, Int32)	Konvertiert die angegebene 32-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.
ToObject(Type, Int64)	Konvertiert die angegebene 64-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.
ToObject(Type, Object)	Konvertiert das angegebene Objekt mit einem ganzzahligen Wert in einen Enumerationsmember.
ToObject(Type, SByte)	Konvertiert den angegebenen Wert einer 8-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.
ToObject(Type, UInt16)	Konvertiert den angegebenen Wert einer 16-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.
ToObject(Type, UInt32)	Konvertiert den angegebenen Wert einer 32-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.
ToObject(Type, UInt64)	Konvertiert den angegebenen Wert einer 64-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.
ToString()	Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Veraltet. Veraltet. Diese Methodenüberladung ist veraltet. Verwenden Sie ToString().
ToString(String)	Konvertiert den Wert dieser Instanz anhand des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.
ToString(String, IFormatProvider)	Veraltet. Veraltet. Diese Methodenüberladung ist veraltet. Verwenden Sie ToString(String).
TryFormat<TEnum>(TEnum, Span<Char>, Int32, ReadOnlySpan<Char>)	Versucht, den Wert des aufgezählten Typs instance in die angegebene Zeichenspanne zu formatieren.
TryParse(Type, ReadOnlySpan<Char>, Boolean, Object)	Konvertiert die Zeichenspanne der Darstellung des Namens oder numerischen Werts einer oder mehrerer aufgezählter Konstanten in ein entsprechendes aufgezähltes Objekt. Ein Parameter gibt an, ob beim Vorgang die Groß-/Kleinschreibung nicht beachtet wird.
TryParse(Type, ReadOnlySpan<Char>, Object)	Konvertiert die Zeichenspanne der Darstellung des Namens oder numerischen Werts einer oder mehrerer aufgezählter Konstanten in ein entsprechendes aufgezähltes Objekt.
TryParse(Type, String, Boolean, Object)	Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.
TryParse(Type, String, Object)	Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.
TryParse<TEnum>(ReadOnlySpan<Char>, 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.
TryParse<TEnum>(ReadOnlySpan<Char>, TEnum)	Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.
TryParse<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.
TryParse<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.

Explizite Schnittstellenimplementierungen

IConvertible.GetTypeCode()	Gibt den Typcode dieser Enum-Instanz zurück.
IConvertible.ToBoolean(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in einen booleschen Wert.
IConvertible.ToByte(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 8-Bit-Ganzzahl ohne Vorzeichen.
IConvertible.ToChar(IFormatProvider)	Konvertiert den aktuellen Wert entsprechend dem zugrunde liegenden Typ in ein Unicode-Zeichen.
IConvertible.ToDateTime(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine DateTime.
IConvertible.ToDecimal(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine Decimal.
IConvertible.ToDouble(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine Gleitkommazahl mit doppelter Genauigkeit.
IConvertible.ToInt16(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 16-Bit-Ganzzahl mit Vorzeichen.
IConvertible.ToInt32(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 32-Bit-Ganzzahl mit Vorzeichen.
IConvertible.ToInt64(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 64-Bit-Ganzzahl mit Vorzeichen.
IConvertible.ToSByte(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 8-Bit-Ganzzahl ohne Vorzeichen.
IConvertible.ToSingle(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine Gleitkommazahl mit einfacher Genauigkeit.
IConvertible.ToString(IFormatProvider)	Veraltet. Diese Methodenüberladung ist veraltet. Verwenden Sie stattdessen ToString().
IConvertible.ToType(Type, IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in einen angegebenen Typ.
IConvertible.ToUInt16(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 16-Bit-Ganzzahl ohne Vorzeichen.
IConvertible.ToUInt32(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 32-Bit-Ganzzahl ohne Vorzeichen.
IConvertible.ToUInt64(IFormatProvider)	Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 64-Bit-Ganzzahl ohne Vorzeichen.
IFormattable.ToString(String, IFormatProvider)	Veraltet. Diese Methodenüberladung ist veraltet. Verwenden Sie ToString(String).
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der Enumeration in die angegebene Zeichenspanne zu formatieren.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.