Classe Enum

Linguagens de programação geralmente 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# e Visual Basic para definir uma enumeração. Ele cria uma enumeração denominada ArrivalStatus que tem três membros: ArrivalStatus.Early, ArrivalStatus.OnTime, e ArrivalStatus.Late. Observe que em ambos os casos, a enumeração explicitamente herda de Enum; a relação de herança é tratada implicitamente pelo compilador.

public enum ArrivalStatus { Late=-1, OnTime=0, Early=1 };

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

Você pode instanciar um tipo de enumeração da mesma forma que você criar uma instância de qualquer outro tipo de valor: declarar uma variável e atribuindo uma das constantes da enumeração para ele. O exemplo a seguir instancia 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)

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

• Usando os recursos da linguagem de programação específica para difusão (como C#) ou converter um valor inteiro (como em Visual Basic) para um valor de enumeração. O exemplo a seguir cria um ArrivalStatus objeto cujo valor é ArrivalStatus.Early na forma.

  C#

  VB

  Copiar

  
  ArrivalStatus status2 = (ArrivalStatus) 1;
  Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
  // The example displays the following output:
  //       Arrival Status: Early (1)
  
  
  

• Chamando seu construtor padrão implícitos. Como mostra o exemplo a seguir, neste caso o valor subjacente da instância de enumeração é 0. No entanto, isso não é necessariamente o valor de uma constante válido na enumeração.

  C#

  VB

  Copiar

  
  ArrivalStatus status1 = new ArrivalStatus();
  Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
  // The example displays the following output:
  //       Arrival Status: OnTime (0)
  
  
  

• Chamando o Parse ou TryParse método para analisar uma cadeia de caracteres que contém o nome de uma constante da enumeração. Para obter mais informações, consulte o De análise de valores de enumeração seção.

• Chamando o ToObject método para converter um valor inteiro para um tipo de enumeração. Para obter mais informações, consulte o Realizar conversões seção.

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

• Se você não tiver definido um membro de enumeração cujo valor é 0, considere a criação de um None enumerados constante. Por padrão, a memória usada para a enumeração é inicializada para zero, o common language runtime. Conseqüentemente, se você não definir uma constante cujo valor é zero, a enumeração conterá um valor ilegal quando ele é criado.

• Se há um caso padrão óbvio que o seu aplicativo deve representar, considere usar um enumerados constante cujo valor é zero para representá-lo. Se não houver nenhum caso padrão, considere o uso de uma constante enumerada cujo valor é zero para especificar o caso em que não esteja representado por qualquer uma das constantes enumeradas.

• Não especifica constantes enumeradas que são reservados para uso futuro.

• Quando você define um método ou propriedade que leva a uma constante enumerada como um valor, considere a possibilidade de validar o valor. O motivo é que você pode converter um valor numérico para o tipo de enumeração, mesmo se esse valor numérico não está definido na enumeração.

Práticas recomendadas para os tipos de enumeração cujos constantes são campos de bits estão listadas na os membros não-exclusiva e o atributo de sinalizadores seção.

Você não pode definir novos métodos quando você estiver criando uma enumeração. No entanto, um tipo de enumeração herda um conjunto completo de estática e métodos de instância da Enum classe. As seções a seguir a maior parte desses métodos, além de vários outros métodos que são usados com freqüência ao trabalhar com valores de enumeração de pesquisa.

Realização de conversões

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

int value4 = (int) status3;

int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);

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

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

A análise de valores de enumeração

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

Valores de enumeração de formatação

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

Os membros de enumeração de iteração

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

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

[Flags] public enum Pets { None=0, Dog=1, Cat=2, Bird=4, Rodent=8,
                           Reptile=16, Other=32 };

O Pets enumeração pode ser usada como 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)      

Práticas recomendadas a seguir devem ser usadas ao definir o bit a bit de enumeração e aplicando o FlagsAttribute atributo.

• Use o FlagsAttribute atributo personalizado para uma enumeração somente se uma operação bit a bit (AND, OR ou exclusivo) é para ser 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 combinados não se sobreponham.

• Considere a criação de uma constante enumerada para combinações de sinalizador comumente usados. Por exemplo, se você tiver uma enumeração usada para operações de e/S de arquivo que contém as constantes enumeradas Read = 1 e Write = 2, considere a possibilidade de criar a constante enumerada ReadWrite = Read OR Write, que combina o Read e Write sinalizadores. 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 exigida para tarefas simples.

• Tenha cuidado se você definir um número negativo como uma constante enumerada de sinalizador porque muitos posições de sinalizador podem ser definidas como 1, que pode tornar seu código confuso e incentivar a erros de codificação.

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

  C#

  VB

  Copiar

  
  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.      
  
  
  

  Ele equivale a executar uma operação a bit entre o valor numérico e a constante enumerada de sinalizador, que define todos os bits no valor numérico em zero que não correspondem ao sinalizador, e em seguida, teste se o resultado dessa operação é igual a constante enumerada de sinalizador. Isso é ilustrado no exemplo a seguir.

  C#

  VB

  Copiar

  
  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.      
  
  
  

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

  C#

  VB

  Copiar

  
  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.      
  
  
  

• Não defina um valor de enumeração exclusivamente para espelhar o estado da própria enumeração. Por exemplo, não defina uma constante enumerada que simplesmente marca o final da enumeração. Se você precisa determinar o último valor da enumeração, verificar esse valor explicitamente. Além disso, você pode executar uma verificação de intervalo para a constante enumerada primeiro e último se todos os valores no intervalo são válidos.