Enumeraciones en C# - Parte 4

Tabla de Contenido

0. Introducción
1. Operadores de Igualdad y Asignación
2. Operadores de Comparación
3. Operadores Aritméticos
4. Operadores Bitwise
5. Operador sizeof
6. Notas Importantes
7. Conclusiones
8. Glosario
9. Literatura & Enlaces

0. Introducción

En esta cuarta parte de la serie de Enumeraciones en C#, ha llegado el momento de tratar con el funcionamiento de los operadores permitidos para las enumeraciones. Incluiré la demostración de varios de los operadores disponibles para manipular los valores de una constante de una enumeración; igualmente, presentaré las restricciones impuestas sobre los operadores al manipular dos o más constantes de una enumeración. Incluiré, además, ejemplos concretos para comprender a fondo el uso de los operadores: =, ==, !=, <, >, <=, >=, +, -, ^, &, |, ~, +=, -=, ++, --, sizeof.

Artículos de la serie:

Parte 1 - Introducción a la enumeraciones en C#
Parte 2 - Operaciones de las enumeraciones
Parte 3 - Valores bandera de las enumeraciones
Parte 4 - Operadores de las enumeraciones
Parte 5 - Casos de seguridad de tipos

1. Operadores de Igualdad y Asignación

Los operadores de igualdad permitidos para las enumeración son los siguientes:

• == : Determina si dos constantes de una enumeración contienen el mismo valor.
• != : Determina si dos constantes (miembros) de una enumeración contienen valores diferentes.

Veamos estos ejemplos de uso:

if ((derechoIzquierdo & Bordes.Derecho) != 0)

En esta línea de código se realiza la operación bitwise AND para determinar si la variable derechoIzquierdo (Bordes) contiene el valor Bordes.Derecho. Finalmente se determina a través del operador de igualdad, !=, si el resultado de la operación AND es diferente de cero.

El operador de igualdad, == (leído: igual-igual) se usa de la siguiente manera:

if ((borde & Bordes.Derecho) == 1)

Esta línea determina si la variable borde al operarla con Borde.Derecho a través de la operación bitwise AND (&), poseen los mismos valores.

[Nota: Más acerca de estos operadores en [3].]

2. Operadores de Comparación

Este es el conjunto de los operadores permitidos para una enumeración:

• < : (Menor que) 
• > : (Mayor que)
• <= : (Menor o igual a)
• >= : (Mayor o igual a)

Veamos ejemplos de cada uno:

Menor que (<):

Console.WriteLine(Dias.Jueves < Dias.Miercoles); // Salida: False

Mayor que (>):

Console.WriteLine(Dias.Martes > Dias.Lunes); // Salida: True

Menor o igual a (<=):

Dias martes = Dias.Martes;

Console.WriteLine(Dias.Miercoles >= martes); // Salida: True

Mayor o igual a (>=):

Console.WriteLine(Dias.Viernes <= Dias.Jueves); // Salida: False

3. Operadores Aritméticos

Antes de entrar en detalles acerca de las operaciones aritméticas permitidas sobre las enumeraciones, vale aclarar que la adición sólo está permitida entre un miembro (constante) de la enumeración y un valor entero concreto. Inclusive, intentar sumar dos constantes la enumeración generará un error [1].

Veamos lo que ocurre al intentar sumar dos constantes:

Dias lunes = Dias.Lunes;

Dias miercoles = Dias.Miercoles;

Console.WriteLine(lunes + miercoles);

La última línea generará el error CS0019 [5]:

error CS0019: Operator `+' cannot be applied to operands of type `Dias' and `Dias'

> Prueba de ejecución.

Mientras que:

La suma y la resta se realizan de esta manera:

Dias lunes = Dias.Lunes;

Dias miercoles = Dias.Miercoles;

Dias suma = lunes + (1 << 1);

Console.WriteLine("Suma de `lunes` y `(1 << 1)`: {0}", suma.ToString("F"));

Dias resta = miercoles - (1 << 2);

Console.WriteLine("Resta de `miercoles` y (1 << 2)`: {0}", resta.ToString("F"));

> Prueba de ejecución.

Resultado:

Suma de `lunes` y `(1 << 1)`: Martes

Resta de `miercoles` y (1 << 2)`: Martes

4. Operadores Bitwise

[Nota: En la sección 2 (Banderas en Enumeraciones) se explican los operadores | (OR inclusivo), & (AND), y ^ (OR exclusivo) de la parte 3 acerca de Enumeraciones en C#: Enumeraciones en C# - Parte 3.]

5. Operador sizeof de una Enumeración

Podemos usar el operador sizeof [6] para obtener el espacio ocupado en memoria por una enumeración. Por ejemplo:

int tamanioEnum = sizeof(Dias);

Console.WriteLine("El tamaño de la enumeración `Dias` es {0} bytes", tamanioEnum);

> Prueba de ejecución.

Resultado:

El tamaño de la enumeración `Dias` es 4 bytes

6. Notas Importantes

Recomiendo la lectura de otro de mis artículos donde se describe con más nivel de detalle el uso de los operadores bitwise:

Enlace: Operadores Bitwise (Bit a Bit) en C#.

Por otro lado, en [1] nos advierten de:

The bitwise, arithmetic, and comparison operators return the result of processing the underlying integral values.

7. Conclusiones

Hemos aprendido a usar varios de los operadores aplicables a enumeraciones. Vimos el uso de los operadores de igualdad, de comparación, aritméticos, bit-a-bit (bitwise). Al final practicamos, grosso modo, el uso del operador sizeof que nos sirve para obtener el tamaño (en byte) de una enumeración.

8. Glosario

• Bit a bit
• Bitwise
• Desplazamiento bit a la izquierda
• Desplazamiento bit a la derecha
• Operador
• sizeof

9. Literatura & Enlaces

[1]: C# 5.0 in a Nutshell by Joseph Albahari and Ben Albahari. Copyright 2012 Joseph Albahari and Ben Albahari, 978-1-449-32010-2.
[2]: 14.5 Enum values and operations - http://msdn.microsoft.com/en-us/library/aa664601(v=vs.71).aspx
[3]: 7.9.5 Enumeration comparison operators (C#) - http://msdn.microsoft.com/en-us/library/aa664726(v=vs.71).aspx
[4]: Enums in C# - CodeProject - http://www.codeproject.com/Articles/18809/Enums-in-C
[5]: Compiler Error CS0019 - http://msdn.microsoft.com/en-us/library/a63h61ky.aspx
[6]: sizeof (C# Reference) - http://msdn.microsoft.com/en-us/library/eahchzkf.aspx
[7]: Operadores Bitwise (Bit a Bit) en C# | OrtizOL - Experiencias Construcción Software (xCSw) - http://ortizol.blogspot.com/2013/07/operadores-bitwise-bit-bit-en-c.html

J