System.Enum – třída

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Výčet je sada pojmenovaných konstant, jejichž základní typ je jakýkoli celočíselný typ. Pokud není explicitně deklarován žádný základní typ, Int32 použije se. Enum je základní třída pro všechny výčty v .NET. Typy výčtu enum jsou definovány klíčovým slovem v jazyce C#, Enumkonstruktorem ...End Enum v jazyce 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é reprezentace, převod řetězcové reprezentace čísla na instanci této třídy a vytvoření instance zadaného výčtu a hodnoty.

Výčet můžete také považovat za bitové pole. Další informace naleznete v části Nevýlučné členy a atribut Flags aFlagsAttribute.

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 { Unknown=-3, Late=-1, OnTime=0, Early=1 };

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

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

Upozorňující

Nikdy byste neměli vytvářet typ výčtu, jehož základní typ není celočíselný nebo Char. I když můžete takový typ výčtu vytvořit pomocí reflexe, volání metod, 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í. Následující příklad vytvoří instanci, jejíž ArrivalStatus 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 Example1
    Public Sub Main()
        Dim status As ArrivalStatus1 = ArrivalStatus1.OnTime
        Console.WriteLine("Arrival Status: {0} ({0:D})", status)
    End Sub
End Module
' The example displays the following output:
'        Arrival Status: OnTime (0)

Můžete také vytvořit instanci výčtové hodnoty 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 celočíselné hodnoty (jako v jazyce Visual Basic) 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 ArrivalStatus2 = CType(1, ArrivalStatus2)
  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 základní hodnota instance výčtu 0. To však nemusí nutně být hodnota platné konstanty ve 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 ArrivalStatus2()
  Console.WriteLine("Arrival Status: {0} ({0:D})", status1)
  ' The example displays the following output:
  '        Arrival Status: OnTime (0)
  

• Voláním Parse metody nebo TryParse parsování řetězce, který obsahuje název konstanty ve výčtu. Další informace naleznete v části Parse výčtové hodnoty .

• Voláním ToObject metody pro převod celočíselné hodnoty na typ výčtu. Další informace najdete v části Provést převody .

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žívaná 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 k určení případu, který není reprezentován žádnou z ostatních výčtových konstant.

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

