C#: ¿La mejor manera de comparar con un conjunto de valores de Enum?

Question

suponga que tiene enum MyEnum {A = 0, B = 1, C = 2, D = 4, E = 8, F = 16};

En algún momento usted tiene una función que compruebe una instancia de MyEnum y devolver verdadero si es C, D o F

bool IsCDF(MyEnum enumValue) 
{ 
    return //something slick 
} 

Recuerdo que había una cierta Manera muy hábil para hacer cambios de bit y preformar esta operación que se lee mucho mejor que un montón de declaraciones terciarias, pero por mi vida no puedo recordar de qué se trata.

¿Alguien sabe?

Answer 1

Si usted hace un [Banderas] enumeración, se puede asignar un valor poco diferente (1, 2, 4, 8, 16 ...) para cada valor enumerado. Luego puede usar una operación bit a bit para determinar si un valor es uno de un conjunto de valores posibles.

lo tanto, para ver si es C, D o F:

bool IsCDF(MyEnum enumValue) 
{ 
    return((enumValue & (MyEnum.C | MyEnum.D | MyEnum.F)) != 0); 
} 

Tenga en cuenta que esto no va a funcionar para un valor de 0 (en el ejemplo, 'A'), y debe estar cuidadoso de que todos los valores de enum se resuelvan en valores de bit únicos (es decir, potencias de dos diferentes de cero).

Las ventajas de este enfoque son:

• se suele tomar una sola instrucción de la CPU para ejecutar, mientras que haciendo tres separada "si" verificaciones tendrán en 3 o más instrucciones (dependiendo de la plataforma de destino).
• puede pasar el conjunto de valores que desea probar con como un valor de enumeración (un entero) en lugar de tener que utilizar listas de valores de enumeración.
• Puede hacer muchas otras cosas útiles con operaciones bit a bit, que serían torpes y lentas con los enfoques numéricos/comparativos ordinarios.

Answer 2

return (enumValue & MyEnum.C == MyEnum.C) 
     || (enumValue & MyEnum.D == MyEnum.D) 
     || (enumValue & MyEnum.F == MyEnum.F); 

Answer 3

Puede estar pensando en FlagsAttribute. Mire here y here para algunos ejemplos.

Usted podría utilizar Enum.HasFlag Method

Answer 4

que posiblemente haría uso de Unconstrained Melody como una forma de mantener las cosas ordenadas:

if (value.HasAny(MyEnum.C | MyEnum.D | MyEnum.E)) 
{ 
    ... 
} 

probablemente me extraer el bit "C, D o E" en una constante llamada - posiblemente en la enumeración sí, si tuviera significado:

Answer 5

Tal vez esta clase de extensión es muy útil para usted:

public static class Flags 
{ 
    /// <summary> 
    /// Checks if the type has any flag of value. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="type"></param> 
    /// <param name="value"></param> 
    /// <returns></returns> 
    public static bool HasAny<T>(this System.Enum type, T value) 
    { 
     try 
     { 
      return (((int) (object) type & (int) (object) value) != 0); 
     } 
     catch 
     { 
      return false; 
     } 
    } 

    /// <summary> 
    /// Checks if the value contains the provided type. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="type"></param> 
    /// <param name="value"></param> 
    /// <returns></returns> 
    public static bool Has<T>(this System.Enum type, T value) 
    { 
     try 
     { 
      return (((int)(object)type & (int)(object)value) == (int)(object)value); 
     } 
     catch 
     { 
      return false; 
     } 
    } 

    /// <summary> 
    /// Checks if the value is only the provided type. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="type"></param> 
    /// <param name="value"></param> 
    /// <returns></returns> 
    public static bool Is<T>(this System.Enum type, T value) 
    { 
     try 
     { 
      return (int)(object)type == (int)(object)value; 
     } 
     catch 
     { 
      return false; 
     } 
    } 

    /// <summary> 
    /// Appends a value. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="type"></param> 
    /// <param name="value"></param> 
    /// <returns></returns> 
    public static T Add<T>(this System.Enum type, T value) 
    { 
     try 
     { 
      return (T)(object)(((int)(object)type | (int)(object)value)); 
     } 
     catch (Exception ex) 
     { 
      throw new ArgumentException(
       string.Format(
        "Could not append value from enumerated type '{0}'.", 
        typeof(T).Name 
        ), ex); 
     } 
    } 

    /// <summary> 
    /// Appends a value. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="type"></param> 
    /// <param name="value"></param> 
    /// <returns></returns> 
    public static void AddTo<T>(this System.Enum type, ref T value) 
    { 
     try 
     { 
      value = (T)(object)(((int)(object)type | (int)(object)value)); 
     } 
     catch (Exception ex) 
     { 
      throw new ArgumentException(
       string.Format(
        "Could not append value from enumerated type '{0}'.", 
        typeof(T).Name 
        ), ex); 
     } 
    } 

    /// <summary> 
    /// Removes the value. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="type"></param> 
    /// <param name="value"></param> 
    /// <returns></returns> 
    public static T Remove<T>(this System.Enum type, T value) 
    { 
     try 
     { 
      return (T)(object)(((int)(object)type & ~(int)(object)value)); 
     } 
     catch (Exception ex) 
     { 
      throw new ArgumentException(
       string.Format(
        "Could not remove value from enumerated type '{0}'.", 
        typeof(T).Name 
        ), ex); 
     } 
    } 

    /// <summary> 
    /// Removes the value. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="type"></param> 
    /// <param name="value"></param> 
    /// <returns></returns> 
    public static void RemoveFrom<T>(this System.Enum type, ref T value) 
    { 
     try 
     { 
      value = (T)(object)(((int)(object)type & ~(int)(object)value)); 
     } 
     catch (Exception ex) 
     { 
      throw new ArgumentException(
       string.Format(
        "Could not remove value from enumerated type '{0}'.", 
        typeof(T).Name 
        ), ex); 
     } 
    } 
} 

Answer 6

bool IsCDF(MyEnum enumValue) 
{ 
    return new[]{MyEnum.C, MyEnum.D, MyEnum.F}.Contains(enumValue); 
}