Enum Classe

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Fornece a classe base para enumerações.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable

public ref class Enum abstract : ValueType, IComparable, IConvertible, ISpanFormattable

public ref class Enum abstract : ValueType, IComparable, IFormattable

public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable

public abstract class Enum : ValueType, IComparable, IConvertible, ISpanFormattable

[System.Serializable]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable

public abstract class Enum : ValueType, IComparable, IFormattable

type Enum = class
    inherit ValueType
    interface IComparable
    interface IConvertible
    interface IFormattable

type Enum = class
    inherit ValueType
    interface IComparable
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

[<System.Serializable>]
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible

type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable

Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, IFormattable

Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, ISpanFormattable

Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IFormattable

Herança: Object

ValueType
Enum

Derivado: Accessibility.AnnoScope

Microsoft.Aspnet.Snapin.MMC_CONTROL_TYPE

Microsoft.CSharp.ErrorLevel

Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags

Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags

Mais…

Atributos: SerializableAttribute ComVisibleAttribute

Implementações: IComparable IConvertible IFormattable ISpanFormattable

Exemplos

O exemplo a seguir demonstra o uso de uma enumeração para representar valores nomeados e outra enumeração para representar campos de bit nomeados.

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

Comentários

Uma enumeração é um conjunto de constantes nomeadas cujo tipo subjacente é qualquer tipo integral. Se nenhum tipo subjacente for declarado explicitamente, Int32 será usado. Enumé a classe base para todas as enumerações no .NET Framework. Os tipos de enumeração são definidos pelo enum palavra-chave em C#, o Enumconstructo ...End Enum no Visual Basic e o type palavra-chave em F#.

Enum fornece métodos para comparar instâncias dessa classe, converter o valor de uma instância em sua representação de cadeia de caracteres, converter a representação de cadeia de caracteres de um número em uma instância dessa classe e criar uma instância de uma enumeração e valor especificados.

Você também pode tratar uma enumeração como um campo de bits. Para obter mais informações, consulte a seção Membros não Exclusivos e o Atributo Flags e o FlagsAttribute tópico.

Neste tópico:

Criando um tipo de enumeração Instanciando um tipo de enumeração Práticas recomendadas de enumeração Executando operações com enumerações Executando conversões Analisando valores de enumeração Formatação de valores de enumeração Valores de enumeração Iterando membros de enumeração Membros não exclusivos e o atributo Flags Adicionando métodos de enumeração

Criando um tipo de enumeração

As linguagens de programação normalmente fornecem sintaxe para declarar uma enumeração que consiste em um conjunto de constantes nomeadas e seus valores. O exemplo a seguir ilustra a sintaxe usada por C#, F#e Visual Basic para definir uma enumeração. Ele cria uma enumeração chamada ArrivalStatus que tem três membros: ArrivalStatus.Early, ArrivalStatus.OnTimee ArrivalStatus.Late. Observe que, em todos os casos, a enumeração não herda explicitamente de ; a relação de Enumherança é tratada implicitamente pelo compilador.

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

Aviso

Você nunca deve criar um tipo de enumeração cujo tipo subjacente não seja integral ou Char. Embora você possa criar esse tipo de enumeração usando reflexão, as chamadas de método que usam o tipo resultante não são confiáveis e também podem gerar exceções adicionais.

Instanciando um tipo de enumeração

Você pode instanciar um tipo de enumeração assim como instancia qualquer outro tipo de valor: declarando uma variável e atribuindo uma das constantes da enumeração a ela. O exemplo a seguir cria uma instância de um ArrivalStatus cujo valor é 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)

Você também pode instanciar um valor de enumeração das seguintes maneiras:

Usando recursos de uma linguagem de programação específica para converter (como em C#) ou converter (como no Visual Basic) um valor inteiro em um valor de enumeração. O exemplo a seguir cria um ArrivalStatus objeto cujo valor está ArrivalStatus.Early dessa forma.

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)