• Při definování metody nebo vlastnosti, 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 ve 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. Následující části se seznámí s většinou těchto metod, 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í přetypování (v jazyce C# a F#) nebo převodu (v jazyce Visual Basic). V jazyce F# se enum 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 ArrivalStatus2 = CType(value3, ArrivalStatus2)

Dim value4 As Integer = CInt(status3)

Třída Enum také obsahuje metodu ToObject , která převádí hodnotu libovolného celočíselného typu na hodnotu výčtu. Následující příklad používá metodu ToObject(Type, Int32) k převodu na Int32ArrivalStatus 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 ArrivalStatus2 = CType(ArrivalStatus2.ToObject(GetType(ArrivalStatus2), number), ArrivalStatus2)

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 class Example3
{
    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 ArrivalStatus4 As Integer
    Unknown = -3
    Late = -1
    OnTime = 0
    Early = 1
End Enum

Module Example4
    Public Sub Main()
        Dim values() As Integer = {-3, -1, 0, 1, 5, Int32.MaxValue}
        For Each value In values
            Dim status As ArrivalStatus4
            If [Enum].IsDefined(GetType(ArrivalStatus4), value) Then
                status = CType(value, ArrivalStatus4)
            Else
                status = ArrivalStatus4.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 výčtu hodnoty 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 Convert.ChangeType k převodu hodnoty výčtu na jeho základní typ. Všimněte si, že tento příklad nevyžaduje, aby byl základní typ výčtu známý v době kompilace.

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 ArrivalStatus5 = ArrivalStatus5.Early
Dim number = Convert.ChangeType(status, [Enum].GetUnderlyingType(GetType(ArrivalStatus5)))
Console.WriteLine("Converted {0} to {1}", status, number)
' The example displays the following output:
'       Converted Early to 1

Parsovat hodnoty 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 buď 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 volat metodu IsDefined , aby se zajistilo, že výsledek metody analýzy je platná hodnota výčtu. Tento přístup ukazuje příklad a ukazuje volání Parse(Type, String) metod i Enum.TryParse<TEnum>(String, TEnum) metod. Všimněte si, že ne generická metoda analýzy vrací objekt, který může být nutné přetypovat (v jazyce C# a F#) nebo převést (v jazyce 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 ArrivalStatus8 = CType([Enum].Parse(GetType(ArrivalStatus8), number), ArrivalStatus8)
    If Not [Enum].IsDefined(GetType(ArrivalStatus8), status1) Then status1 = ArrivalStatus8.Unknown
    Console.WriteLine("Converted '{0}' to {1}", number, status1)
Catch e As FormatException
    Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus8 value.",
                   number)
End Try

Dim status2 As ArrivalStatus8
If [Enum].TryParse(Of ArrivalStatus8)(name, status2) Then
    If Not [Enum].IsDefined(GetType(ArrivalStatus8), status2) Then status2 = ArrivalStatus8.Unknown
    Console.WriteLine("Converted '{0}' to {1}", name, status2)
Else
    Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus8 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, stejně jako 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 Výčtové formátovací řetězce. 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 výčtu ArrivalStatus 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 ArrivalStatus6 = ArrivalStatus6.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 – členy výčtu

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

• Můžete volat metodu GetNames pro načtení pole řetězců obsahující názvy členů výčtu. Dále pro každý prvek pole řetězců 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(ArrivalStatus7))
  Console.WriteLine("Members of {0}:", GetType(ArrivalStatus7).Name)
  Array.Sort(names)
  For Each name In names
      Dim status As ArrivalStatus7 = CType([Enum].Parse(GetType(ArrivalStatus7), name),
                                 ArrivalStatus7)
      Console.WriteLine("   {0} ({0:D})", status)
  Next
  ' The example displays the following output:
  '       Members of ArrivalStatus7:
  '          Early (1)
  '          Late (-1)
  '          OnTime (0)
  '          Unknown (-3)
  

• Můžete volat metodu GetValues pro 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 jeho 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(ArrivalStatus7))
  Console.WriteLine("Members of {0}:", GetType(ArrivalStatus7).Name)
  For Each value In values
      Dim status As ArrivalStatus7 = CType([Enum].ToObject(GetType(ArrivalStatus7), value),
                                       ArrivalStatus7)
      Console.WriteLine("   {0} ({0:D})", status)
  Next
  ' The example displays the following output:
  '       Members of ArrivalStatus7:
  '          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. Například ArrivalStatus instance může mít hodnotu Early, OnTimenebo 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 ho 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 pak lze 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 je pro číselnou hodnotu provedena 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ů v některých případech považována za pokročilý koncept, který by neměl být vyžadován 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 kód matoucí a podpořit chyby kódování.

• Pohodlný způsob, jak otestovat, jestli je příznak nastaven v číselné hodnotě, je volání metody 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 ekvivalentní provedení bitové operace AND mezi číselnou hodnotou a výčtovou konstantou 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.
  

• Slouží None jako název výčtové konstanty příznaku, jejíž hodnota je nula. Výčtovou konstantu None v bitové operaci AND nelze použít k otestování příznaku, protože výsledek je vždy nula. Můžete ale provést logickou, nikoli bitovou porovnávání číselné hodnoty a None výčtové konstanty, abyste zjistili, jestli jsou některé bity v číselné hodnotě nastaveny. 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 výhradně 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), nelze definovat vlastní metody pro typ výčtu jiné než tyto metody zděděné z Enum třídy. Metody rozšíření však 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 dopisu, které student může obdržet ve třídě. Do typu je přidána Grades metoda rozšíření s názvemPassing, takže každá instance tohoto typu nyní "ví", zda představuje známku, nebo ne. Třída Extensions obsahuje také statickou proměnnou pro čtení i 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 Example8
{
    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.

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