Enum Klasa

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Udostępnia klasę bazową dla wyliczenia.

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

Dziedziczenie: Object

ValueType
Enum

Pochodne: Accessibility.AnnoScope

Microsoft.Aspnet.Snapin.MMC_CONTROL_TYPE

Microsoft.CSharp.ErrorLevel

Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags

Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags

Więcej…

Atrybuty: SerializableAttribute ComVisibleAttribute

Implementuje: IComparable IConvertible IFormattable ISpanFormattable

Przykłady

W poniższym przykładzie pokazano użycie wyliczenia do reprezentowania nazwanych wartości i innej wyliczenia reprezentującej nazwane pola bitowe.

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

Uwagi

Wyliczenie jest zestawem nazwanych stałych, których typem bazowym jest dowolny typ całkowity. Jeśli żaden typ bazowy nie jest jawnie zadeklarowany, Int32 jest używany. Enumjest klasą bazową dla wszystkich wyliczeń w .NET Framework. Typy wyliczenia są definiowane przez enum słowo kluczowe w języku C#, Enumkonstrukcję type ...End Enum w Visual Basic i słowo kluczowe w języku F#.

Enum Zawiera metody porównywania wystąpień tej klasy, konwertowania wartości wystąpienia na reprezentację ciągu, konwertowanie reprezentacji ciągu liczby na wystąpienie tej klasy oraz tworzenie wystąpienia określonej wyliczenia i wartości.

Można również traktować wyliczenie jako pole bitowe. Aby uzyskać więcej informacji, zobacz sekcję Elementy członkowskie inne niż wykluczające i Atrybut flagi oraz FlagsAttribute temat.

W tym temacie:

Tworzenie typu wyliczenia tworzenie wystąpienia typu wyliczenia Typ wyliczenia Najlepsze rozwiązania Dotyczące wykonywania operacji z wyliczeniami Wykonywanie konwersji Analizowanie wartości wyliczania wartości iteracji iteracja członków nieu wyłącznych członków i atrybut Flags Dodawanie metod wyliczenia

Tworzenie typu wyliczenia

Języki programowania zwykle zapewniają składnię do deklarowania wyliczenia składającego się z zestawu nazwanych stałych i ich wartości. Poniższy przykład ilustruje składnię używaną przez język C#, F# i Visual Basic w celu zdefiniowania wyliczenia. Tworzy wyliczenie o nazwie ArrivalStatus zawierającej trzy elementy członkowskie: ArrivalStatus.Early, ArrivalStatus.OnTimei ArrivalStatus.Late. Należy pamiętać, że we wszystkich przypadkach wyliczenie nie dziedziczy jawnie z Enum; relacja dziedziczenia jest obsługiwana niejawnie przez kompilator.

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

Ostrzeżenie

Nigdy nie należy tworzyć typu wyliczenia, którego typ bazowy jest nieuliczny lub Char. Chociaż można utworzyć taki typ wyliczenia przy użyciu odbicia, wywołania metody korzystające z wynikowego typu są niewiarygodne i mogą również zgłaszać dodatkowe wyjątki.

Tworzenie wystąpienia typu wyliczenia

Wystąpienie typu wyliczenia można utworzyć tak samo, jak wystąpienie dowolnego innego typu wartości: deklarując zmienną i przypisując do niej jedną ze stałych wyliczenia. Poniższy przykład tworzy wystąpienie ArrivalStatus , którego wartość to 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)

Możesz również utworzyć wystąpienie wartości wyliczenia w następujący sposób:

Używając funkcji określonego języka programowania do rzutowania (tak jak w języku C#) lub konwertowania (jak w Visual Basic) wartości całkowitej na wartość wyliczenia. Poniższy przykład tworzy ArrivalStatus obiekt, którego wartość jest ArrivalStatus.Early w ten sposób.

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)

Wywołując niejawny konstruktor bez parametrów. Jak pokazano w poniższym przykładzie, w tym przypadku podstawowa wartość wystąpienia wyliczenia wynosi 0. Niekoniecznie jest to jednak wartość prawidłowej stałej w wyliczaniu.

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)

Wywołując metodę Parse or TryParse , aby przeanalizować ciąg zawierający nazwę stałej w wyliczenie. Aby uzyskać więcej informacji, zobacz sekcję Analizowanie wartości wyliczenia .
Wywołując metodę ToObject w celu przekonwertowania wartości całkowitej na typ wyliczenia. Aby uzyskać więcej informacji, zobacz sekcję Wykonywanie konwersji .