Chamando seu construtor implícito sem parâmetros. Como mostra o exemplo a seguir, nesse caso, o valor subjacente da instância de enumeração é 0. No entanto, esse não é necessariamente o valor de uma constante válida na enumeração .

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)

Chamando o Parse método ou TryParse para analisar uma cadeia de caracteres que contém o nome de uma constante na enumeração. Para obter mais informações, consulte a seção Analisando valores de enumeração .
Chamando o ToObject método para converter um valor integral em um tipo de enumeração. Para obter mais informações, consulte a seção Executando conversões .

Práticas recomendadas de enumeração

Recomendamos que você use as seguintes práticas recomendadas ao definir tipos de enumeração:

Se você não tiver definido um membro de enumeração cujo valor é 0, considere criar uma None constante enumerada. Por padrão, a memória usada para a enumeração é inicializada como zero pelo Common Language Runtime. Consequentemente, se você não definir uma constante cujo valor é zero, a enumeração conterá um valor inválido quando ele for criado.
Se houver um caso padrão óbvio que seu aplicativo precisa representar, considere usar uma constante enumerada cujo valor é zero para representá-lo. Se não houver nenhum caso padrão, considere usar uma constante enumerada cujo valor é zero para especificar o caso que não é representado por nenhuma das outras constantes enumeradas.
Não especifique constantes enumeradas reservadas para uso futuro.
Ao definir um método ou propriedade que usa uma constante enumerada como um valor, considere validar o valor. O motivo é que você pode converter um valor numérico para o tipo de enumeração mesmo que esse valor numérico não esteja definido na enumeração .

Práticas recomendadas adicionais para tipos de enumeração cujas constantes são campos de bits são listadas na seção Membros Não Exclusivos e atributo Flags .

Executando operações com enumerações

Você não pode definir novos métodos ao criar uma enumeração. No entanto, um tipo de enumeração herda um conjunto completo de métodos estáticos e de instância da Enum classe . As seções a seguir pesquisam a maioria desses métodos, além de vários outros métodos que são comumente usados ao trabalhar com valores de enumeração.

Executando conversões

Você pode converter entre um membro de enumeração e seu tipo subjacente usando uma conversão (em C# e F#) ou um operador de conversão (no Visual Basic). Em F#, a enum função também é usada. O exemplo a seguir usa operadores de conversão ou conversão para executar conversões de um inteiro em um valor de enumeração e de um valor de enumeração para um inteiro.

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)

A Enum classe também inclui um ToObject método que converte um valor de qualquer tipo integral em um valor de enumeração. O exemplo a seguir usa o ToObject(Type, Int32) método para converter um Int32 em um ArrivalStatus valor . Observe que, como o ToObject retorna um valor do tipo Object, o uso de um operador de conversão ou conversão ainda pode ser necessário para converter o objeto no tipo de enumeração.

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)

Ao converter um inteiro em um valor de enumeração, é possível atribuir um valor que não seja realmente um membro da enumeração. Para evitar isso, você pode passar o inteiro para o IsDefined método antes de executar a conversão. O exemplo a seguir usa esse método para determinar se os elementos em uma matriz de valores inteiros podem ser convertidos ArrivalStatus em valores.

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

Embora a Enum classe forneça implementações de interface explícitas da IConvertible interface para converter de um valor de enumeração em um tipo integral, você deve usar os métodos da Convert classe, como ToInt32, para executar essas conversões. O exemplo a seguir ilustra como você pode usar o GetUnderlyingType método junto com o Convert.ChangeType método para converter um valor de enumeração em seu tipo subjacente. Observe que este exemplo não exige que o tipo subjacente da enumeração seja conhecido em tempo de compilação.

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

Analisando valores de enumeração

