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šího výčtu pro reprezentaci pojmenovaných bitových polí.

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

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

[Flags]

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

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

   Console::WriteLine();
   Console::WriteLine(  "Enums can also be created which have values that represent some meaningful amount." );
   Console::WriteLine(  "The BoilingPoints Enum defines the following items, and corresponding values:" );
   i = 0;
   Array^ b = Enum::GetNames( boiling );
   do
   {
      Object^ o = b->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( boiling, Enum::Parse( boiling, o->ToString() ),  "d" ) );
   }
   while ( ++i < b->Length );

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

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [Flags]
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static void Main() {

        Type weekdays = typeof(Days);
        Type boiling = typeof(BoilingPoints);

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

        foreach ( string s in Enum.GetNames(weekdays) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format( weekdays, Enum.Parse(weekdays, s), "d"));

        Console.WriteLine();
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.");
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:");

        foreach ( string s in Enum.GetNames(boiling) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format(boiling, Enum.Parse(boiling, s), "d"));

        Colors myColors = Colors.Red | Colors.Blue | Colors.Yellow;
        Console.WriteLine();
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors);
    }
}
Public Class EnumTest
    Enum Days
        Saturday
        Sunday
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
    End Enum 
    
    Enum BoilingPoints
        Celsius = 100
        Fahrenheit = 212
    End Enum 
    
    <Flags()> _
    Enum Colors
        Red = 1
        Green = 2
        Blue = 4
        Yellow = 8
    End Enum 

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

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

        Dim s As String
        For Each s In  [Enum].GetNames(weekdays)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(weekdays, [Enum].Parse(weekdays, s), "d"))
        
        Next s
        Console.WriteLine()
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.")
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:")

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

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

Poznámky

Výčet je sada pojmenovaných konstant, jejichž podkladový typ je celočíselného typu. Pokud není explicitně deklarován žádný základní typ, Int32 je použit. Enumje základní třída pro všechny výčty v .NET Framework. Výčtové typy jsou definovány klíčovým enum slovem v jazyce C# a Enum konstruktorem ... End Enum v Visual Basic.

Enum poskytuje metody pro porovná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ého výčtu a hodnoty.

Výčet lze také považovat za bitové pole. Další informace najdete v části Ne exclusive Members and the Flags Attribute a v tématu FlagsAttribute .

V tomto tématu:

Vytvoření výčtu typu Vytvoření instance výčtu typu Osvědčené postupy výčet osvědčené postupy Provádění operací s výčty Provádění převodů Parsování hodnot výčtu Formátování hodnot výčtu Iteracečlenů výčtu Nevýlučné členy a atribut FlagsPřidání metod výčtu

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 ukazuje syntaxi, kterou jazyk C# a Visual Basic k definování výčtu. Vytvoří výčet s názvem ArrivalStatus , který má tři členy: , a ArrivalStatus.Early ArrivalStatus.OnTime ArrivalStatus.Late . Všimněte si, že v obou případech výčet explicitně nezdědí z . Vztah dědičnosti je zpracováván Enum implicitně kompilátorem.

public enum 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 vytvářet typ výčtu, jehož podkladový typ není celočíselné nebo Char . Přestože lze 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

Instanci typu výčtu můžete vytvořit stejně jako při vytváření instance jiného typu hodnoty: deklarováním proměnné a přiřazením jedné z konstant výčtu. 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)
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)

Můžete také vytvořit instanci hodnoty výčtu 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 Visual Basic) celočíselné hodnoty na hodnotu výčtu. Následující příklad vytvoří ArrivalStatus objekt, jehož hodnota ArrivalStatus.Early je 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)
    
    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. To však nemusí nutně představovat hodnotu 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)
    
    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 Parse metody nebo pro parsování řetězce, který obsahuje TryParse název konstanty ve výčtu. Další informace najdete v části Analýza hodnot výčtu.

  • Voláním ToObject metody převedete 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žívat následující osvědčené postupy:

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

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

  • Nezadáte výčtové konstanty, které jsou vyhrazené 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 v případě, že tato číselná hodnota není definována ve výčtu.

Další osvědčené postupy pro typy výčtů, jejichž konstanty jsou bitová pole, jsou uvedeny v části Ne exclusive Members a Flags Attribute.

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 a instancí metod z Enum třídy . V následujících částech se většina těchto metod kromě několika dalších metod, které se běžně používají při práci s hodnotami výčtu, prošly.

Provádění převodů