Najlepsze rozwiązania dotyczące wyliczania

Zalecamy użycie następujących najlepszych rozwiązań podczas definiowania typów wyliczenia:

Jeśli nie zdefiniowano elementu członkowskiego wyliczenia, którego wartość wynosi 0, rozważ utworzenie stałej wyliczonej None . Domyślnie pamięć używana do wyliczania jest inicjowana do zera przez środowisko uruchomieniowe języka wspólnego. W związku z tym, jeśli nie zdefiniujesz stałej, której wartość jest równa zero, wyliczenie będzie zawierać niedozwoloną wartość podczas jej tworzenia.
Jeśli istnieje oczywisty przypadek domyślny, który aplikacja musi reprezentować, rozważ użycie wyliczonej stałej, której wartość wynosi zero, aby ją reprezentować. Jeśli nie ma przypadku domyślnego, rozważ użycie wyliczonej stałej, której wartość to zero, aby określić przypadek, który nie jest reprezentowany przez żadną z pozostałych wyliczonych stałych.
Nie należy określać wyliczonych stałych zarezerwowanych do użycia w przyszłości.
Podczas definiowania metody lub właściwości, która przyjmuje stałą wyliczaną jako wartość, rozważ zweryfikowanie wartości. Przyczyną jest to, że można rzutować wartość liczbową na typ wyliczenia, nawet jeśli ta wartość liczbowa nie jest zdefiniowana w wyliczenia.

Dodatkowe najlepsze rozwiązania dotyczące typów wyliczenia, których stałe są polami bitowymi, są wymienione w sekcji Elementy członkowskie bez wyłącznych i Atrybut flag.

Wykonywanie operacji przy użyciu wyliczenia

Podczas tworzenia wyliczenia nie można zdefiniować nowych metod. Jednak typ wyliczenia dziedziczy kompletny zestaw metod statycznych i wystąpień z Enum klasy. W poniższych sekcjach przedstawiono większość tych metod, oprócz kilku innych metod, które są często używane podczas pracy z wartościami wyliczenia.

Wykonywanie konwersji

Element członkowski wyliczania i jego typ bazowy można przekonwertować za pomocą operatora rzutowania (w języku C# i F#) lub konwersji (w języku Visual Basic). W języku F# enum jest również używana funkcja. W poniższym przykładzie użyto operatorów rzutowania lub konwersji, aby wykonać konwersje zarówno z liczby całkowitej, jak i z wartości wyliczenia do liczby całkowitej.

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)

Klasa Enum zawiera również metodę ToObject , która konwertuje wartość dowolnego typu całkowitego na wartość wyliczenia. W poniższym przykładzie ToObject(Type, Int32) użyto metody w celu przekonwertowania wartości Int32 na ArrivalStatus wartość. Należy pamiętać, że ponieważ zwraca ToObject wartość typu Object, użycie operatora rzutowania lub konwersji może być nadal konieczne do rzutowania obiektu do typu wyliczenia.

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)

Podczas konwertowania liczby całkowitej na wartość wyliczenia można przypisać wartość, która nie jest elementem członkowskim wyliczenia. Aby temu zapobiec, można przekazać liczbę całkowitą do IsDefined metody przed wykonaniem konwersji. W poniższym przykładzie użyto tej metody w celu określenia, czy elementy w tablicy wartości całkowitych można przekonwertować na ArrivalStatus wartości.

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

Enum Mimo że klasa udostępnia jawne implementacje interfejsu IConvertible do konwertowania z wartości wyliczenia na typ całkowity, należy użyć metod Convert klasy, takich jak ToInt32, w celu wykonania tych konwersji. W poniższym przykładzie pokazano, jak można użyć GetUnderlyingType metody wraz z Convert.ChangeType metodą, aby przekonwertować wartość wyliczenia na jego typ bazowy. Należy pamiętać, że ten przykład nie wymaga, aby podstawowy typ wyliczenia był znany w czasie kompilacji.

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

Analizowanie wartości wyliczenia