Os Parse métodos e TryParse permitem converter a representação de cadeia de caracteres de um valor de enumeração nesse valor. A representação de cadeia de caracteres pode ser o nome ou o valor subjacente de uma constante de enumeração. Observe que os métodos de análise converterão com êxito representações de cadeia de caracteres de números que não são membros de uma enumeração específica se as cadeias de caracteres puderem ser convertidas em um valor do tipo subjacente da enumeração. Para evitar isso, o IsDefined método pode ser chamado para garantir que o resultado do método de análise seja um valor de enumeração válido. O exemplo ilustra essa abordagem e demonstra chamadas para os Parse(Type, String) métodos e Enum.TryParse<TEnum>(String, TEnum) . Observe que o método de análise não genérico retorna um objeto que talvez seja necessário converter (em C# e F#) ou converter (no Visual Basic) para o tipo de enumeração apropriado.

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

Formatação de valores de enumeração

Você pode converter valores de enumeração em suas representações de cadeia de caracteres chamando o método estático Format , bem como as sobrecargas do método de instância ToString . Você pode usar uma cadeia de caracteres de formato para controlar a maneira precisa como um valor de enumeração é representado como uma cadeia de caracteres. Para obter mais informações, consulte Cadeias de caracteres de formato de enumeração. O exemplo a seguir usa cada uma das cadeias de caracteres de formato de enumeração com suporte ("G" ou "g", "D" ou "d", "X" ou "x" e "F" ou "f" ) para converter um membro da ArrivalStatus enumeração em suas representações de cadeia de caracteres.

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

Iterando membros de enumeração

O Enum tipo não implementa a IEnumerable interface ou IEnumerable<T> , o que permitiria iterar membros de uma coleção usando um foreach constructo (em C#), for..in (em F#) ou For Each (no Visual Basic). No entanto, você pode enumerar membros de duas maneiras.

Você pode chamar o GetNames método para recuperar uma matriz de cadeia de caracteres que contém os nomes dos membros de enumeração. Em seguida, para cada elemento da matriz de cadeia de caracteres, você pode chamar o Parse método para converter a cadeia de caracteres em seu valor de enumeração equivalente. O exemplo a seguir ilustra esta abordagem.

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)

Você pode chamar o GetValues método para recuperar uma matriz que contém os valores subjacentes na enumeração . Em seguida, para cada elemento da matriz, você pode chamar o ToObject método para converter o inteiro em seu valor de enumeração equivalente. O exemplo a seguir ilustra esta abordagem.

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)

Membros não exclusivos e o atributo Flags

Um uso comum de uma enumeração é representar um conjunto de valores mutuamente exclusivos. Por exemplo, uma ArrivalStatus instância pode ter um valor de Early, OnTimeou Late. Não faz sentido que o valor de uma ArrivalStatus instância reflita mais de uma constante de enumeração.

Em outros casos, no entanto, o valor de um objeto de enumeração pode incluir vários membros de enumeração e cada membro representa um campo de bits no valor de enumeração. O FlagsAttribute atributo pode ser usado para indicar que a enumeração consiste em campos de bits. Por exemplo, uma enumeração chamada Pets pode ser usada para indicar os tipos de animais de estimação em uma casa. Ele pode ser definido da seguinte maneira.

[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

A Pets enumeração pode ser usada, conforme mostrado no exemplo a seguir.

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)

As práticas recomendadas a seguir devem ser usadas ao definir uma enumeração bit a bit e aplicar o FlagsAttribute atributo .

Use o FlagsAttribute atributo personalizado para uma enumeração somente se uma operação bit a bit (AND, OR, EXCLUSIVE OR) for executada em um valor numérico.
Defina constantes de enumeração em potências de dois, ou seja, 1, 2, 4, 8 e assim por diante. Isso significa que os sinalizadores individuais em constantes de enumeração combinadas não se sobrepõem.
Considere criar uma constante enumerada para combinações de sinalizador comumente usadas. Por exemplo, se você tiver uma enumeração usada para operações de E/S de arquivo que contém as constantes Read = 1 enumeradas e Write = 2, considere criar a constante ReadWrite = Read OR Writeenumerada , que combina os Read sinalizadores e Write . Além disso, a operação OR bit a bit usada para combinar os sinalizadores pode ser considerada um conceito avançado em algumas circunstâncias que não deve ser necessária para tarefas simples.
Tenha cuidado se você definir um número negativo como uma constante enumerada de sinalizador porque muitas posições de sinalizador podem ser definidas como 1, o que pode tornar seu código confuso e incentivar erros de codificação.