Převod mezi členem výčtu a jeho podkladovým typem můžete provést pomocí přetypování (v jazyce C#) nebo převodu (v Visual Basic). Následující příklad používá operátory přetypování nebo převodu k převodu z celého čísla na hodnotu výčtu i z hodnoty výčtu na celé číslo.

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

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

Dim value4 As Integer = CInt(status3)

Třída Enum obsahuje také ToObject metodu, která převede hodnotu celočíselného typu na hodnotu výčtu. Následující příklad používá ToObject(Type, Int32) metodu k převodu typu Int32 na ArrivalStatus hodnotu. Všimněte si, že vzhledem k tomu, že vrací hodnotu typu , může být použití operátoru přetypování nebo převodu stále nezbytné k přetypování objektu ToObject Object na typ výčtu.

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

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

I když třída poskytuje explicitní implementace rozhraní pro převod z hodnoty výčtu na celočíselného typu, měli byste použít metody třídy, například , k provedení Enum IConvertible těchto Convert ToInt32 převodů. Následující příklad ukazuje, jak lze použít metodu spolu s metodou k převodu hodnoty výčtu GetUnderlyingType Convert.ChangeType na její 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
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

Metody Parse TryParse a umožňují převést řetězcové vyjádření hodnoty výčtu na hodnotu. Řetězcová reprezentace 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é vyjádření čísel, která nejsou členy konkrétního výčtu, pokud lze řetězce převést na hodnotu základního typu výčtu. Chcete-li tomu zabránit, je možné volat metodu , aby se zajistilo, že výsledek metody analýzy IsDefined je platná hodnota výčtu. Příklad tento přístup ilustruje a ukazuje volání metod Parse(Type, String) Enum.TryParse<TEnum>(String, TEnum) i . Všimněte si, že neobecná metoda analýzy vrátí objekt, který možná budete muset přetypovat (v jazyce C#) 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
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 lze převést na jejich řetězcové reprezentace voláním statické metody a také Format přetížením metody ToString instance. Ř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 najdete 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 členu výčtu na jeho ArrivalStatus ř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
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 rozhraní nebo , které by vám umožnilo iterovat členy kolekce pomocí konstruktoru (v jazyce Enum IEnumerable IEnumerable<T> foreach C#) For Each nebo (v Visual Basic). Výčet členů ale můžete provést dvěma způsoby.

  • Voláním metody GetNames můžete načíst pole řetězců obsahující názvy členů výčtu. Dále můžete pro každý prvek pole řetězců zavolat metodu a převést Parse řetězec na 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)
    
    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)
    
  • Voláním metody GetValues můžete načíst pole, které obsahuje základní hodnoty ve výčtu. Dále můžete pro každý prvek pole zavolat metodu , která převede celé číslo ToObject 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)
    
    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)
    

Členy, které nejsou výhradní, a atribut Flags

Jedním z běžných použití výčtu je reprezentace sady vzájemně se vylučující hodnoty. Instance může ArrivalStatus mít například hodnotu Early , OnTime nebo Late . Nemá smysl, aby hodnota instance odrážela více než ArrivalStatus 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 s názvem může být použit k označení druhů domácích mazlíčků Pets v domácnosti. Můžete 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> Public Enum Pets As Integer
   None = 0
   Dog = 1
   Cat = 2
   Bird = 4
   Rodent = 8
   Reptile = 16
   Other = 32
End Enum

Výčet Pets lze poté 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)
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)

Následující osvědčené postupy byste měli použít při definování bitové výčtu a použití FlagsAttribute atributu.

  • Vlastní atribut použijte pro výčet pouze v případě, že je pro číselnou hodnotu provedena bitové operace FlagsAttribute (AND, OR, EXCLUSIVE OR).

  • Definujte konstanty výčtu ve mocnách dvou mocn, tedy 1, 2, 4, 8 atd. To znamená, že jednotlivé příznaky v kombinovaných konstantách výčtu 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žitý pro souborové V/V operace, které obsahují výčtové konstanty a , zvažte vytvoření výčtové konstanty , která kombinuje příznaky a Read = 1 Write = 2 ReadWrite = Read OR Write Read Write . Kromě toho může být bitový operátor OR použitý ke kombinování příznaků v některých případech považován za pokročilý koncept, který by neměl být vyžadován pro jednoduché úlohy.

  • Buďte opatrní, pokud jako konstantu výčtu příznaku definujete záporné číslo, protože mnoho pozic příznaků může být nastaveno na hodnotu 1, což může kód zmást a podněcovat chyby kódování.

  • Pohodlným způsobem, jak otestovat, jestli je příznak nastavený v číselné hodnotě, je volání metody instance, jak HasFlag 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.
    
    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í k provedení bitové operace AND mezi číselnou hodnotou a konstantou výčtu příznaků, která nastaví všechny bity číselné hodnoty na nulu, které neodpovídají příznaku, a pak otestuje, zda je výsledek této operace roven konstantě výčtu 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.
    
    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 výčtové konstanty příznaku, jejíž hodnota je nula. Výčtovou konstantu nelze použít v bitové operaci AND k otestování příznaku, protože None výsledek je vždy nula. NoneK určení, zda jsou nastaveny jakékoli bity číselné hodnoty, však lze provést logickou, ne bitovou, porovnání mezi číselnou hodnotou a výčtovou konstantou. 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.
    
    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ého výčtu. Nedefinujte například výčtovou konstantu, která pouze označí konec výčtu. Pokud potřebujete určit poslední hodnotu výčtu, zkontrolujte tuto hodnotu explicitně. Kromě toho můžete provést kontrolu rozsahu pro první a poslední výčtovou konstantu, pokud jsou všechny hodnoty v rozsahu platné.

