Enum Třída

Definice

Poskytuje základní třídu pro výčty.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable
public ref class Enum abstract : ValueType, IComparable, IFormattable
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
[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
[<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, IFormattable
Dědičnost
Odvozené
Atributy
Implementuje

Příklady

Následující příklad ukazuje použití výčtu k reprezentaci pojmenovaných hodnot a další výčtu představující pojmenovaná bitová pole.

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

Poznámky

Výčet je sada pojmenovaných konstant, jejichž podkladový typ je libovolný celočíselný typ. Pokud není explicitně deklarován žádný podkladový typ, Int32 použije se. Enumje základní třída pro všechny výčty v .NET Framework. Typy výčtu enum jsou definovány klíčovým slovem v jazyce C#, Enumkonstruktorem ...End Enum v Visual Basic a klíčovým slovem type v jazyce F#.

Enum poskytuje metody pro porovnávání instancí této třídy, převod hodnoty instance na řetězcové vyjádření, převod řetězcové reprezentace čísla na instanci této třídy a vytvoření instance zadané výčtu a hodnoty.

Výčet můžete také považovat za bitové pole. Další informace najdete v části Nevýlučné členy a oddíl Atributy příznaků a FlagsAttribute téma.

V tomto tématu:

Vytvoření typu výčtu vytvoření instance výčtového typu Výčet osvědčených postupů provádění operací s výčty Provádění převodů parsování hodnot výčtu Formátování hodnot výčtuVýčtové hodnotyUterating členů výčtu členůNon-exclusive a metod výčtu Flags attributeAdding

Vytvoření typu výčtu

Programovací jazyky obvykle poskytují syntaxi pro deklaraci výčtu, který se skládá ze sady pojmenovaných konstant a jejich hodnot. Následující příklad znázorňuje syntaxi používanou jazykem C#, F# a Visual Basic k definování výčtu. Vytvoří výčet s názvem ArrivalStatus tři členy: ArrivalStatus.Early, ArrivalStatus.OnTimea ArrivalStatus.Late. Všimněte si, že ve všech případech výčet explicitně nedědí z Enum; vztah dědičnosti je zpracován implicitně kompilátorem.

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

Upozornění

Nikdy byste neměli vytvořit typ výčtu, jehož podkladový typ není integrální nebo Char. I když můžete takový typ výčtu vytvořit pomocí reflexe, volání metody, která používají výsledný typ, jsou nespolehlivé a mohou také vyvolat další výjimky.

Vytvoření instance typu výčtu

Můžete vytvořit instanci typu výčtu stejně jako vytvořit instanci libovolného jiného typu hodnoty: deklarováním proměnné a přiřazením jedné z konstant výčtu k němu. Následující příklad vytvoří instanci ArrivalStatus , jejíž hodnota je 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)

Hodnotu výčtu můžete vytvořit také následujícími způsoby:

  • Použitím funkcí konkrétního programovacího jazyka k přetypování (jako v jazyce C#) nebo převodu (jako v Visual Basic) celočíselné hodnoty na hodnotu výčtu. Následující příklad vytvoří ArrivalStatus objekt, jehož hodnota je ArrivalStatus.Early tímto způsobem.

    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)
    
  • Voláním implicitního konstruktoru bez parametrů Jak ukazuje následující příklad, v tomto případě je podkladová hodnota instance výčtu 0. Nejedná se však nutně o hodnotu platné konstanty v výčtu.

    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)
    
  • Voláním nebo TryParse metodou Parse parsování řetězce, který obsahuje název konstanty v výčtu. Další informace najdete v části Parsování hodnot výčtu .

  • Voláním ToObject metody převeďte celočíselnou hodnotu na typ výčtu. Další informace najdete v části Provádění převodů .

Osvědčené postupy výčtu

Při definování typů výčtu doporučujeme použít následující osvědčené postupy:

  • Pokud jste nedefinovali člen výčtu, jehož hodnota je 0, zvažte vytvoření výčtové None konstanty. Ve výchozím nastavení se paměť použitá pro výčet inicializuje na nulu modulem CLR (Common Language Runtime). Pokud tedy nedefinujete konstantu, jejíž hodnota je nula, bude výčet při vytváření obsahovat neplatnou hodnotu.

  • Pokud je zřejmé, že vaše aplikace musí představovat výchozí případ, zvažte použití výčtové konstanty, jejíž hodnota je nula, aby ji reprezentovala. Pokud neexistuje žádný výchozí případ, zvažte použití výčtové konstanty, jejíž hodnota je nula, určit případ, který není reprezentován žádnou z ostatních výčtových konstant.

  • Nezadávejte výčtové konstanty, které jsou vyhrazeny pro budoucí použití.

  • Když definujete metodu nebo vlastnost, která přebírá výčtovou konstantu jako hodnotu, zvažte ověření hodnoty. Důvodem je, že číselnou hodnotu můžete přetypovat na typ výčtu, i když tato číselná hodnota není definována v výčtu.

