Enum Klasse

Definition

Stellt die Basisklasse für Enumerationen bereit.Provides the base class for enumerations.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible
Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, IFormattable
Vererbung
Abgeleitet
Attribute
Implementiert

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung einer Enumeration zur Darstellung benannter Werte und eine weitere Enumeration zur Darstellung benannter Bitfelder.The following example demonstrates using an enumeration to represent named values and another enumeration to represent named bit fields.

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);
    }
}
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 von benannten Konstanten, deren zugrunde liegender Typ ein beliebiger ganzzahliger Typ ist.An enumeration is a set of named constants whose underlying type is any integral type. Wenn kein zugrunde liegender Typ explizit deklariert wird, wird Int32 verwendet.If no underlying type is explicitly declared, Int32 is used. Enum ist die Basisklasse für alle Enumerationen in der .NET Framework.Enum is the base class for all enumerations in the .NET Framework. Enumerationstypen werden durch das enum- C# Schlüsselwort in und das Enum...End Enum-Konstrukt in Visual Basic definiert.Enumeration types are defined by the enum keyword in C# and the Enum...End Enum construct in Visual Basic.

Enum bietet Methoden zum Vergleichen von Instanzen dieser Klasse, zum Umrechnen des Werts einer Instanz in ihre Zeichen folgen Darstellung, zum umrechnen der Zeichen folgen Darstellung einer Zahl in eine Instanz dieser Klasse und zum Erstellen einer Instanz einer angegebenen Enumeration. und-Wert.Enum provides methods for comparing instances of this class, converting the value of an instance to its string representation, converting the string representation of a number to an instance of this class, and creating an instance of a specified enumeration and value.

Sie können auch eine Enumeration als Bitfeld behandeln.You can also treat an enumeration as a bit field. Weitere Informationen finden Sie im Abschnitt nicht exklusive Member und Flags-Attribut und im FlagsAttribute Thema.For more information, see the Non-Exclusive Members and the Flags Attribute section and the FlagsAttribute topic.

In diesem Thema:In this topic:

Erstellen eines Enumerationstyps Creating an enumeration type
Instanziieren eines Enumerationstyps Instantiating an enumeration type
Bewährte Methoden für die Enumeration Enumeration best practices
Ausführen von Vorgängen mit Enumerationen Performing operations with enumerations
Ausführen von KonvertierungenPerforming conversions
Auswerten von EnumerationswertenParsing enumeration values
Formatieren von EnumerationswertenFormatting enumeration values
Iteration von EnumerationsmembernIterating enumeration members
Nicht exklusive Member und das Flags-AttributNon-exclusive members and the Flags attribute
Hinzufügen von EnumerationsmethodenAdding enumeration methods

Erstellen eines EnumerationstypsCreating an enumeration type

Programmiersprachen stellen in der Regel eine Syntax zum Deklarieren einer Enumeration bereit, die aus einem Satz benannter Konstanten und deren Werten besteht.Programming languages typically provide syntax to declare an enumeration that consists of a set of named constants and their values. Im folgenden Beispiel wird die Syntax veranschaulicht, C# die von und Visual Basic zum Definieren einer Enumeration verwendet wird.The following example illustrates the syntax used by C# and Visual Basic to define an enumeration. Es wird eine Enumeration mit dem Namen ArrivalStatus erstellt, die drei Member hat: ArrivalStatus.Early, ArrivalStatus.OnTimeund ArrivalStatus.Late.It creates an enumeration named ArrivalStatus that has three members: ArrivalStatus.Early, ArrivalStatus.OnTime, and ArrivalStatus.Late. Beachten Sie, dass in beiden Fällen die Enumeration nicht explizit von Enumerbt. die Vererbungs Beziehung wird implizit vom Compiler behandelt.Note that in both cases, the enumeration does not explicitly inherit from Enum; the inheritance relationship is handled implicitly by the compiler.

public enum ArrivalStatus { Late=-1, OnTime=0, Early=1 };
Public Enum ArrivalStatus As Integer
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Warnung

