1. Introdução
Na programação, a gente vive lidando com listas de opções já conhecidas e limitadas. Tipo: dias da semana, cores do semáforo, níveis de dificuldade de um jogo, status de pedido. Cada uma dessas opções normalmente é representada por um valor fixo. E é aí que entra o assunto de hoje — enums (enum).
Enum é um tipo de dado especial que permite declarar um conjunto de constantes nomeadas.
enum é tipo uma caixinha com etiquetas em cada compartimento, onde cada etiqueta é um nome único ligado a um número.
- Teu código fica legível e autoexplicativo;
- No lugar daqueles “números mágicos” tipo 0, 1, 2 aparecem nomes que fazem sentido: DayOfWeek.Monday ou TrafficLight.Red;
- O compilador vai reclamar se tu tentar colocar um valor inválido;
- Por trás de cada elemento... tem só um número inteiro! (Mas já já a gente fala mais disso.)
2. Sintaxe pra declarar um enum
Bora criar nosso primeiro enum — tipos de clima pro nosso futuro app. Olha só como fica:
// Enum de condições do clima
public enum WeatherCondition
{
Sunny, // 0
Cloudy, // 1
Rainy, // 2
Stormy, // 3
Snowy // 4
}
- A palavra-chave enum define um novo tipo.
- Entre as chaves ficam os nomes das opções. Por padrão, cada opção recebe um número inteiro começando do zero (Sunny == 0, Cloudy == 1 e por aí vai).
- Dá pra definir os valores explicitamente também:
public enum WeatherCondition
{
Sunny = 1,
Cloudy = 2,
Rainy = 4,
Stormy = 8,
Snowy = 16
}
Isso é útil quando os valores precisam bater com algum padrão externo ou protocolo.
3. Usando enums
Imagina que a gente fez um app — um programinha de console que reage ao clima.
// Classe do app
class Program
{
static void Main()
{
// Usando nosso enum pra guardar o estado do clima
WeatherCondition todayWeather = WeatherCondition.Sunny;
// Mostra na tela
Console.WriteLine($"Hoje o clima é: {todayWeather} ({(int)todayWeather})");
// Agora vamos simular uma mudança no clima
todayWeather = WeatherCondition.Rainy;
Console.WriteLine($"Opa! O clima mudou: {todayWeather} ({(int)todayWeather})");
}
}
O que vai acontecer?
Hoje o clima é: Sunny (0)
Opa! O clima mudou: Rainy (2)
- todayWeather — não é string, não é número, é um elemento do enum.
- Fazer cast pra (int) mostra o “código numérico” desse valor.
Aliás, enums combinam muito bem com condições:
if (todayWeather == WeatherCondition.Rainy)
Console.WriteLine("Leva um guarda-chuva!");
4. Cenários práticos de uso de enum
Onde aparecem enums?
- Em apps de negócios: status de pedidos (New, Processing, Shipped, Cancelled).
- Em sistemas de usuários: níveis de acesso (User, Moderator, Admin).
- Em jogos: estados do personagem (Idle, Moving, Jumping, Falling).
- No GUI: botões, mensagens, cores de ícones.
E se tu for fundo no .NET — vai achar enums em quase toda classe da biblioteca padrão! Por exemplo, operações com arquivos usam enums pra indicar o modo de abrir arquivo (leitura, escrita, criação).
5. Valores explícitos e faixa de valores
Às vezes tu quer transformar um conjunto de valores int usados no código em um enum. Isso é bem fácil:
public enum CompassDirection
{
North = 10,
East = 20,
South = 30,
West = 40
}
Agora CompassDirection.North = 10, East = 20, e assim por diante. Se algum elemento não tiver valor explícito, ele pega automaticamente o valor anterior +1.
Tipo de armazenamento
Por padrão, enum é armazenado como int (inteiro de 4 bytes). Mas tu pode escolher outro tipo base se quiser economizar memória:
public enum TinyEnum : byte
{
First, // 0
Second, // 1
Third // 2
}
Agora cada valor do enum ocupa só um byte!
Lista completa dos tipos possíveis: byte, sbyte, short, ushort, int, uint, long, ulong.
6. Conversão entre enum e números/strings
Conversão enum ↔ int:
Pra converter enum pra int e vice-versa, é só usar typecast:
WeatherCondition current = WeatherCondition.Cloudy;
int number = (int)current; // Vai dar 1
WeatherCondition fromNumber = (WeatherCondition)2; // Vai dar Rainy
Conversão enum ↔ string:
Converter enum pra string é fácil: só chamar o método ToString().
// Convertendo enum pra string
string name = WeatherCondition.Stormy.ToString(); // "Stormy"
// Convertendo string pra enum com Enum.Parse
WeatherCondition parsed = (WeatherCondition)Enum.Parse(typeof(WeatherCondition), "Stormy");
// Também dá pra usar Enum.TryParse
WeatherCondition parsedOk;
if (Enum.TryParse("Snowy", out parsedOk))
{
Console.WriteLine(parsedOk); // Snowy
}
Erro comum:
Se tu converter um número pra enum que não tem esse membro definido, o compilador não reclama, mas tu ganha um “estado virtual”.
Por exemplo:
WeatherCondition weird = (WeatherCondition)999;
Console.WriteLine(weird); // 999 (não vira "Unknown"!)
Ou seja, o dev tem que ficar ligado nessas conversões.
7. switch e enum nasceram um pro outro
Enums (enum) combinam demais com o operador switch. É um jeito prático e claro de “reagir” a diferentes valores do enum — sem precisar de um monte de “if-else”.
Exemplo: reagindo ao clima
public enum WeatherCondition
{
Sunny,
Cloudy,
Rainy,
Stormy,
Snowy
}
WeatherCondition today = WeatherCondition.Rainy;
switch (today)
{
case WeatherCondition.Sunny:
Console.WriteLine("Tá sol! Bora dar um rolê.");
break;
case WeatherCondition.Cloudy:
Console.WriteLine("Tá nublado. Leva um casaquinho.");
break;
case WeatherCondition.Rainy:
Console.WriteLine("Tá chovendo. Não esquece o guarda-chuva!");
break;
case WeatherCondition.Stormy:
Console.WriteLine("Tempestade! Melhor ficar em casa.");
break;
case WeatherCondition.Snowy:
Console.WriteLine("Tá nevando — põe o gorro!");
break;
default:
Console.WriteLine("Clima desconhecido...");
break;
}
- Cada case corresponde a um valor do enum.
- Se o valor não bater com nenhum conhecido, executa o default (útil se alguém colocou um número direto no enum).
Por que enum + switch é massa?
- Código legível: todos os casos possíveis aparecem nos case.
- Fácil de expandir: adicionou um novo tipo de clima — só botar mais um case.
- Seguro: o compilador pode avisar se tu esqueceu de tratar algum caso (a partir do C# 8.0 dá até pra exigir lista completa).
Exemplo: enum com lógica de jogo
public enum GameState
{
Start,
Playing,
Paused,
GameOver
}
void PrintState(GameState state)
{
switch (state)
{
case GameState.Start:
Console.WriteLine("Bem-vindo ao jogo!");
break;
case GameState.Playing:
Console.WriteLine("O jogo tá rolando. Boa sorte!");
break;
case GameState.Paused:
Console.WriteLine("Pausa. Dá pra respirar.");
break;
case GameState.GameOver:
Console.WriteLine("Fim de jogo. Tenta de novo!");
break;
default:
Console.WriteLine("Estado desconhecido do jogo.");
break;
}
}
Dicas:
- Se vários casos fazem a mesma coisa, pode juntar eles:
switch (today)
{
case WeatherCondition.Rainy:
case WeatherCondition.Stormy:
Console.WriteLine("Não esquece o guarda-chuva e uma roupa quentinha!");
break;
}
- Lembra do default pra tratar valores inesperados (tipo se alguém converteu um número direto pra enum).
- Com switch dá pra montar “máquinas de estado”, menus e qualquer sistema com opções fixas.
8. Enums e métodos/serviços principais do .NET
.NET tem vários métodos úteis pra enums:
- Enum.GetNames(typeof(WeatherCondition)) — pega todos os nomes.
- Enum.GetValues(typeof(WeatherCondition)) — todos os valores.
- Enum.IsDefined(typeof(WeatherCondition), "Rainy") — vê se tem esse membro no enum.
- Documentação: System.Enum
Exemplo mostrando todas as opções de clima:
foreach (var name in Enum.GetNames(typeof(WeatherCondition)))
{
Console.WriteLine(name);
}
9. Erros comuns e “pegadinhas”
- Usar “números mágicos” no lugar de enums, perdendo legibilidade.
- Não tratar valores que não estão definidos no enum (tipo quando converte número).
- Dar nomes sem sentido pros elementos do enum (Value1, Value2... — aí ninguém lembra o que é o quê).
- Quebrar o princípio da responsabilidade única — usar um enum pra coisas diferentes.
Melhor solução: sempre usa enums quando tiver um conjunto fixo de opções, e dá nomes que expliquem direitinho o que cada elemento significa.
GO TO FULL VERSION