Další osvědčené postupy pro typy výčtu, jejichž konstanty jsou bitová pole, jsou uvedeny v části Nevýlučné členy a atribut flags .

Provádění operací s výčty

Při vytváření výčtu nelze definovat nové metody. Typ výčtu však dědí úplnou sadu statických metod a metod instancí z Enum třídy. V následujících částech se většina těchto metod zabývá kromě několika dalších metod, které se běžně používají při práci s hodnotami výčtu.

Provádění převodů

Mezi členem výčtu a jeho základním typem můžete převést pomocí operátoru přetypování (v jazyce C# a F#) nebo převodu (v Visual Basic). V jazyce F# enum se používá také funkce. Následující příklad používá operátory přetypování nebo převodu k provádění převodů z celého čísla na hodnotu výčtu a z hodnoty výčtu na celé číslo.

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)

Třída Enum také obsahuje metodu ToObject , která převádí hodnotu libovolného integrálního typu na hodnotu výčtu. Následující příklad používá metodu ToObject(Type, Int32) k převodu Int32 na ArrivalStatus hodnotu. Všimněte si, že vzhledem k tomu ToObject , že vrátí hodnotu typu Object, použití operátoru přetypování nebo převodu může být stále nutné přetypovat objekt na typ výčtu.

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)

Při převodu celého čísla na hodnotu výčtu je možné přiřadit hodnotu, která není ve skutečnosti členem výčtu. Chcete-li tomu zabránit, můžete před provedením převodu IsDefined předat celé číslo metodě. Následující příklad používá tuto metodu k určení, zda prvky v poli celočíselné hodnoty lze převést na ArrivalStatus hodnoty.

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 Ačkoli třída poskytuje explicitní rozhraní implementace IConvertible rozhraní pro převod z hodnoty výčtu na celočíselný typ, měli byste použít metody Convert třídy, například ToInt32, k provedení těchto převodů. Následující příklad ukazuje, jak můžete použít metodu GetUnderlyingType spolu s metodou k převodu hodnoty výčtu Convert.ChangeType na jeho základní typ. Všimněte si, že tento příklad nevyžaduje, aby byl v době kompilace znám základní typ výčtu.

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

Analýza hodnot výčtu

TryParse Metody Parse umožňují převést řetězcovou reprezentaci hodnoty výčtu na tuto hodnotu. Řetězcové vyjádření může být název nebo podkladová hodnota konstanty výčtu. Všimněte si, že metody analýzy úspěšně převedou řetězcové reprezentace čísel, které nejsou členy určitého výčtu, pokud lze řetězce převést na hodnotu základního typu výčtu. Chcete-li tomu zabránit, lze metodu IsDefined volat, aby se zajistilo, že výsledek metody analýzy je platná hodnota výčtu. Příklad znázorňuje tento přístup a ukazuje volání metod Parse(Type, String) i Enum.TryParse<TEnum>(String, TEnum) metod. Všimněte si, že ne generická metoda analýzy vrátí objekt, který možná budete muset přetypovat (v jazyce C# a F#) nebo převést (v Visual Basic) na příslušný typ výčtu.

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

Formátování hodnot výčtu

Hodnoty výčtu můžete převést na jejich řetězcové reprezentace voláním statické Format metody a také přetížení metody instance ToString . Řetězec formátu můžete použít k řízení přesného způsobu, jakým je hodnota výčtu reprezentována jako řetězec. Další informace naleznete v tématu Formát řetězců výčtu. Následující příklad používá každý z podporovaných řetězců formátu výčtu ("G" nebo "g", "D" nebo "d", "X" nebo "x" a "F" nebo "f" ) k převodu člena ArrivalStatus výčtu na jeho řetězcové reprezentace.

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

Iterace členů výčtu

Typ neimplementuje IEnumerable ani IEnumerable<T> rozhraní, které by vám umožnilo iterovat členy kolekce pomocí konstruktoru foreach (v jazyce C#), for..in (v jazyce F#) nebo For Each (v Enum Visual Basic). Členy ale můžete vytvořit výčet jedním ze dvou způsobů.

  • Metodu GetNames můžete volat k načtení pole řetězců obsahující názvy členů výčtu. Dále pro každý prvek pole řetězce můžete volat metodu Parse , která převede řetězec na jeho ekvivalentní hodnotu výčtu. Tento postup znázorňuje následující příklad.

    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)
    
  • Metodu GetValues můžete volat k načtení pole, které obsahuje podkladové hodnoty v výčtu. Dále pro každý prvek pole můžete volat metodu ToObject , která převede celé číslo na ekvivalentní hodnotu výčtu. Tento postup znázorňuje následující příklad.

    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)
    