Sie sollten nie einen Enumerationstyp erstellen, dessen zugrunde liegender Typ nicht ganzzahlig oder Charist.You should never create an enumeration type whose underlying type is non-integral or 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.Although you can create such an enumeration type by using reflection, method calls that use the resulting type are unreliable and may also throw additional exceptions.

Instanziieren eines EnumerationstypsInstantiating an enumeration type

Sie können einen Enumerationstyp genau so instanziieren, wie Sie einen anderen Werttyp instanziieren: durch Deklarieren einer Variablen und Zuweisen einer der Konstanten der Enumeration.You can instantiate an enumeration type just as you instantiate any other value type: by declaring a variable and assigning one of the enumeration's constants to it. Im folgenden Beispiel wird ein-ArrivalStatus instanziiert, dessen Wert ArrivalStatus.OnTimeist.The following example instantiates an ArrivalStatus whose value is 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)
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:You can also instantiate an enumeration value in the following ways:

  • Mithilfe der Funktionen einer bestimmten Programmiersprache können Sie einen ganzzahligen C#Wert in einen Enumerationswert umwandeln (wie in) oder in einen ganzzahligen Wert konvertieren (wie in Visual Basic).By using a particular programming language's features to cast (as in C#) or convert (as in Visual Basic) an integer value to an enumeration value. Im folgenden Beispiel wird ein ArrivalStatus Objekt erstellt, dessen Wert auf diese Weise ArrivalStatus.Early wird.The following example creates an ArrivalStatus object whose value is ArrivalStatus.Early in this way.

    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // 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 Parameter losen Konstruktors.By calling its implicit parameterless constructor. Wie im folgenden Beispiel gezeigt, ist in diesem Fall der zugrunde liegende Wert der Enumerationsinstanz 0 (null).As the following example shows, in this case the underlying value of the enumeration instance is 0. Dies ist jedoch nicht notwendigerweise der Wert einer gültigen Konstante in der-Enumeration.However, this is not necessarily the value of a valid constant in the enumeration.

    ArrivalStatus status1 = new ArrivalStatus();
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
    // 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)
    
  • Durch Aufrufen der-Methode Parse oder TryParse, um eine Zeichenfolge zu analysieren, die den Namen einer Konstanten in der-Enumeration enthält.By calling the Parse or TryParse method to parse a string that contains the name of a constant in the enumeration. Weitere Informationen finden Sie im Abschnitt zum Auswerten von Enumerationswerten .For more information, see the Parsing Enumeration Values section.

  • Indem Sie die ToObject-Methode aufrufen, um einen ganzzahligen Wert in einen Enumerationstyp zu konvertieren.By calling the ToObject method to convert an integral value to an enumeration type. Weitere Informationen finden Sie im Abschnitt Durchführen von Konvertierungen .For more information, see the Performing Conversions section.

Bewährte Methoden für die EnumerationEnumeration best practices

Es wird empfohlen, beim Definieren von Enumerationstypen die folgenden bewährten Methoden zu verwenden:We recommend that you use the following best practices when you define enumeration types:

  • Wenn Sie keinen Enumerationsmember definiert haben, dessen Wert 0 ist, sollten Sie eine None Enumerationskonstante erstellen.If you have not defined an enumeration member whose value is 0, consider creating a None enumerated constant. Standardmäßig wird der Arbeitsspeicher, der für die-Enumeration verwendet wird, vom Common Language Runtime mit 0 (null) initialisiert.By default, the memory used for the enumeration is initialized to zero by the common language runtime. Wenn Sie daher keine Konstante definieren, deren Wert 0 (null) ist, enthält die Enumeration bei der Erstellung einen ungültigen Wert.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • Wenn ein offensichtlicher Standardfall vorliegt, den die Anwendung darstellen muss, sollten Sie eine enumerierte Konstante verwenden, deren Wert 0 (null) ist, um Sie darzustellen.If there is an obvious default case that your application has to represent, consider using an enumerated constant whose value is zero to represent it. Wenn kein Standardfall vorhanden ist, sollten Sie eine Enumerationskonstante verwenden, deren Wert 0 (null) ist, um den Fall anzugeben, der nicht durch eine der anderen Enumerationskonstanten repräsentiert wird.If there is no default case, consider using an enumerated constant whose value is zero to specify the case that is not represented by any of the other enumerated constants.

  • Geben Sie keine Enumerationskonstanten an, die für die zukünftige Verwendung reserviert sind.Do not specify enumerated constants that are reserved for future use.

  • Wenn Sie eine Methode oder Eigenschaft definieren, die eine Enumerationskonstante als Wert annimmt, sollten Sie den Wert validieren.When you define a method or property that takes an enumerated constant as a value, consider validating the value. Der Grund hierfür ist, dass Sie einen numerischen Wert in den Enumerationstyp umwandeln können, auch wenn dieser numerische Wert nicht in der-Enumeration definiert ist.The reason is that you can cast a numeric value to the enumeration type even if that numeric value is not defined in the enumeration.

