Curso de C#: Lição 17: Enums

Esta lição explica como usar C # enums. Os nossos objectivos são os seguintes: Entenda o que é um ENUM. Ser capaz de criar novos tipos enum. Saiba como usar enums. Ganhar familiaridade com métodos tipo System.Enum

Por | @oficinadanet Programação
Esta lição explica como usar C # enums. Os nossos objectivos são os seguintes:
  • Entenda o que é um ENUM
  • Ser capaz de criar novos tipos enum
  • Saiba como usar enums
  • Ganhar familiaridade com métodos tipo System.Enum


Definição de Enums


Enums são fortemente constantes tipadas. São essencialmente únicas formas que permitem que você atribuir nomes aos integrante valores simbólicos. No C # tradição, eles são fortemente digitado, o que significa que um ENUM de um tipo não pode ser implicitamente atribuído a um ENUM de outro tipo, embora o valor subjacente de seus membros são os mesmos. Na mesma linha, integrante tipos e enums não são intercambiáveis implicitamente. Todas as tarefas entre os diferentes tipos e enum integrante tipos exigem uma explícita expressos.

Enums prestam-se mais sustentável código porque eles são simbólicos, o que lhe permite trabalhar com valores integrais, mas usando um nome significativo para o fazer. Por exemplo, qual o tipo de código prefere trabalhar com - um conjunto de valores denominado Norte, Sul, Leste e Oeste ou o conjunto de inteiros 0, 1, 2, 3 e mapeados para que os mesmos valores, respectivamente? Enums que trabalhar com veemência constantes tipadas via simbólica nomes fácil.

Enums são tipos valor, o que significa que elas contém seu próprio valor, não pode herdar ou ser herdado a partir de, e cópias a atribuição de um valor enum para o outro. Você vai ver nesta lição e noutros locais que enums são utilizadas e referidas com ambas as minúsculas, enum, e maiúsculas, enum. Curiosamente, a relação entre os dois é que o tipo C #, enum, herda a Base Class Library (BCL) tipo, enum. Use o tipo C #, enum, para definir novas enums e utilizar o tipo BCL, enum, para implementar métodos estáticos enum.

Criando um enum


O. NET Framework Class Library enums e contém muitos exemplos de como eles são utilizados. Por exemplo, toda vez que você colocar um ícone em um MessageBox, você usa o MessageBoxIcon ENUM. Para obter uma lista de disponíveis no enums. NET Framework Class Library, dê uma olhada na documentação para a classe Enum e clicar sobre o link derivados classes.

Sempre existem situações em que você está usando um conjunto de números relacionados em um programa, considere substitui estes números com enums. Vai fazer um programa mais legível e tipo de seguro. Listing 17-1 contém um ENUM definição eo código que usa esse tipo de declaração enum em um interruptor. Em vez de usar os números 0, 1 e 2, no interruptor declaração, o código é mais significativa através da utilização do Volume ENUM.

Listing 17-1. Criação e Utilização um enum: EnumSwitch.cs
 using System;

// declares the enum
public enum Volume
{
   Low,
   Medium,
   High
}

// demonstrates how to use the enum

class EnumSwitch
{
   static void Main()
   {
      // create and initialize
      // instance of enum type
      Volume myVolume = Volume.Medium;

      // make decision based
      // on enum value
      switch (myVolume)
      {
         case Volume.Low:
            Console.WriteLine("The volume has been turned Down.");
            break;
         case Volume.Medium:
            Console.WriteLine("The volume is in the middle.");
            break;
         case Volume.High:
            Console.WriteLine("The volume has been turned up.");
            break;
      }
      Console.ReadLine();
   }
}


Listing 17-1 contém uma definição para um ENUM. Aviso de que é declarada com a palavra-chave enum, tem um tipo de identificador (volume), e contém uma lista de valores separados por vírgula fechados dentro de chavetas.

