Las enumeraciones son "un tipo distinto que consiste en un conjunto de constantes llamado lista de enumeradores ". Es decir, una enumeración es un tipo. Lo que significa que se declarará como un tipo en nuestro código, y otro tipo no podrá tener ese mismo nombre y ser declarado como una enumeración. Cada enumeración debe tener un nombre distinto.
Una enumeración es un conjunto, es decir, una agrupación de valores similares. Los valores contenidos en la enumeración reciben nombres, por lo que podemos identificarlos fácilmente, y son constantes, lo que significa que no podemos cambiar sus nombres o sus valores después de crear la enumeración.
Aunque asignemos nombres a los miembros de la lista de enumeración, el compilador en realidad asigna números enteros a los miembros de la lista, y comienzan con 0 incrementándose de uno en uno por cada miembro de la enumeración. Podemos inicializar miembros con nuestro propio valor, lo cual anula este comportamiento por defecto. Por ejemplo utilizaremos los meses del año como constantes nombradas. El siguiente código muestra el uso de una enumeración que contiene los 12 meses del año. La primera muestra utiliza el inicio por defecto. Comienza en 0, mientras que en el segundo ejemplo lo forzamos para que comience con 1.
// enum llamada Meses,
utilizando el inicializador por defecto
enum
Meses
{
Ene,
Feb, Mar, Abr,
May, Jun, Jul,
Ago, Sep, Oct,
Nov, Dic
};
// enum llamada Meses, utilizando una inicialización
forzada
enum
Meses2
{
Ene = 1, Feb, Mar,
Abr, May, Jun,
Jul, Ago, Sep,
Oct, Nov, Dic
};
Igual que los nombres de variables, los nombres de los enumeradores no pueden contener espacios. Si queremos utilizar nombres con un espacio, deberemos considerar utilizar NombreConEspacio o Nombre_Con_Espacio.
En los ejemplos anteriores, la primera muestra utiliza el inicializador predeterminado de 0 y, por lo tanto, los valores en la enumeración contiene los valores de 0 a 11; Ene = 0, Feb = 1, Mar = 2, y así sucesivamente. Pero usualmente utilizamos los meses como Ene = 1, Feb = 2, Mar = 3 y así sucesivamente. Para mantener esta representación numérica, podemos elegir la segunda muestra del código anterior e iniciar la enumeración
en 1, para adaptarnos a la representación numérica correcta.
El código utiliza un tipo de datos subyacente de int para representar los valores de la lista. Podemos elegir cambiar ese tipo predeterminado, siguiendo al nombre de la enumeración con dos puntos y el tipo de datos como se muestra en el siguiente código.
// utilizando un tipo de
datos diferente al de por defecto
enum Meses3 : byte
{
Ene,
Feb, Mar, Abr,
May, Jun, Jul,
Ago, Sep, Oct,
Nov, Dic
};
Sólo están permitidos ciertos tipos de datos para los tipos subyacentes en las enumeraciones. Los tipos de valor permitidos son:
byte
sbyte
short
ushort
int
uint
long
ulong
Todos estos tipos son tipos numéricos. Entonces, ¿por qué querríamos elegir un tipo subyacente diferente al predeterminado? Esto depende de nuestros requerimientos para nuestros valores de enumeración. Por ejemplo, si estamos realmente preocupados por la conservación de la memoria en nuestra aplicación, podemos elegir utilizar el tipo byte como se ha mostrado anteriormente. Un int es un valor de 32 bits, lo que significa 4 bytes mientras que tipo byte que utiliza solo un byte.
Podemos asignar a cada enumerador su propio valor no secuencial. Por ejemplo, los pilotos de aviones manejan diferentes velocidades de aire para descender con seguridad el tren de aterrizaje y los alerones. Esto se puedes representar por sus designadores de letras y luego asignar las velocidades del aire correspondientes a esos designadores utilizando una enumeración.
// enumeración para
representar las diferentes velocidades del aire
enum VelAire
{
Vx = 55,
Vy = 65,
Vs0 = 50,
Vs1 = 40,
Vne = 120
}
En esta enumeración se han establecido cinco enumeradores para representar diferentes velocidades del aire en un avión.
Vx es el mejor ángulo de velocidad de ascenso.
Vy es la mejor velocidad de ascenso.
Vs0 es la velocidad de pérdida en una configuración limpia.
Vs1 es la velocidad de pérdida con flaps extendidos.
Vne es la velocidad que nunca se debe exceder.
Si tuviéramos que escribir código que utilizara solo los valores numéricos, el código sería difícil de leer porque no podríamos descifrar fácilmente el significado de los valores. Con una Enumeración, los programadores entenderían el significado cuando se encuentren en el código los diferentes indicadores de velocidad.
Además de hacer que el código sea más fácil de leer, las enumeraciones tienen otras ventajas, como permitir que otros desarrolladores utilicen nuestra enumeración para saber
claramente cuáles son los valores permitidos para esa enumeración, y alimentar el motor IntelliSense de visual studio.
Cuando declara una enumeración y luego creamos un nuevo tipo que utiliza nuestra enumeración, IntelliSense muestra los valores permitidos.
Una enumeración es un tipo, es una instancia del tipo System.Enum. System.Enum contiene una serie de métodos que podemos utilizar con nuestras enumeraciones. A continuación hay un código de ejemplo que muestra un par de los métodos disponibles para nosotros cuando trabajamos con enumeraciones.
Utilizando un enum
class Program
{
enum
Meses { Ene = 1, Feb,
Mar, Abr, May,
Jun, Jul, Ago,
Sep, Oct, Nov,
Dic };
static void Main(string[] args)
{
string nombre = Enum.GetName(typeof(Meses), 8); Console.WriteLine("El mes octavo es
" + nombre);
Console.WriteLine("Meses subrayados en
la enum:");
foreach (int values in Enum.GetValues(typeof(Meses)))
{
Console.WriteLine(values);
Console.ReadLine();
}
}
}
Análisis
En el ejemplo anterior creamos una enumeración llamada Meses que inicia los valores en 1 e incrementa el valor predeterminado de 1 para cada mes subsiguiente. En el método main, crea una variable de cadena que llamamos nombre y luego utilizamos un método GetName () de System.Enum para obtener el octavo valor de la enumeración, y lo asignamos a la variable nombre. Como las enumeraciones implementan implícitamente IEnumerable, podemos iterar sobre ellas utilizando foreach. El bucle foreach utiliza el método GetValues () de la clase System.Enum para extraer los valores de la enumeración.