Weitere bewährte Methoden für Enumerationstypen, deren Konstanten Bitfelder sind, sind im Abschnitt nicht exklusive Member und im Flags-Attribut aufgeführt.Additional best practices for enumeration types whose constants are bit fields are listed in the Non-Exclusive Members and the Flags Attribute section.

Ausführen von Vorgängen mit EnumerationenPerforming operations with enumerations

Sie können keine neuen Methoden definieren, wenn Sie eine Enumeration erstellen.You cannot define new methods when you are creating an enumeration. Ein Enumerationstyp erbt jedoch einen kompletten Satz statischer Methoden und Instanzmethoden von der Enum-Klasse.However, an enumeration type inherits a complete set of static and instance methods from the Enum class. In den folgenden Abschnitten werden die meisten dieser Methoden sowie einige andere Methoden behandelt, die häufig beim Arbeiten mit Enumerationswerten verwendet werden.The following sections survey most of these methods, in addition to several other methods that are commonly used when working with enumeration values.

Ausführen von KonvertierungenPerforming conversions

Sie können einen Enumerationsmember und den zugrunde liegenden Typ mithilfe eines Umwandlungs-( C#in) oder eines Konvertierungs Operators (in Visual Basic) konvertieren.You can convert between an enumeration member and its underlying type by using a casting (in C#) or conversion (in Visual Basic) operator. Im folgenden Beispiel werden Umwandlungs-oder Konvertierungs Operatoren verwendet, um sowohl von einer Ganzzahl in einen Enumerationswert als auch von einem Enumerationswert in eine ganze Zahl konvertiert werdenThe following example uses casting or conversion operators to perform conversions both from an integer to an enumeration value and from an enumeration value to an integer.

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

int 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 ganzzahligen Typs in einen Enumerationswert konvertiert.The Enum class also includes a ToObject method that converts a value of any integral type to an enumeration value. Im folgenden Beispiel wird die ToObject(Type, Int32)-Methode verwendet, um eine Int32 in einen ArrivalStatus-Wert zu konvertieren.The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. Beachten Sie, dass, da die ToObject einen Wert vom Typ Objectzurückgibt, die Verwendung eines Umwandlungs-oder Konvertierungs Operators möglicherweise trotzdem notwendig ist, um das Objekt in den Enumerationstyp umzuwandeln.Note that, because the ToObject returns a value of type Object, the use of a casting or conversion operator may still be necessary to cast the object to the enumeration type.

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

Wenn eine Ganzzahl in einen Enumerationswert umgerechnet wird, ist es möglich, einen Wert zuzuweisen, der eigentlich kein Member der-Enumeration ist.When converting an integer to an enumeration value, it is possible to assign a value that is not actually a member of the enumeration. Um dies zu verhindern, können Sie die ganze Zahl an die IsDefined-Methode übergeben, bevor Sie die Konvertierung durchführen.To prevent this, you can pass the integer to the IsDefined method before performing the conversion. 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.The following example uses this method to determine whether the elements in an array of integer values can be converted to ArrivalStatus values.

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
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 Schnittstellen Implementierungen der IConvertible-Schnittstelle für die Konvertierung von einem Enumerationswert in einen ganzzahligen Typ bereitstellt, sollten Sie die Methoden der Convert-Klasse, wie z. b. ToInt32, verwenden, um diese Konvertierungen auszuführen.Although the Enum class provides explicit interface implementations of the IConvertible interface for converting from an enumeration value to an integral type, you should use the methods of the Convert class, such as ToInt32, to perform these conversions. Im folgenden Beispiel wird veranschaulicht, wie Sie die GetUnderlyingType-Methode zusammen mit der Convert.ChangeType-Methode verwenden können, um einen Enumerationswert in den zugrunde liegenden Typ zu konvertieren.The following example illustrates how you can use the GetUnderlyingType method along with the Convert.ChangeType method to convert an enumeration value to its underlying type. Beachten Sie, dass dieses Beispiel nicht erfordert, dass der zugrunde liegende Typ der Enumeration zur Kompilierzeit bekannt ist.Note that this example does not require the underlying type of the enumeration to be known at compile time.

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
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

Auswerten von EnumerationswertenParsing enumeration values

Mit den Methoden Parse und TryParse können Sie die Zeichen folgen Darstellung eines Enumerationswerts in diesen Wert konvertieren.The Parse and TryParse methods allow you to convert the string representation of an enumeration value to that value. Die Zeichen folgen Darstellung kann entweder der Name oder der zugrunde liegende Wert einer Enumerationskonstante sein.The string representation can be either the name or the underlying value of an enumeration constant. Beachten Sie, dass die-Methoden zur Verarbeitung von Zeichen folgen Darstellungen von Zahlen, die keine Member einer bestimmten Enumeration sind, erfolgreich konvertieren können, wenn die Zeichen folgen in einen Wert des zugrunde liegenden Typs der Enumeration konvertiert werden können.Note that the parsing methods will successfully convert string representations of numbers that are not members of a particular enumeration if the strings can be converted to a value of the enumeration's underlying type. Um dies zu verhindern, kann die IsDefined-Methode aufgerufen werden, um sicherzustellen, dass das Ergebnis der-Methode für die-Methode ein gültiger-Enumerationswert ist.To prevent this, the IsDefined method can be called to ensure that the result of the parsing method is a valid enumeration value. Dieses Verfahren wird in diesem Beispiel veranschaulicht, und es werden Aufrufe der Methoden Parse(Type, String) und Enum.TryParse<TEnum>(String, TEnum) veranschaulicht.The example illustrates this approach and demonstrates calls to both the Parse(Type, String) and Enum.TryParse<TEnum>(String, TEnum) methods. Beachten Sie, dass die nicht generische-Methode ein-Objekt zurückgibt, das Sie möglicherweise in C#umwandeln oder (in Visual Basic) in den entsprechenden Enumerationstyp konvertieren müssen.Note that the non-generic parsing method returns an object that you may have to cast (in C#) or convert (in Visual Basic) to the appropriate enumeration type.

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
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 EnumerationswertenFormatting enumeration values

Sie können Enumerationswerte in ihre Zeichen folgen Darstellungen konvertieren, indem Sie die statische Format-Methode sowie die über Ladungen der-Instanz ToString Methode aufrufen.You can convert enumeration values to their string representations by calling the static Format method, as well as the overloads of the instance ToString method. Sie können eine Format Zeichenfolge verwenden, um die exakte Art und Weise zu steuern, in der ein Enumerationswert als Zeichenfolge dargestellt wird.You can use a format string to control the precise way in which an enumeration value is represented as a string. Weitere Informationen finden Sie unter Enumerationsformatzeichenfolgen.For more information, see Enumeration Format Strings. Im folgenden Beispiel wird jede der unterstützten Enumerationsformatzeichenfolgen ("g" oder "g", "d" oder "d", "x" oder "x", "f" oder "f") verwendet, um einen Member der ArrivalStatus Enumeration in seine Zeichen folgen Darstellungen zu konvertieren.The following example uses each of the supported enumeration format strings ("G" or "g", "D" or "d", "X" or "x", and "F" or "f" ) to convert a member of the ArrivalStatus enumeration to its string representations.

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
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

Iteration von EnumerationsmembernIterating enumeration members

Der Enum Typ implementiert nicht die IEnumerable oder IEnumerable<T>-Schnittstelle, die es Ihnen ermöglicht, Member einer Auflistung mithilfe eines foreach (in C#) oder For Each (in Visual Basic) zu durchlaufen.The Enum type does not implement the IEnumerable or IEnumerable<T> interface, which would enable you to iterate members of a collection by using a foreach (in C#) or For Each (in Visual Basic) construct. Allerdings können Sie Member auf zwei Arten auflisten.However, you can enumerate members in either of two ways.

  • Sie können die GetNames-Methode aufrufen, um ein Zeichen folgen Array mit den Namen der Enumerationsmember abzurufen.You can call the GetNames method to retrieve a string array containing the names of the enumeration members. Als nächstes können Sie für jedes Element des Zeichen folgen Arrays die Parse-Methode zum Konvertieren der Zeichenfolge in den entsprechenden Enumerationswert abrufen.Next, for each element of the string array, you can call the Parse method to convert the string to its equivalent enumeration value. Dieser Ansatz wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates this approach.

    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)      
    
    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.You can call the GetValues method to retrieve an array that contains the underlying values in the enumeration. Als nächstes können Sie für jedes Element des Arrays die ToObject-Methode aufzurufen, um die Ganzzahl in den entsprechenden Enumerationswert zu konvertieren.Next, for each element of the array, you can call the ToObject method to convert the integer to its equivalent enumeration value. Dieser Ansatz wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates this approach.

    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)
    
    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 Member und das Flags-AttributNon-exclusive members and the Flags attribute