Esta é enum tipo de Volume e nós usá-la para declarar o myVolume a principal variável no método. Uma vez que um ENUM é um tipo de valor, podemos atribuir um valor (Volume.Medium) que lhe directamente, semelhante aos tipos como int simples ou dupla. Uma vez que o myVolume variável é declarada e inicializada, ela é utilizada no interruptor statement.Each do caso declarações representar um único membro do Volume ENUM.

Qualquer momento por um membro do Volume enum é utilizado, é totalmente qualificado com o "volume" identificador de tipo de garantir a segurança. Por exemplo, se houvesse um Carnes enum no âmbito de aplicação, então com certeza gostaria de ter Meat.Medium diferente do que Volume. Com tanto no âmbito enums, seria ambíguo para apenas utilizar o identificador Mídia sem qualificação de tipo. Usando o identificador garante esse tipo de erros não são feitas.

Utilizando Enums


Um ENUM é normalmente especificada como mostrado na Lista 17-1, mas pode ser personalizado alterando sua base de tipo e membro valores. Por padrão, o tipo de subjacente um ENUM é int. Esta omissão pode ser mudado pela especificação de uma base específica quando declara a ENUM. Você irá especificar uma base diferente se o enum foi amplamente utilizado e não houve uma oportunidade para a poupança de espaço, selecionando um tipo menor. Outra razão pode ser que você quis se o tipo de subjacentes a enum para corresponder a outro tipo em seu programa e você quis explicitamente expressos entre os dois, sem perda de precisão. Valid base types include byte , sbyte , short , ushort , int , uint , long , and ulong .

Outra modificação que você pode fazer para um ENUM é o de definir o valor de qualquer membro enum. Por padrão, o primeiro membro de um ENUM tem o valor de zero. Se este valor não faz sentido para a sua enum, você pode alterá-lo para um ou com outro número. Além disso, você pode alterar qualquer um dos membros de um ENUM para qualquer valor que é válida para o seu tipo base. Não atribuído enum membros têm um valor que representa uma mais do que seu antecessor. Listing 17-2 mostra como base para modificar o tipo e os valores de um ENUM.

Listing 17-2. Configurando o enum Base e Inicializando deputados: EnumBaseAndMembers.cs
 using System;

// declares the enum
public enum Volume : byte
{
    Low = 1,
    Medium,
    High
}

class EnumBaseAndMembers
{
    static void Main()
    {
        // create and initialize
        // instance of enum type
        Volume myVolume = Volume.Low;

        // make decision based
        // on enum value
        switch (myVolume)
        {
            case Volume.Low:
                Console.WriteLine("The volume has been turned Down.");
                break;
            case Volume.Medium:
                Console.WriteLine("The volume is in the middle.");
                break;
            case Volume.High:
                Console.WriteLine("The volume has been turned up.");
                break;
        }
        Console.ReadLine();
    }
}


O volume enum na Lista 17-2 mostra como a alterar o tipo de base e dos membros da enum.Its um tipo base é alterado para com o byte: sintaxe na sequência da enum identificador, Volume. Isso garante que o volume só podem enum ter membros com valores que são válidos para o tipo byte.

O primeiro membro da Fascículo enum, Low, tem seu valor alterado para 1. A mesma sintaxe, = , pode ser aplicada a qualquer membro do ENUM. Você está restrito a partir de criar referências em frente, circular referências, e referências em duplicado enum membros.

Os valores padrão do Baixo Volume enum são = 0, Medium = 1, 2 e Alto = porque o primeiro membro de um ENUM padrão para 0 e os seguintes membros para um padrão mais que seu antecessor. No entanto, o volume enum na listagem 17-2 Baixo membro tem o seu conjunto de 1, o que significa que o Alto e Médio = 2 = 3.

Truques Enum