Nevýlučné členy a atribut Flags

Jedním z běžných použití výčtu je reprezentace sady vzájemně se vylučujících hodnot. Instance může mít například ArrivalStatus hodnotu Early, nebo OnTime``Late. Nemá smysl, aby hodnota ArrivalStatus instance odrážela více než jednu konstantu výčtu.

V jiných případech však hodnota objektu výčtu může obsahovat více členů výčtu a každý člen představuje bitové pole v hodnotě výčtu. Atribut FlagsAttribute lze použít k označení, že výčet se skládá z bitových polí. Například výčet pojmenovaný Pets může být použit k označení druhů domácích zvířat v domácnosti. Lze ji definovat následujícím způsobem.

[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

Výčet Pets se pak dá použít, jak je znázorněno v následujícím příkladu.

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)

Při definování bitové výčtu a použití atributu FlagsAttribute by se měly použít následující osvědčené postupy.

  • FlagsAttribute Vlastní atribut použijte pro výčet pouze v případě, že se má s číselnou hodnotou provádět bitové operace (AND, OR, EXCLUSIVE OR).

  • Definujte konstanty výčtu v mocninách dvou, tj. 1, 2, 4, 8 atd. To znamená, že jednotlivé příznaky v kombinovaných výčtových konstantách se nepřekrývají.

  • Zvažte vytvoření výčtové konstanty pro běžně používané kombinace příznaků. Pokud máte například výčet používaný pro vstupně-výstupní operace souboru, které obsahují výčtové konstanty Read = 1 , a Write = 2zvažte vytvoření výčtové konstanty ReadWrite = Read OR Write, která kombinuje Read a Write příznaky. Kromě toho může být bitové operace OR použitá ke kombinování příznaků považována za pokročilý koncept za určitých okolností, které by se neměly vyžadovat pro jednoduché úlohy.

  • Pokud definujete záporné číslo jako konstantu s výčtem příznaku, protože mnoho pozic příznaků může být nastaveno na hodnotu 1, což může vést k matoucímu kódu a podpoře chyb kódování.

  • Pohodlný způsob, jak otestovat, jestli je příznak nastaven v číselné hodnotě, je volat metodu instance HasFlag , jak je znázorněno v následujícím příkladu.

    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.
    

    Je ekvivalentem provádění bitové operace AND mezi číselnou hodnotou a konstantou s výčtem příznaku, která nastaví všechny bity v číselné hodnotě na nulu, která neodpovídá příznaku, a pak testuje, zda výsledek této operace odpovídá výčtové konstantě příznaku. To je znázorněno v následujícím příkladu.

    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.
    
  • Použijte None jako název příznaku výčtu konstanty, jejíž hodnota je nula. Nelze použít výčtovou konstantu None v bitové operaci AND k otestování příznaku, protože výsledek je vždy nula. Můžete ale provést logické, nikoli bitové porovnání číselné hodnoty a None výčtové konstanty, abyste zjistili, zda jsou nastaveny nějaké bity v číselné hodnotě. To je znázorněno v následujícím příkladu.

    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.
    
  • Nedefinujte hodnotu výčtu pouze pro zrcadlení stavu samotné výčtu. Například nedefinujte výčtovou konstantu, která pouze označuje konec výčtu. Pokud potřebujete určit poslední hodnotu výčtu, zkontrolujte tuto hodnotu explicitně. Kromě toho můžete provést kontrolu rozsahu první a poslední výčtové konstanty, pokud jsou všechny hodnoty v rozsahu platné.

Přidání metod výčtu