Eine Enumeration wird häufig verwendet, um einen Satz von sich gegenseitig ausschließenden Werten darzustellen.One common use of an enumeration is to represent a set of mutually exclusive values. Beispielsweise kann eine ArrivalStatus Instanz den Wert "Early", "OnTime" oder "Late" aufweisen.For example, an ArrivalStatus instance can have a value of Early, OnTime, or Late. Es ist nicht sinnvoll, dass der Wert einer ArrivalStatus-Instanz mehr als eine Enumerationskonstante widerspiegelt.It makes no sense for the value of an ArrivalStatus instance to reflect more than one enumeration constant.

In anderen Fällen kann der Wert eines Enumerationsobjekt jedoch mehrere Enumerationsmember enthalten, und jedes Element stellt ein Bitfeld im Enumerationswert dar.In other cases, however, the value of an enumeration object can include multiple enumeration members, and each member represents a bit field in the enumeration value. Das FlagsAttribute-Attribut kann verwendet werden, um anzugeben, dass die Enumeration aus Bitfeldern besteht.The FlagsAttribute attribute can be used to indicate that the enumeration consists of bit fields. Beispielsweise kann eine Enumeration mit dem Namen Pets verwendet werden, um die Arten der Haustiere in einem Haushalt anzugeben.For example, an enumeration named Pets might be used to indicate the kinds of pets in a household. Sie kann wie folgt definiert werden.It can be defined as follows.