Enum tipos implicitamente herdar a System.Enum tipo na Base Class Library (BCL). Isto também significa que você pode usar os membros da System.Enum a funcionar em tipos enum. Esta secção faz exatamente isso, mostrando alguns truques e dicas úteis para usar com enums em seus programas.

Um requisito comum com enums é converter entre o ENUM e uma variável do tipo sua base. Por exemplo, se você estiver recebendo contribuições na forma de um int de um usuário ou um arquivo fluxo, então você pode lançar-a para um ENUM e utilizá-la de forma significativa em seu programa. Você também pode obter uma lista completa dos nomes enum membro ou enum valores, o que é útil se você tem lógica que precisa de iterate através de cada membro enum. Listing 17-3 mostra a forma de executar as conversões entre enums e seus tipos e como base para utilizar alguns dos membros System.Enum tipo.

Listing 17-3. Conversões e usando o System.Enum Tipo: Enumtricks.cs
 using System;

// declares the enum
public enum Volume : byte
{
    Low = 1,
    Medium,
    High
}

// shows different ways
// to work with enums
class Enumtricks
{
    static void Main(string[] args)
    {
        // instantiate type
        Enumtricks enumtricks = new Enumtricks();

        // demonstrates explicit cast
        // of int to Volume
        enumtricks.GetEnumFromUser();

        // iterate through Volume enum by name
        enumtricks.ListEnumMembersByName();

        // iterate through Volume enum by value
        enumtricks.ListEnumMembersByValue();

        Console.ReadLine();
    }