Metody Parse i TryParse umożliwiają konwertowanie ciągu reprezentacji wartości wyliczenia na wartość tej wartości. Reprezentacja ciągu może być nazwą lub podstawową wartością stałej wyliczenia. Należy pamiętać, że metody analizowania pomyślnie przekonwertują reprezentacje ciągów liczb, które nie są elementami członkowskimi określonego wyliczenia, jeśli ciągi można przekonwertować na wartość typu bazowego wyliczenia. Aby temu zapobiec, można wywołać metodę w celu upewnienia się, IsDefined że wynik metody analizowania jest prawidłową wartością wyliczenia. W przykładzie pokazano to podejście i pokazano wywołania metod Parse(Type, String) i .Enum.TryParse<TEnum>(String, TEnum) Należy pamiętać, że metoda analizowania niegeneryczna zwraca obiekt, który może być konieczne rzutowanie (w języku C# i F#) lub przekonwertowanie (w Visual Basic) na odpowiedni typ wyliczenia.

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

Formatowanie wartości wyliczenia

Wartości wyliczenia można przekonwertować na ich reprezentacje ciągów, wywołując metodę statyczną Format , a także przeciążenia metody wystąpienia ToString . Możesz użyć ciągu formatu, aby kontrolować dokładny sposób, w jaki wartość wyliczenia jest reprezentowana jako ciąg. Aby uzyskać więcej informacji, zobacz Ciągi formatu wyliczenia. W poniższym przykładzie użyto każdego z obsługiwanych ciągów formatu wyliczenia ("G" lub "g", "D" lub "d", "X" lub "x" oraz "F" lub "f" ) w celu przekonwertowania elementu członkowskiego ArrivalStatus wyliczenia na jego reprezentacje ciągów.

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

Iterowanie elementów członkowskich wyliczania

Typ Enum nie implementuje interfejsu IEnumerable lub IEnumerable<T> , który umożliwia iterowanie elementów członkowskich kolekcji przy użyciu foreach konstrukcji (w języku C#), for..in (w języku F#) lub For Each (w języku Visual Basic). Można jednak wyliczać elementy członkowskie na jeden z dwóch sposobów.

Metodę można wywołać, GetNames aby pobrać tablicę ciągów zawierającą nazwy składowych wyliczenia. Następnie dla każdego elementu tablicy ciągów można wywołać Parse metodę, aby przekonwertować ciąg na równoważną wartość wyliczenia. To podejście pokazano w poniższym przykładzie.

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)

Możesz wywołać metodę GetValues , aby pobrać tablicę zawierającą wartości bazowe w wyliczenie. Następnie dla każdego elementu tablicy można wywołać ToObject metodę, aby przekonwertować liczbę całkowitą na równoważną wartość wyliczenia. To podejście pokazano w poniższym przykładzie.

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)

Nie wykluczające się elementy członkowskie i atrybut Flags

Jednym z typowych zastosowań wyliczenia jest reprezentowanie zestawu wzajemnie wykluczających się wartości. Na przykład ArrivalStatus wystąpienie może mieć wartość Early, OnTimelub Late. Nie ma sensu, aby wartość ArrivalStatus wystąpienia odzwierciedlała więcej niż jedną stałą wyliczenia.

W innych przypadkach jednak wartość obiektu wyliczenia może zawierać wiele elementów członkowskich wyliczenia, a każdy element członkowski reprezentuje pole bitowe w wartości wyliczenia. Atrybut FlagsAttribute może służyć do wskazania, że wyliczenie składa się z pól bitowych. Na przykład wyliczenie o nazwie Pets może służyć do wskazywania rodzajów zwierząt domowych w gospodarstwie domowym. Można go zdefiniować w następujący sposób.

[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

Następnie Pets można użyć wyliczenia, jak pokazano w poniższym przykładzie.

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)

Podczas definiowania wyliczenia bitowego i stosowania atrybutu FlagsAttribute należy użyć poniższych najlepszych rozwiązań.

Użyj atrybutu niestandardowego FlagsAttribute dla wyliczenia tylko wtedy, gdy operacja bitowa (AND, OR, EXCLUSIVE LUB) ma być wykonywana na wartości liczbowej.
Zdefiniuj stałe wyliczenia w uprawnieniach dwóch, czyli 1, 2, 4, 8 itd. Oznacza to, że poszczególne flagi w połączonych stałych wyliczenia nie nakładają się na siebie.
Rozważ utworzenie stałej wyliczonej dla często używanych kombinacji flag. Jeśli na przykład masz wyliczenie używane do operacji we/wy Read = 1 pliku, które zawierają wyliczone stałe i Write = 2, rozważ utworzenie wyliczonej stałej ReadWrite = Read OR Write, która łączy Read flagi i Write . Ponadto bitowa operacja OR używana do łączenia flag może być uznawana za zaawansowaną koncepcję w pewnych okolicznościach, które nie powinny być wymagane w przypadku prostych zadań.
Należy zachować ostrożność w przypadku definiowania liczby ujemnej jako stałej wyliczonej flagi, ponieważ wiele pozycji flag może być ustawionych na 1, co może spowodować mylące kodowanie i zachęcanie do błędów kodowania.