[Flags] public enum 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.The Pets enumeration can then be used as shown in the following example.

Pets familyPets = Pets.Dog | Pets.Cat;
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets);
// 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 beim Definieren einer bitweisen Enumeration und Anwenden des FlagsAttribute Attributs verwendet werden.The following best practices should be used when defining a bitwise enumeration and applying the FlagsAttribute attribute.

  • Verwenden Sie das benutzerdefinierte-Attribut FlagsAttribute nur dann für eine Enumeration, wenn eine bitweise-Operation (and, or, Exclusive oder) für einen numerischen Wert ausgeführt werden soll.Use the FlagsAttribute custom attribute for an enumeration only if a bitwise operation (AND, OR, EXCLUSIVE OR) is to be performed on a numeric value.

  • Definieren von Enumerationskonstanten in den zwei Mächten, d. h. 1, 2, 4, 8 usw.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. Dies bedeutet, dass sich die einzelnen Flags in kombinierten Enumerationskonstanten nicht überlappen.This means the individual flags in combined enumeration constants do not overlap.

  • Erstellen Sie ggf. eine Enumerationskonstante für häufig verwendete Flag-Kombinationen.Consider creating an enumerated constant for commonly used flag combinations. Wenn Sie z. b. eine Enumeration für Datei-e/a-Vorgänge verwenden, die die Enumerationskonstanten Read = 1 und Write = 2enthalten, sollten Sie die Enumerationskonstante ReadWrite = Read OR Writeerstellen, die die Read und Write Flags kombiniert.For example, if you have an enumeration used for file I/O operations that contains the enumerated constants Read = 1 and Write = 2, consider creating the enumerated constant ReadWrite = Read OR Write, which combines the Read and Write flags. Außerdem kann der bitweise OR-Vorgang, der zum Kombinieren der Flags verwendet wird, in einigen Fällen als erweitertes Konzept angesehen werden, die für einfache Aufgaben nicht erforderlich sein sollten.In addition, the bitwise OR operation used to combine the flags might be considered an advanced concept in some circumstances that should not be required for simple tasks.

  • Gehen Sie vorsichtig vor, wenn Sie eine negative Zahl als Flag-Enumerationskonstante definieren, da viele Flagpositionen auf 1 festgelegt werden können, was den Code verwirrend machen und Codierungsfehler fördern kann.Use caution if you define a negative number as a flag enumerated constant because many flag positions might be set to 1, which might make your code confusing and encourage coding errors.

  • Eine bequeme Methode, um zu testen, ob ein Flag in einem numerischen Wert festgelegt ist, besteht darin, die Instanz HasFlag-Methode aufzurufen, wie im folgenden Beispiel gezeigt.A convenient way to test whether a flag is set in a numeric value is to call the instance HasFlag method, as shown in the following example.

    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.      
    
    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.      
    

    Dies entspricht der Durchführung einer bitweisen and-Operation zwischen dem numerischen Wert und der-Flag-Enumerationskonstante, die alle Bits im numerischen Wert auf 0 (null) festlegt, die nicht dem-Flag entsprechen, und dann testet, ob das Ergebnis dieses Vorgangs gleich dem enumerationsenumerationskonstante.It is equivalent to performing a bitwise AND operation between the numeric value and the flag enumerated constant, which sets all bits in the numeric value to zero that do not correspond to the flag, and then testing whether the result of that operation is equal to the flag enumerated constant. Dies wird im folgenden Beispiel illustriert.This is illustrated in the following example.

    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.      
    
    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 Namen der-Flag-Enumerationskonstante, deren Wert 0 (null) ist.Use None as the name of the flag enumerated constant whose value is zero. Sie können die None Enumerationskonstante nicht in einer bitweisen and-Operation verwenden, um auf ein Flag zu testen, da das Ergebnis immer 0 (null) ist.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. Sie können jedoch einen logischen, nicht einen bitweisen Vergleich zwischen dem numerischen Wert und dem None enumerierten Konstanten ausführen, um zu bestimmen, ob Bits im numerischen Wert festgelegt werden.However, you can perform a logical, not a bitwise, comparison between the numeric value and the None enumerated constant to determine whether any bits in the numeric value are set. Dies wird im folgenden Beispiel illustriert.This is illustrated in the following example.

    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.      
    
    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 keinen Enumerationswert ausschließlich so, dass er den Status der Enumeration widerspiegelt.Do not define an enumeration value solely to mirror the state of the enumeration itself. Definieren Sie z. b. keine Enumerationskonstante, die nur das Ende der Enumeration kennzeichnet.For example, do not define an enumerated constant that merely marks the end of the enumeration. Wenn Sie den letzten Wert der Enumeration ermitteln müssen, überprüfen Sie diesen Wert explizit.If you need to determine the last value of the enumeration, check for that value explicitly. Außerdem können Sie eine Bereichs Überprüfung für die erste und letzte Enumerationskonstante ausführen, wenn alle Werte innerhalb des Bereichs gültig sind.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