Uma maneira conveniente de testar se um sinalizador é definido em um valor numérico é chamar o método de instância HasFlag , conforme mostrado no exemplo a seguir.

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.

É equivalente a executar uma operação AND bit a bit entre o valor numérico e a constante enumerada do sinalizador, que define todos os bits no valor numérico como zero que não correspondem ao sinalizador e, em seguida, testar se o resultado dessa operação é igual à constante enumerada do sinalizador. Isso é ilustrado no exemplo a seguir.

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.

Use None como o nome da constante enumerada do sinalizador cujo valor é zero. Você não pode usar a None constante enumerada em uma operação AND bit a bit para testar um sinalizador porque o resultado é sempre zero. No entanto, você pode executar uma comparação lógica, não bit a bit, entre o valor numérico e a None constante enumerada para determinar se algum bit no valor numérico está definido. Isso é ilustrado no exemplo a seguir.

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.

Não defina um valor de enumeração apenas para espelho o estado da própria enumeração. Por exemplo, não defina uma constante enumerada que apenas marque o final da enumeração. Se você precisar determinar o último valor da enumeração, marcar para esse valor explicitamente. Além disso, você pode executar um intervalo marcar para a primeira e a última constante enumerada se todos os valores dentro do intervalo forem válidos.

Adicionando métodos de enumeração