Wygodnym sposobem testowania, czy flaga jest ustawiona w wartości liczbowej, jest wywołanie metody wystąpienia HasFlag , jak pokazano w poniższym przykładzie.

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.

Jest to równoważne wykonaniu bitowej operacji AND między wartością liczbową a wyliczonej stałej flagi, która ustawia wszystkie bity w wartości liczbowej na zero, która nie odpowiada flagi, a następnie testuje, czy wynik tej operacji jest równy wyliczonej stałej flagi. Jest to zilustrowane w poniższym przykładzie.

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.

Użyj None jako nazwy wyliczonej stałej flagi, której wartość to zero. Nie można użyć wyliczonej None stałej w bitowej operacji AND, aby przetestować flagę, ponieważ wynik jest zawsze zerowy. Można jednak wykonać logiczne, a nie bitowe porównanie wartości liczbowej i None wyliczonej stałej w celu określenia, czy są ustawione jakiekolwiek bity w wartości liczbowej. Jest to zilustrowane w poniższym przykładzie.

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.

Nie należy definiować wartości wyliczenia wyłącznie w celu dublowania stanu samego wyliczenia. Na przykład nie należy definiować wyliczonej stałej, która jedynie oznacza koniec wyliczenia. Jeśli musisz określić ostatnią wartość wyliczenia, sprawdź jawnie, czy ta wartość jest jawna. Ponadto można sprawdzić zakres dla pierwszej i ostatniej wyliczonej stałej, jeśli wszystkie wartości w zakresie są prawidłowe.

Dodawanie metod wyliczenia