Hinzufügen von EnumerationsmethodenAdding enumeration methods

Da Enumerationstypen durch Sprachstrukturen definiert werden, wie zC#. b. enum () und Enum (Visual Basic), können Sie keine benutzerdefinierten Methoden für einen Enumerationstyp definieren, der nicht von der Enum Klasse geerbt wurde.Because enumeration types are defined by language structures, such as enum (C#) and Enum (Visual Basic), you cannot define custom methods for an enumeration type other than those methods inherited from the Enum class. Sie können jedoch Erweiterungs Methoden verwenden, um einem bestimmten Enumerationstyp Funktionalität hinzuzufügen.However, you can use extension methods to add functionality to a particular enumeration type.

Im folgenden Beispiel stellt die Grades-Enumeration die möglichen Noten in Buchstaben dar, die ein Schüler im Unterricht erhalten kann.In the following example, the Grades enumeration represents the possible letter grades that a student may receive in a class. 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.An extension method named Passing is added to the Grades type so that each instance of that type now "knows" whether it represents a passing grade or not. Die Extensions-Klasse enthält auch eine statische Variable mit Lese-/Schreibzugriff, die die minimale Übergabe Qualität definiert.The Extensions class also contains a static read-write variable that defines the minimum passing grade. Der Rückgabewert der Passing-Erweiterungsmethode gibt den aktuellen Wert dieser Variablen an.The return value of the Passing extension method reflects the current value of that variable.

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.
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.Initializes a new instance of the Enum class.