Přidání metod výčtu

vzhledem k tomu, že výčtové typy jsou definovány jazykovými strukturami, jako je například enum (C#) a Enum (Visual Basic), nelze definovat vlastní metody pro typ výčtu jiný než metody zděděné z Enum třídy. Můžete však použít rozšiřující metody pro přidání funkcionality do konkrétního výčtového typu.

V následujícím příkladu Grades výčet představuje možné známky, které může student získat ve třídě. Rozšiřující metoda s názvem Passing je přidána do Grades typu tak, že každá instance daného typu teď "ví", zda představuje třídu předání nebo ne. ExtensionsTřída také obsahuje statickou proměnnou pro čtení a zápis, která definuje minimální stupeň předávání. Návratová hodnota Passing 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.
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 odpovídající řetězcovou reprezentaci podle zadaného formátu.

GetHashCode()

Vrátí hodnotu hash hodnoty této instance.

GetName(Type, Object)

Načte název konstanty v zadaném 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 členu 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 je v aktuální instanci nastaveno jedno nebo více bitových polí.

IsDefined(Type, Object)

Vrátí logickou hodnotu určující, zda zadaná celočíselné hodnoty nebo její název jako řetězec existuje v zadaném výčtu.

IsDefined<TEnum>(TEnum)

Vrátí logickou hodnotu určující, zda zadaná celočíselné hodnoty 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 operace bez rozlišení velkých a malých písmen.

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 operace bez rozlišení velkých a malých písmen.

Parse<TEnum>(ReadOnlySpan<Char>)

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

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

Převede rozsah znaků reprezentace názvu nebo číselné hodnoty jedné nebo více výčtových konstant zadaných pomocí na TEnum ekvivalentní výčtový objekt. Parametr určuje, jestli operace bez rozlišení velkých a malých písmen.

Parse<TEnum>(String)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo více výčtových konstant zadaných pomocí na TEnum 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 zadaných pomocí na TEnum ekvivalentní výčtový objekt. Parametr určuje, jestli operace bez rozlišení velkých a malých písmen.

ToObject(Type, Byte)

Převede zadanou 8bitovou verzi unsigned integer na člen výčtu.

ToObject(Type, Int16)

Převede zadané 16bitové celé číslo se znaménkem na člen výčtu.

ToObject(Type, Int32)

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

ToObject(Type, Int64)

Převede zadané 64bitové celé číslo se znaménkem 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 hodnotu 8bitového celého čísla se znaménkem na člen výčtu.

ToObject(Type, UInt16)

Převede zadanou 16bitovou unsigned integer na člena výčtu.

ToObject(Type, UInt32)

Převede zadanou 32bitovou unsigned integer na člena výčtu.

ToObject(Type, UInt64)

Převede zadanou 64bitovou unsigned integer na člena výčtu.

ToString()

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

ToString(IFormatProvider)
Zastaralé.
Zastaralé.

Toto přetížení metody je zastaralé. použijte ToString() .

ToString(String)

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

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

Toto přetížení metody je zastaralé; použijte 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, zda se u operace nerozlišují velká a malá 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, zda se u operace rozlišují velká 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, zda se u operace rozlišují velká 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ě podkladového typu.

IConvertible.ToByte(IFormatProvider)

Převede aktuální hodnotu na 8bitovou verzi unsigned integer na základě podkladového typu.

IConvertible.ToChar(IFormatProvider)

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

IConvertible.ToDateTime(IFormatProvider)

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

IConvertible.ToDecimal(IFormatProvider)

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

IConvertible.ToDouble(IFormatProvider)

Převede aktuální hodnotu na číslo s plovoucí desetinnou čárkou s dvojitou přesností na základě podkladového typu.

IConvertible.ToInt16(IFormatProvider)

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

IConvertible.ToInt32(IFormatProvider)

Převede aktuální hodnotu na 32bitové celé číslo se znaménkem na základě podkladového typu.

IConvertible.ToInt64(IFormatProvider)

Převede aktuální hodnotu na 64bitové celé číslo se znaménkem na základě podkladového typu.

IConvertible.ToSByte(IFormatProvider)

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

IConvertible.ToSingle(IFormatProvider)

Převede aktuální hodnotu na číslo s plovoucí desetinnou čárkou s jednou přesností na základě podkladového typu.

IConvertible.ToString(IFormatProvider)
Zastaralé.

Toto přetížení metody je zastaralé. místo ToString() toho použijte .

IConvertible.ToType(Type, IFormatProvider)

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

IConvertible.ToUInt16(IFormatProvider)

Převede aktuální hodnotu na 16bitovou verzi unsigned integer na základě podkladového typu.

IConvertible.ToUInt32(IFormatProvider)

Převede aktuální hodnotu na 32bitovou verzi unsigned integer na základě podkladového typu.

IConvertible.ToUInt64(IFormatProvider)

Převede aktuální hodnotu na 64bitovou verzi unsigned integer na základě podkladového typu.

IFormattable.ToString(String, IFormatProvider)
Zastaralé.

Toto přetížení metody je zastaralé. použijte 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é