C#: Meilleur moyen de vérifier par rapport à un ensemble de Valeurs Enum?

Si vous en faites une [Flags] enum, vous pouvez affecter une autre valeur de bit (1, 2, 4, 8, 16...) pour chaque valeur énumérée. Ensuite, vous pouvez utiliser une opération au niveau du bit pour déterminer si une valeur est un ensemble de valeurs possibles.

Alors, pour voir si elle est C, D ou F:

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

ou à l'aide de HasFlag() (la moins efficace mais plus lisible):

bool IsCDF(MyEnum enumValue)
{
    return enumValue.HasFlag(MyEnum.C | MyEnum.D | MyEnum.F);
}

Notez que cela ne fonctionne pas pour une valeur de 0 (dans votre exemple, 'A'), et vous devez veiller à ce que toutes les valeurs de l'enum résoudre unique des valeurs des bits (c'est à dire non-zéro des puissances de deux).

Les avantages de cette approche sont:

• il sera généralement prendre un seul PROCESSEUR d'instructions/cycle pour exécuter, alors que faire les trois "si", vérifications de prendre 3 ou plusieurs instructions (en fonction de votre plate-forme cible).
• Vous pouvez passer l'ensemble des valeurs que vous souhaitez tester avec une valeur d'enum (un entier) au lieu de devoir utiliser des listes de valeurs enum.
• Vous pouvez faire beaucoup d'autres choses utiles avec les opérations bit à bit, ce qui serait maladroit et lent avec de l'ordinaire numérique/approches comparatives.

Indication de la main:
Lors de la définition de [Drapeaux] enums, utilisez décalage vers la gauche (<<) afin de rendre les valeurs des bits plus clair (et beaucoup plus difficile de se tromper), surtout pour les plus élevés de bits d'ordre:

[Flags]
enum MyEnum
{
    A = 1 << 0,     //Equivalent to 1
    B = 1 << 1,     //Equivalent to 2
    C = 1 << 2,     //Equivalent to 4
    D = 1 << 3,     //Equivalent to 8
    …
    Big = 1 << 26,  //Equivalent to 67108864
}

OriginalL'auteur Jason Williams

J'avais peut-être l'utiliser Sans Contrainte Mélodie comme un moyen de garder les choses en ordre:

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

Je serais probablement extraire le "C, D ou E" bit dans une constante nommée, peut - être sous l'enum lui-même, si elle avait un sens:

OriginalL'auteur Jon Skeet

Peut-être que cette classe d'extension est utile pour vous:

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);
}
}
}

OriginalL'auteur Felix C