Methoden

CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.Returns a value indicating whether this instance is equal to a specified object.

Format(Type, Object, String)

Konvertiert den angegebenen Wert eines angegebenen Enumerationstyps unter Berücksichtigung des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.Converts the specified value of a specified enumerated type to its equivalent string representation according to the specified format.

GetHashCode()

Gibt den Hashcode für den Wert dieser Instanz zurück.Returns the hash code for the value of this instance.

GetName(Type, Object)

Ruft den Namen der Konstanten der angegebenen Enumeration mit dem angegebenen Wert ab.Retrieves the name of the constant in the specified enumeration that has the specified value.

GetNames(Type)

Ruft ein Array mit den Namen der Konstanten einer angegebenen Enumeration ab.Retrieves an array of the names of the constants in a specified enumeration.

GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
GetTypeCode()

Gibt den Typcode des zugrunde liegenden Typs dieses Enumerationsmembers zurück.Returns the type code of the underlying type of this enumeration member.

GetUnderlyingType(Type)

Gibt den zugrunde liegenden Typ der angegebenen Enumeration zurück.Returns the underlying type of the specified enumeration.

GetValues(Type)

Ruft ein Array mit den Werten der Konstanten einer angegebenen Enumeration ab.Retrieves an array of the values of the constants in a specified enumeration.

HasFlag(Enum)

Bestimmt, ob ein oder mehrere Bitfelder in der aktuellen Instanz festgelegt werden.Determines whether one or more bit fields are set in the current instance.

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.Returns a Boolean telling whether a given integral value, or its name as a string, exists in a specified enumeration.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
Parse(Type, String)

Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

Parse(Type, String, Boolean)

Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Ein Parameter gibt an, ob bei der Operation die Groß- und Kleinschreibung nicht berücksichtigt wird.A parameter specifies whether the operation is case-insensitive.

Parse<TEnum>(String)
Parse<TEnum>(String, Boolean)
ToObject(Type, Byte)

Konvertiert die angegebene 8-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.Converts the specified 8-bit unsigned integer to an enumeration member.

ToObject(Type, Int16)

Konvertiert die angegebene 16-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.Converts the specified 16-bit signed integer to an enumeration member.

ToObject(Type, Int32)

Konvertiert die angegebene 32-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.Converts the specified 32-bit signed integer to an enumeration member.

ToObject(Type, Int64)

Konvertiert die angegebene 64-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.Converts the specified 64-bit signed integer to an enumeration member.

ToObject(Type, Object)

Konvertiert das angegebene Objekt mit einem ganzzahligen Wert in einen Enumerationsmember.Converts the specified object with an integer value to an enumeration member.

ToObject(Type, SByte)

Konvertiert den angegebenen Wert einer 8-Bit-Ganzzahl mit Vorzeichen in einen Enumerationsmember.Converts the specified 8-bit signed integer value to an enumeration member.

ToObject(Type, UInt16)