    // demonstrates explicit cast
    // of int to Volume
    public void GetEnumFromUser()
    {
        Console.WriteLine("
----------------");
        Console.WriteLine("Volume Settings:");
        Console.WriteLine("----------------
");

        Console.Write(@"
1 - Low
2 - Medium
3 - High

Please select one (1, 2, or 3): ");

        // get value user provided
        string volString = Console.ReadLine();
        int volInt = Int32.Parse(volString);

        // perform explicit cast from
        // int to Volume enum type
        Volume myVolume = (Volume)volInt;

        Console.WriteLine();

        // make decision based
        // on enum value
        switch (myVolume)
        {
            case Volume.Low:
                Console.WriteLine("The volume has been turned Down.");
                break;
            case Volume.Medium:
                Console.WriteLine("The volume is in the middle.");
                break;
            case Volume.High:
                Console.WriteLine("The volume has been turned up.");
                break;
        }

        Console.WriteLine();
    }

    // iterate through Volume enum by name
    public void ListEnumMembersByName()
    {
        Console.WriteLine("
---------------------------- ");
        Console.WriteLine("Volume Enum Members by Name:");
        Console.WriteLine("----------------------------
");

        // get a list of member names from Volume enum,
        // figure out the numeric value, and display
        foreach (string volume in Enum.GetNames(typeof(Volume)))
        {
            Console.WriteLine("Volume Member: {0}
Value: {1}",
                volume, (byte)Enum.Parse(typeof(Volume), volume));
        }
    }

    // iterate through Volume enum by value
    public void ListEnumMembersByValue()
    {
        Console.WriteLine("
----------------------------- ");
        Console.WriteLine("Volume Enum Members by Value:");
        Console.WriteLine("-----------------------------
");

        // get all values (numeric values) from the Volume
        // enum type, figure out member name, and display
        foreach (byte val in Enum.GetValues(typeof(Volume)))
        {
            Console.WriteLine("Volume Value: {0}
Member: {1}",
                val, Enum.GetName(typeof(Volume), val));
        }
    }
}


O código na listagem 17-3 método inclui três chamadas para GetEnumFromUser, ListEnumMembersByName, e ListEnumMembersByValue. Cada um desses métodos demonstrar um aspecto diferente de usar System.Enum para trabalhar com enums.

O GetEnumFromUser mostra como método para obter int entrada e traduzi-lo para uma adequada enum tipo. Convertendo um int para um ENUM torna o código mais legível e tipo de seguro. O seguinte é um excerto da Listing 17-3, que mostra a parte pertinente do código que executa a conversão:

         // get value user provided
        string volString = Console.ReadLine();
        int volInt = Int32.Parse(volString);

        // perform explicit cast from
        // int to Volume enum type
        Volume myVolume = (Volume)volInt;


Após o programa abre um menu, ele pede ao usuário para uma selecção, sob a forma de um número (1, 2 ou 3). Quando o usuário faz uma seleção e pressiona a tecla Enter, a leitura do código com o valor Console.ReadLine, que retorna o valor como uma string tipo. Uma vez que você só pode lançar um int para um Volume enum tipo, a entrada do usuário deve ser convertido a partir de uma string para um int Int32.Parse com o método. Convertendo o volume de t para um enum tipo é simplesmente uma questão de aplicação de uma operação durante expressos atribuição.

Para obter todos os membros de um ENUM, ao mesmo tempo, você pode usar o método de GetNames a System.Enum tipo, que retorna uma string array de nomes de todos os seus membros um ENUM. Um trecho da ListEnumMembersByName método em 17,3 listagem mostra que este aparece abaixo:

         // get a list of member names from Volume enum,
        // figure out the numeric value, and display
        foreach (string volume in Enum.GetNames(typeof(Volume)))
        {
            Console.WriteLine("Volume Member: {0}
Value: {1}",
                volume, (byte)Enum.Parse(typeof(Volume), volume));
        }


Porque GetNames retorna um arranjo de cordas, é fácil de usar a declaração em um loop como foreach. Algo que você pode ser curioso sobre o código acima, em segundo é o parâmetro para o método WriteLine do formato string. Dada a enum tipo e uma representação string do nome de membro, você pode usar o Enum.Parse método para obter o valor subjacente a esse membro. Uma vez que o volume da base enum tipo é byte, o valor de retorno de Enum.Parse devem ser expressos para um byte antes da cessão, forçando a representação numérica do valor enum a aparecer. Se nós teria omitido o byte expressos, a saída seria a Fascículo enum membro, que passaria então a ser convertida para uma representação string do nome de membro, o que não é o que o código destinado a mostrar.

Em vez de receber nomes de todos os membros de um ENUM, você pode ter um motivo para obter todos os valores da enum em uma hora. O código abaixo, a partir do método em ListEnumMembersByValue Listing 17,3, mostra como fazer isso:

         // get all values (numeric values) from the Volume
        // enum type, figure out member name, and display
        foreach (byte val in Enum.GetValues(typeof(Volume)))
        {
            Console.WriteLine("Volume Value: {0}
Member: {1}",
                val, Enum.GetName(typeof(Volume), val));
        }


Atendendo ao tipo do enum, o método GetValues de System.Enum irá retornar um array de um determinado tipo enum da base, que, neste caso, é byte. Enquanto iteração através desta lista, cada membro é impresso para o console mostrar o seu valor e de nome. O nome é obtido pela utilização do método GetName de System.Enum, que aceita um ENUM tipo eo valor para o qual a obter o nome do correspondente.

Resumo


Enums são fortemente digitado constantes de listas de membros com nomes que são simbólicas, o que corresponde a um tipo subjacente integrante. Enum base tipos podem ser alterados e os valores podem ser especificados. O System.Enum. NET Framework Class Library tipo é a classe base de enum tipos e contém métodos que permitem a você trabalhar com enums de diferentes formas, tais como trabalhar com uma lista de nomes ou valores, convertendo valor a partir de nome, e convertendo de nome de valor. Para obter mais informações sobre o tipo System.Enum, consulte o. NET Framework SDK documentação.

Matéria automaticamente traduzida de: http://www.csharp-station.com/Tutorials/Lesson17.aspx

Mais sobre: curso_c_sharp, c_sharp
Share Tweet
DESTAQUESRecomendadoMais compartilhados
Comentários