Vzhledem k tomu, že typy výčtu jsou definovány strukturami jazyka, například enum (C#) a Enum (Visual Basic), nemůžete definovat vlastní metody pro jiný typ výčtu než tyto metody zděděné z Enum třídy. Metody rozšíření ale můžete použít k přidání funkcí do konkrétního typu výčtu.

V následujícím příkladu Grades výčet představuje možné známky, které student může obdržet ve třídě. Do typu se přidá Grades metoda rozšíření s názvemPassing, aby každá instance tohoto typu nyní "věděla", zda představuje známku nebo ne. Třída Extensions obsahuje také statickou proměnnou pro čtení a zápis, která definuje minimální známku. Návratová Passing hodnota metody rozšíření odráží aktuální hodnotu této proměnné.

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

Inicializuje novou instanci Enum třídy.

Metody

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

Format(Type, Object, String)

Převede zadanou hodnotu zadaného výčtového typu na ekvivalentní řetězcové vyjádření podle zadaného formátu.

GetHashCode()

Vrátí kód hash pro hodnotu této instance.

GetName(Type, Object)

Načte název konstanty v zadané výčtu, která má zadanou hodnotu.

GetName<TEnum>(TEnum)

Načte název konstanty v zadaném typu výčtu, který má zadanou hodnotu.

GetNames(Type)

Načte pole názvů konstant v zadaném výčtu.

GetNames<TEnum>()

Načte pole názvů konstant v zadaném typu výčtu.

GetType()

Type Získá aktuální instanci.

(Zděděno od Object)
GetTypeCode()

Vrátí kód typu základního typu tohoto člena výčtu.

GetUnderlyingType(Type)

Vrátí základní typ zadaného výčtu.

GetValues(Type)

Načte pole hodnot konstant v zadaném výčtu.

GetValues<TEnum>()

Načte pole hodnot konstant v zadaném typu výčtu.

HasFlag(Enum)

Určuje, zda jsou v aktuální instanci nastavena jedno nebo více bitových polí.

IsDefined(Type, Object)

Vrátí logickou hodnotu označující, jestli daná integrální hodnota nebo její název jako řetězec existuje v zadaném výčtu.

IsDefined<TEnum>(TEnum)

Vrátí logickou hodnotu označující, jestli daná integrální hodnota nebo její název jako řetězec existuje v zadaném výčtu.

MemberwiseClone()

Vytvoří použádnou kopii aktuálního souboru Object.

(Zděděno od Object)
Parse(Type, ReadOnlySpan<Char>)

Převede rozsah znaků reprezentace názvu nebo číselné hodnoty jedné nebo více výčtových konstant na ekvivalentní výčtový objekt.

Parse(Type, ReadOnlySpan<Char>, Boolean)

Převede rozsah znaků reprezentace názvu nebo číselné hodnoty jedné nebo více výčtových konstant na ekvivalentní výčtový objekt. Parametr určuje, jestli je operace nerozlišující malá a velká písmena.

Parse(Type, String)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.

Parse(Type, String, Boolean)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu. Parametr určuje, jestli je operace nerozlišující malá a velká písmena.

Parse<TEnum>(ReadOnlySpan<Char>)

Převede rozsah znaků reprezentace názvu nebo číselné hodnoty jedné nebo více výčtových konstant určených TEnum ekvivalentním výčtem objektu.

Parse<TEnum>(ReadOnlySpan<Char>, Boolean)

Převede rozsah znaků reprezentace názvu nebo číselné hodnoty jedné nebo více výčtových konstant určených TEnum ekvivalentním výčtem objektu. Parametr určuje, jestli je operace nerozlišující malá a velká písmena.

Parse<TEnum>(String)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo více výčtových konstant určených TEnum na ekvivalentní výčtový objekt.

Parse<TEnum>(String, Boolean)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo více výčtových konstant určených TEnum na ekvivalentní výčtový objekt. Parametr určuje, jestli je operace nerozlišující malá a velká písmena.

ToObject(Type, Byte)

Převede zadané 8bitové celé číslo bez znaménka na člen výčtu.

ToObject(Type, Int16)

Převede zadané 16bitové celé číslo podepsaného na člen výčtu.

ToObject(Type, Int32)

Převede zadané 32bitové celé číslo podepsané na člen výčtu.

ToObject(Type, Int64)

Převede zadané 64bitové celé číslo podepsaného na člen výčtu.

ToObject(Type, Object)

Převede zadaný objekt s celočíselnou hodnotou na člen výčtu.

ToObject(Type, SByte)

Převede zadanou 8bitovou celočíselnou hodnotu na člena výčtu.

ToObject(Type, UInt16)

Převede zadanou 16bitovou celočíselnou hodnotu bez znaménka na člena výčtu.

ToObject(Type, UInt32)

Převede zadanou 32bitovou celočíselnou hodnotu bez znaménka na člen výčtu.

ToObject(Type, UInt64)

Převede zadanou 64bitovou celočíselnou hodnotu bez znaménka na člena výčtu.

ToString()

Převede hodnotu této instance na její odpovídající řetězcovou reprezentaci.

ToString(IFormatProvider)
Zastaralé.
Zastaralé.

Přetížení této metody je zastaralé; použít ToString().

ToString(String)

Převede hodnotu této instance na ekvivalentní řetězcové vyjádření pomocí zadaného formátu.

ToString(String, IFormatProvider)
Zastaralé.
Zastaralé.

Přetížení této metody je zastaralé; použít ToString(String).

TryParse(Type, ReadOnlySpan<Char>, Boolean, Object)

Převede rozsah znaků reprezentace názvu nebo číselné hodnoty jedné nebo více výčtových konstant na ekvivalentní výčtový objekt. Parametr určuje, jestli je operace nerozlišující malá a velká písmena.

TryParse(Type, ReadOnlySpan<Char>, Object)

Převede rozsah znaků reprezentace názvu nebo číselné hodnoty jedné nebo více výčtových konstant na ekvivalentní výčtový objekt.

TryParse(Type, String, Boolean, Object)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.

TryParse(Type, String, Object)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.

TryParse<TEnum>(ReadOnlySpan<Char>, Boolean, TEnum)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu. Parametr určuje, jestli je operace citlivá na malá a malá písmena. Vrácená hodnota označuje, zda převod proběhl úspěšně.

TryParse<TEnum>(ReadOnlySpan<Char>, TEnum)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.

TryParse<TEnum>(String, Boolean, TEnum)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu. Parametr určuje, jestli je operace citlivá na malá a malá písmena. Vrácená hodnota označuje, zda převod proběhl úspěšně.

TryParse<TEnum>(String, TEnum)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu. Vrácená hodnota označuje, zda převod proběhl úspěšně.

Explicitní implementace rozhraní

IConvertible.GetTypeCode()

Vrátí kód typu této Enum instance.

IConvertible.ToBoolean(IFormatProvider)

Převede aktuální hodnotu na logickou hodnotu na základě základního typu.

IConvertible.ToByte(IFormatProvider)

Převede aktuální hodnotu na 8bitové celé číslo bez znaménka na základě podkladového typu.

IConvertible.ToChar(IFormatProvider)

Převede aktuální hodnotu na znak Unicode na základě základního typu.

IConvertible.ToDateTime(IFormatProvider)

Převede aktuální hodnotu na DateTime základě základního typu.

IConvertible.ToDecimal(IFormatProvider)

Převede aktuální hodnotu na Decimal základě základního typu.

IConvertible.ToDouble(IFormatProvider)

Převede aktuální hodnotu na číslo s plovoucí desetinou čárkou na základě základního typu.

IConvertible.ToInt16(IFormatProvider)

Převede aktuální hodnotu na 16bitové celé číslo podepsané na základě základního typu.

IConvertible.ToInt32(IFormatProvider)

Převede aktuální hodnotu na 32bitové celé číslo podepsané na základě základního typu.

IConvertible.ToInt64(IFormatProvider)

Převede aktuální hodnotu na 64bitové celé číslo podepsané na základě základního typu.

IConvertible.ToSByte(IFormatProvider)

Převede aktuální hodnotu na 8bitové celé číslo podepsané na základě základního typu.

IConvertible.ToSingle(IFormatProvider)

Převede aktuální hodnotu na jednopřesné číslo s plovoucí desetinou čárkou na základě základního typu.

IConvertible.ToString(IFormatProvider)
Zastaralé.

Přetížení této metody je zastaralé; místo toho použijte ToString() .

IConvertible.ToType(Type, IFormatProvider)

Převede aktuální hodnotu na zadaný typ na základě základního typu.

IConvertible.ToUInt16(IFormatProvider)

Převede aktuální hodnotu na 16bitové celé číslo bez znaménka na základě podkladového typu.

IConvertible.ToUInt32(IFormatProvider)

Převede aktuální hodnotu na 32bitové celé číslo bez znaménka na základě základního typu.

IConvertible.ToUInt64(IFormatProvider)

Převede aktuální hodnotu na 64bitové celé číslo bez znaménka na základě základního typu.

IFormattable.ToString(String, IFormatProvider)
Zastaralé.

Přetížení této metody je zastaralé; použít ToString(String).

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.

Viz také