Como os tipos de enumeração são definidos por estruturas de linguagem, como enum (C#) e Enum (Visual Basic), você não pode definir métodos personalizados para um tipo de enumeração diferente daqueles métodos herdados da Enum classe . No entanto, você pode usar métodos de extensão para adicionar funcionalidade a um tipo de enumeração específico.

No exemplo a seguir, a enumeração Grades representa as letras possíveis que um aluno pode receber em uma classe. Um método de extensão chamado Passing é adicionado ao tipo Grades de forma que cada instância desse tipo agora "sabe" se ele representa uma nota de aprovação ou não. A Extensions classe também contém uma variável estática de leitura/gravação que define a nota mínima de aprovação. O valor retornado do Passing método de extensão reflete o valor atual dessa variável.

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.

Construtores

Enum()

Inicializa uma nova instância da classe Enum.

Métodos

CompareTo(Object)	Compara essa instância com um objeto especificado e retorna uma indicação dos valores relativos.
Equals(Object)	Retorna um valor que indica se a instância é igual a um objeto especificado.
Format(Type, Object, String)	Converte o valor especificado de um tipo enumerado especificado em sua representação de cadeia de caracteres equivalente de acordo com o formato especificado.
GetHashCode()	Retorna o código hash para o valor dessa instância.
GetName(Type, Object)	Recupera o nome da constante na enumeração especificada que tem o valor especificado.
GetName<TEnum>(TEnum)	Recupera o nome da constante no tipo de enumeração especificado que tem o valor especificado.
GetNames(Type)	Recupera uma matriz de nomes de constantes em uma enumeração especificada.
GetNames<TEnum>()	Recupera uma matriz de nomes de constantes em um tipo de enumeração especificado.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
GetTypeCode()	Retorna o código de tipo do tipo subjacente desse membro de enumeração.
GetUnderlyingType(Type)	Retorna o tipo subjacente da enumeração especificada.
GetValues(Type)	Recupera uma matriz de valores de constantes em uma enumeração especificada.
GetValues<TEnum>()	Recupera uma matriz de valores de constantes em um tipo de enumeração especificado.
GetValuesAsUnderlyingType(Type)	Recupera uma matriz dos valores das constantes de tipo subjacentes em uma enumeração especificada.
GetValuesAsUnderlyingType<TEnum>()	Recupera uma matriz dos valores das constantes de tipo subjacentes em um tipo de enumeração especificado.
HasFlag(Enum)	Determina se um ou mais campos de bits são definidos na instância atual.
IsDefined(Type, Object)	Retorna um booliano informando se um determinado valor integral ou o seu nome como uma cadeia de caracteres existe em uma enumeração especificada.
IsDefined<TEnum>(TEnum)	Retorna um booliano informando se um determinado valor integral, ou seu nome como uma cadeia de caracteres, existe em uma enumeração especificada.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Parse(Type, ReadOnlySpan<Char>)	Converte o intervalo de representação de caracteres do nome ou valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente.
Parse(Type, ReadOnlySpan<Char>, Boolean)	Converte o intervalo de representação de caracteres do nome ou valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente. Um parâmetro especifica se a operação não diferencia maiúsculas de minúsculas.
Parse(Type, String)	Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente.
Parse(Type, String, Boolean)	Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente. Um parâmetro especifica se a operação não diferencia maiúsculas de minúsculas.
Parse<TEnum>(ReadOnlySpan<Char>)	Converte o intervalo de representação de caracteres do nome ou valor numérico de uma ou mais constantes enumeradas especificadas por `TEnum` em um objeto enumerado equivalente.
Parse<TEnum>(ReadOnlySpan<Char>, Boolean)	Converte o intervalo de representação de caracteres do nome ou valor numérico de uma ou mais constantes enumeradas especificadas por `TEnum` em um objeto enumerado equivalente. Um parâmetro especifica se a operação não diferencia maiúsculas de minúsculas.
Parse<TEnum>(String)	Converte a representação de cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas especificadas por `TEnum` em um objeto enumerado equivalente.
Parse<TEnum>(String, Boolean)	Converte a representação de cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas especificadas por `TEnum` em um objeto enumerado equivalente. Um parâmetro especifica se a operação não diferencia maiúsculas de minúsculas.
ToObject(Type, Byte)	Converte o inteiro sem sinal de 8 bits especificado para um membro de enumeração.
ToObject(Type, Int16)	Converte o inteiro com sinal de 16 bits especificado em um membro de enumeração.
ToObject(Type, Int32)	Converte o inteiro com sinal de 32 bits especificado para um membro de enumeração.
ToObject(Type, Int64)	Converte o inteiro com sinal de 64 bits especificado em um membro de enumeração.
ToObject(Type, Object)	Converte o objeto especificado com um valor inteiro em um membro da enumeração.
ToObject(Type, SByte)	Converte o valor inteiro com sinal de 8 bits especificado em um membro de enumeração.
ToObject(Type, UInt16)	Converte o valor inteiro sem sinal de 16 bits especificado em um membro de enumeração.
ToObject(Type, UInt32)	Converte o valor inteiro sem sinal de 32 bits especificado em um membro de enumeração.
ToObject(Type, UInt64)	Converte o valor inteiro sem sinal de 64 bits especificado em um membro de enumeração.
ToString()	Converte o valor dessa instância na representação da cadeia de caracteres equivalente.
ToString(IFormatProvider)	Obsoleto. Obsoleto. Essa sobrecarga de método é obsoleta; use ToString().
ToString(String)	Converte o valor dessa instância para sua representação de cadeia de caracteres equivalente usando o formato especificado.
ToString(String, IFormatProvider)	Obsoleto. Obsoleto. Essa sobrecarga de método é obsoleta; use ToString(String).
TryFormat<TEnum>(TEnum, Span<Char>, Int32, ReadOnlySpan<Char>)	Tenta formatar o valor da instância de tipo enumerado no intervalo de caracteres fornecido.
TryParse(Type, ReadOnlySpan<Char>, Boolean, Object)	Converte o intervalo de representação de caracteres do nome ou valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente. Um parâmetro especifica se a operação não diferencia maiúsculas de minúsculas.
TryParse(Type, ReadOnlySpan<Char>, Object)	Converte o intervalo de representação de caracteres do nome ou valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente.
TryParse(Type, String, Boolean, Object)	Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente.
TryParse(Type, String, Object)	Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente.
TryParse<TEnum>(ReadOnlySpan<Char>, Boolean, TEnum)	Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente. Um parâmetro especifica se a operação diferencia maiúsculas de minúsculas. O valor de retorno indica se a conversão foi bem-sucedida.
TryParse<TEnum>(ReadOnlySpan<Char>, TEnum)	Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente.
TryParse<TEnum>(String, Boolean, TEnum)	Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente. Um parâmetro especifica se a operação diferencia maiúsculas de minúsculas. O valor de retorno indica se a conversão foi bem-sucedida.
TryParse<TEnum>(String, TEnum)	Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente. O valor de retorno indica se a conversão foi bem-sucedida.

Implantações explícitas de interface

IConvertible.GetTypeCode()	Retorna o código de tipo desta instância de Enum.
IConvertible.ToBoolean(IFormatProvider)	Converte o valor atual em um valor booliano com base no tipo subjacente.
IConvertible.ToByte(IFormatProvider)	Converte o valor atual em um inteiro sem sinal de 8 bits com base no tipo subjacente.
IConvertible.ToChar(IFormatProvider)	Converte o valor atual em um caractere Unicode com base no tipo subjacente.
IConvertible.ToDateTime(IFormatProvider)	Converte o valor atual em um DateTime com base no tipo subjacente.
IConvertible.ToDecimal(IFormatProvider)	Converte o valor atual em um Decimal com base no tipo subjacente.
IConvertible.ToDouble(IFormatProvider)	Converte o valor atual em um número de ponto flutuante de precisão dupla com base no tipo subjacente.
IConvertible.ToInt16(IFormatProvider)	Converte o valor atual em um inteiro com sinal de 16 bits com base no tipo subjacente.
IConvertible.ToInt32(IFormatProvider)	Converte o valor atual em um inteiro com sinal de 32 bits com base no tipo subjacente.
IConvertible.ToInt64(IFormatProvider)	Converte o valor atual em um inteiro com sinal de 64 bits com base no tipo subjacente.
IConvertible.ToSByte(IFormatProvider)	Converte o valor atual em um inteiro com sinal de 8 bits com base no tipo subjacente.
IConvertible.ToSingle(IFormatProvider)	Converte o valor atual em um número de ponto flutuante de precisão simples com base no tipo subjacente.
IConvertible.ToString(IFormatProvider)	Obsoleto. Esta sobrecarga de método é obsoleta; use ToString().
IConvertible.ToType(Type, IFormatProvider)	Converte o valor atual em um tipo especificado com base no tipo subjacente.
IConvertible.ToUInt16(IFormatProvider)	Converte o valor atual em um inteiro sem sinal de 16 bits com base no tipo subjacente.
IConvertible.ToUInt32(IFormatProvider)	Converte o valor atual em um inteiro sem sinal de 32 bits com base no tipo subjacente.
IConvertible.ToUInt64(IFormatProvider)	Converte o valor atual em um inteiro sem sinal de 64 bits com base no tipo subjacente.
IFormattable.ToString(String, IFormatProvider)	Obsoleto. Essa sobrecarga de método é obsoleta; use ToString(String).
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da enumeração no intervalo fornecido de caracteres.

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.

Enum Classe

Definição

Exemplos

Comentários

Criando um tipo de enumeração

Instanciando um tipo de enumeração

Práticas recomendadas de enumeração

Executando operações com enumerações

Executando conversões

Analisando valores de enumeração

Formatação de valores de enumeração

Iterando membros de enumeração

Membros não exclusivos e o atributo Flags

Adicionando métodos de enumeração

Construtores

Métodos

Implantações explícitas de interface

Aplica-se a

Acesso thread-safe

Confira também

Comentários

Comentários

Recursos adicionais