Ponieważ typy wyliczenia są definiowane przez struktury językowe, takie jak enum (C#) i Enum (Visual Basic), nie można zdefiniować metod niestandardowych dla typu wyliczenia innego niż te metody dziedziczone z Enum klasy. Można jednak użyć metod rozszerzeń, aby dodać funkcjonalność do określonego typu wyliczenia.

W poniższym przykładzie wyliczenie Grades reprezentuje możliwe oceny liter, które student może otrzymać w klasie. Metoda rozszerzenia o nazwie Passing jest dodawana do Grades typu, aby każde wystąpienie tego typu "wie", czy reprezentuje klasę przekazującą, czy nie. Klasa Extensions zawiera również statyczną zmienną odczytu i zapisu, która definiuje minimalną ocenę przekazywania. Wartość Passing zwracana metody rozszerzenia odzwierciedla bieżącą wartość tej zmiennej.

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.

Konstruktory

Enum()

Inicjuje nowe wystąpienie klasy Enum.

Metody

CompareTo(Object)	Porównuje to wystąpienie z określonym obiektem i zwraca wskazanie ich względnych wartości.
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.
Format(Type, Object, String)	Konwertuje określoną wartość określonego typu wyliczonego na równoważną reprezentację ciągu zgodnie z określonym formatem.
GetHashCode()	Zwraca kod skrótu dla wartości tego wystąpienia.
GetName(Type, Object)	Pobiera nazwę stałej w określonym wyliczenie, które ma określoną wartość.
GetName<TEnum>(TEnum)	Pobiera nazwę stałej w określonym typie wyliczania, który ma określoną wartość.
GetNames(Type)	Pobiera tablicę nazw stałych w określonym wyliczeniem.
GetNames<TEnum>()	Pobiera tablicę nazw stałych w określonym typie wyliczania.
GetType()	Type Pobiera bieżące wystąpienie. (Odziedziczone po Object)
GetTypeCode()	Zwraca kod typu bazowego tego elementu członkowskiego wyliczenia.
GetUnderlyingType(Type)	Zwraca podstawowy typ określonego wyliczenia.
GetValues(Type)	Pobiera tablicę wartości stałych w określonym wyliczeniem.
GetValues<TEnum>()	Pobiera tablicę wartości stałych w określonym typie wyliczenia.
GetValuesAsUnderlyingType(Type)	Pobiera tablicę wartości stałych typu bazowego w określonym wyliczaniu.
GetValuesAsUnderlyingType<TEnum>()	Pobiera tablicę wartości stałych typu bazowego w określonym typie wyliczania.
HasFlag(Enum)	Określa, czy w bieżącym wystąpieniu ustawiono jedno lub więcej pól bitowych.
IsDefined(Type, Object)	Zwraca wartość logiczną informującą, czy dana wartość całkowita, czy jej nazwa jako ciąg, istnieje w określonym wyliczeniu.
IsDefined<TEnum>(TEnum)	Zwraca wartość logiczną informującą, czy dana wartość całkowita, czy jej nazwa jako ciąg, istnieje w określonym wyliczeniu.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
Parse(Type, ReadOnlySpan<Char>)	Konwertuje zakres znaków reprezentacji nazwy lub wartości liczbowej co najmniej jednej wyliczonej stałej na równoważny obiekt wyliczony.
Parse(Type, ReadOnlySpan<Char>, Boolean)	Konwertuje zakres znaków reprezentacji nazwy lub wartości liczbowej co najmniej jednej wyliczonej stałej na równoważny obiekt wyliczony. Parametr określa, czy operacja jest bez uwzględniania wielkości liter.
Parse(Type, String)	Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.
Parse(Type, String, Boolean)	Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego. Parametr określa, czy operacja jest bez uwzględniania wielkości liter.
Parse<TEnum>(ReadOnlySpan<Char>)	Konwertuje zakres znaków reprezentacji nazwy lub wartości liczbowej co najmniej jednej wyliczonej stałej określonej przez do `TEnum` równoważnego obiektu wyliczonego.
Parse<TEnum>(ReadOnlySpan<Char>, Boolean)	Konwertuje zakres znaków reprezentacji nazwy lub wartości liczbowej co najmniej jednej wyliczonej stałej określonej przez do `TEnum` równoważnego obiektu wyliczonego. Parametr określa, czy operacja jest bez uwzględniania wielkości liter.
Parse<TEnum>(String)	Konwertuje reprezentację ciągu nazwy lub wartości liczbowej co najmniej jednej wyliczonej stałej określonej przez do `TEnum` równoważnego obiektu wyliczonego.
Parse<TEnum>(String, Boolean)	Konwertuje reprezentację ciągu nazwy lub wartości liczbowej co najmniej jednej wyliczonej stałej określonej przez do `TEnum` równoważnego obiektu wyliczonego. Parametr określa, czy operacja jest bez uwzględniania wielkości liter.
ToObject(Type, Byte)	Konwertuje określoną 8-bitową liczbę całkowitą bez znaku na element członkowski wyliczenia.
ToObject(Type, Int16)	Konwertuje określoną 16-bitową liczbę całkowitą podpisaną na element członkowski wyliczenia.
ToObject(Type, Int32)	Konwertuje określoną 32-bitową liczbę całkowitą podpisaną na element członkowski wyliczenia.
ToObject(Type, Int64)	Konwertuje określoną 64-bitową liczbę całkowitą podpisaną na element członkowski wyliczenia.
ToObject(Type, Object)	Konwertuje określony obiekt z wartością całkowitą na element członkowski wyliczenia.
ToObject(Type, SByte)	Konwertuje określoną 8-bitową wartość całkowitą ze znakiem na element członkowski wyliczenia.
ToObject(Type, UInt16)	Konwertuje określoną 16-bitową niepodpisaną wartość całkowitą na element członkowski wyliczenia.
ToObject(Type, UInt32)	Konwertuje określoną 32-bitową niepodpisaną wartość całkowitą na element członkowski wyliczenia.
ToObject(Type, UInt64)	Konwertuje określoną 64-bitową wartość całkowitą bez znaku na element członkowski wyliczenia.
ToString()	Konwertuje wartość tego wystąpienia na jego równoważną reprezentację w postaci ciągu.
ToString(IFormatProvider)	Nieaktualne. Nieaktualne. To przeciążenie metody jest przestarzałe; użyj polecenia ToString().
ToString(String)	Konwertuje wartość tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonego formatu.
ToString(String, IFormatProvider)	Nieaktualne. Nieaktualne. To przeciążenie metody jest przestarzałe; użyj polecenia ToString(String).
TryFormat<TEnum>(TEnum, Span<Char>, Int32, ReadOnlySpan<Char>)	Udostępnia klasę bazową dla wyliczenia.
TryParse(Type, ReadOnlySpan<Char>, Boolean, Object)	Konwertuje zakres znaków reprezentacji nazwy lub wartości liczbowej co najmniej jednej wyliczonej stałej na równoważny obiekt wyliczony. Parametr określa, czy operacja jest bez uwzględniania wielkości liter.
TryParse(Type, ReadOnlySpan<Char>, Object)	Konwertuje zakres znaków reprezentacji nazwy lub wartości liczbowej co najmniej jednej wyliczonej stałej na równoważny obiekt wyliczony.
TryParse(Type, String, Boolean, Object)	Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.
TryParse(Type, String, Object)	Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.
TryParse<TEnum>(ReadOnlySpan<Char>, Boolean, TEnum)	Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego. Parametr określa, czy operacja jest wrażliwa na wielkość liter. Zwracana wartość wskazuje, czy konwersja powiodła się.
TryParse<TEnum>(ReadOnlySpan<Char>, TEnum)	Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.
TryParse<TEnum>(String, Boolean, TEnum)	Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego. Parametr określa, czy operacja jest wrażliwa na wielkość liter. Zwracana wartość wskazuje, czy konwersja powiodła się.
TryParse<TEnum>(String, TEnum)	Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego. Zwracana wartość wskazuje, czy konwersja powiodła się.

Jawne implementacje interfejsu

IConvertible.GetTypeCode()	Zwraca kod typu tego Enum wystąpienia.
IConvertible.ToBoolean(IFormatProvider)	Konwertuje bieżącą wartość na wartość logiczną na podstawie typu bazowego.
IConvertible.ToByte(IFormatProvider)	Konwertuje bieżącą wartość na 8-bitową niepodpisaną liczbę całkowitą na podstawie typu bazowego.
IConvertible.ToChar(IFormatProvider)	Konwertuje bieżącą wartość na znak Unicode na podstawie typu bazowego.
IConvertible.ToDateTime(IFormatProvider)	Konwertuje bieżącą DateTime wartość na na podstawie typu bazowego.
IConvertible.ToDecimal(IFormatProvider)	Konwertuje bieżącą Decimal wartość na na podstawie typu bazowego.
IConvertible.ToDouble(IFormatProvider)	Konwertuje bieżącą wartość na liczbę zmiennoprzecinkową o podwójnej precyzji na podstawie typu bazowego.
IConvertible.ToInt16(IFormatProvider)	Konwertuje bieżącą wartość na 16-bitową liczbę całkowitą podpisaną na podstawie typu bazowego.
IConvertible.ToInt32(IFormatProvider)	Konwertuje bieżącą wartość na 32-bitową liczbę całkowitą podpisaną na podstawie typu bazowego.
IConvertible.ToInt64(IFormatProvider)	Konwertuje bieżącą wartość na 64-bitową liczbę całkowitą podpisaną na podstawie typu bazowego.
IConvertible.ToSByte(IFormatProvider)	Konwertuje bieżącą wartość na 8-bitową liczbę całkowitą podpisaną na podstawie typu bazowego.
IConvertible.ToSingle(IFormatProvider)	Konwertuje bieżącą wartość na liczbę zmiennoprzecinkową o pojedynczej precyzji na podstawie bazowego typu.
IConvertible.ToString(IFormatProvider)	Nieaktualne. To przeciążenie metody jest przestarzałe; użyj ToString() zamiast tego.
IConvertible.ToType(Type, IFormatProvider)	Konwertuje bieżącą wartość na określony typ na podstawie typu bazowego.
IConvertible.ToUInt16(IFormatProvider)	Konwertuje bieżącą wartość na 16-bitową liczbę całkowitą bez znaku na podstawie typu bazowego.
IConvertible.ToUInt32(IFormatProvider)	Konwertuje bieżącą wartość na 32-bitową liczbę całkowitą bez znaku na podstawie typu bazowego.
IConvertible.ToUInt64(IFormatProvider)	Konwertuje bieżącą wartość na 64-bitową liczbę całkowitą bez znaku na podstawie typu bazowego.
IFormattable.ToString(String, IFormatProvider)	Nieaktualne. To przeciążenie metody jest przestarzałe; użyj polecenia ToString(String).
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Udostępnia klasę bazową dla wyliczenia.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.