Konvertiert den angegebenen Wert einer 16-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.Converts the specified 16-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt32)

Konvertiert den angegebenen Wert einer 32-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.Converts the specified 32-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt64)

Konvertiert den angegebenen Wert einer 64-Bit-Ganzzahl ohne Vorzeichen in einen Enumerationsmember.Converts the specified 64-bit unsigned integer value to an enumeration member.

ToString()

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.Converts the value of this instance to its equivalent string representation.

ToString(IFormatProvider)

Diese Methodenüberladung ist veraltet. Verwenden Sie ToString().This method overload is obsolete; use ToString().

ToString(String)

Konvertiert den Wert dieser Instanz anhand des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.Converts the value of this instance to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

Diese Methodenüberladung ist veraltet. Verwenden Sie ToString(String).This method overload is obsolete; use ToString(String).

TryParse(Type, String, Boolean, Object)

Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

TryParse(Type, String, Object)

Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

TryParse<TEnum>(String, Boolean, TEnum)

Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Ein Parameter gibt an, ob bei der Operation die Groß- und Kleinschreibung berücksichtigt wird.A parameter specifies whether the operation is case-sensitive. Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.The return value indicates whether the conversion succeeded.

TryParse<TEnum>(String, TEnum)

Konvertiert die Zeichenfolgendarstellung des Namens oder des numerischen Werts einer oder mehrerer Enumerationskonstanten in ein entsprechendes Enumerationsobjekt.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.The return value indicates whether the conversion succeeded.

Explizite Schnittstellenimplementierungen

IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in einen booleschen Wert.Converts the current value to a Boolean value based on the underlying type.

IConvertible.ToByte(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 8-Bit-Ganzzahl ohne Vorzeichen.Converts the current value to an 8-bit unsigned integer based on the underlying type.

IConvertible.ToChar(IFormatProvider)

Konvertiert den aktuellen Wert entsprechend dem zugrunde liegenden Typ in ein Unicode-Zeichen.Converts the current value to a Unicode character based on the underlying type.

IConvertible.ToDateTime(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine DateTime.Converts the current value to a DateTime based on the underlying type.

IConvertible.ToDecimal(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine Decimal.Converts the current value to a Decimal based on the underlying type.

IConvertible.ToDouble(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine Gleitkommazahl mit doppelter Genauigkeit.Converts the current value to a double-precision floating point number based on the underlying type.

IConvertible.ToInt16(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 16-Bit-Ganzzahl mit Vorzeichen.Converts the current value to a 16-bit signed integer based on the underlying type.

IConvertible.ToInt32(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 32-Bit-Ganzzahl mit Vorzeichen.Converts the current value to a 32-bit signed integer based on the underlying type.

IConvertible.ToInt64(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 64-Bit-Ganzzahl mit Vorzeichen.Converts the current value to a 64-bit signed integer based on the underlying type.

IConvertible.ToSByte(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 8-Bit-Ganzzahl ohne Vorzeichen.Converts the current value to an 8-bit signed integer based on the underlying type.

IConvertible.ToSingle(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine Gleitkommazahl mit einfacher Genauigkeit.Converts the current value to a single-precision floating-point number based on the underlying type.

IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in einen angegebenen Typ.Converts the current value to a specified type based on the underlying type.

IConvertible.ToUInt16(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 16-Bit-Ganzzahl ohne Vorzeichen.Converts the current value to a 16-bit unsigned integer based on the underlying type.

IConvertible.ToUInt32(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 32-Bit-Ganzzahl ohne Vorzeichen.Converts the current value to a 32-bit unsigned integer based on the underlying type.

IConvertible.ToUInt64(IFormatProvider)

Konvertiert den aktuellen Wert auf Grundlage des zugrunde liegenden Typs in eine 64-Bit-Ganzzahl ohne Vorzeichen.Converts the current value to a 64-bit unsigned integer based on the underlying type.

IFormattable.ToString(String, IFormatProvider)

Diese Methodenüberladung ist veraltet. Verwenden Sie ToString(String).This method overload is obsolete; use ToString(String).

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.This type is thread safe.

Siehe auch