¿Cómo verifico si hay más de una bandera enum configurada?

Question

Solo quiero saber si se ha configurado exactamente una bandera enum, no cuáles. Mi pensamiento actual es comprobar si es un poder de 2. ¿Hay alguna manera mejor incorporada a los tipos enum?

[Flags] 
enum Foo 
{ 
Flag1 = 0x01, 
Flag2 = 0x02, 
Flag3 = 0x04, 
Flag4 = 0x08, 
Flag5 = 0x10, 
Flag6 = 0x20, 
Flag7 = 0x40, 
Flag8 = 0x80 
} 

private bool ExactlynOneFlagSet(Foo myFoo) 
{ 
    var x = (byte) myFoo; 
    return (x != 0) && ((x & (x - 1)) == 0); //Check if a power of 2 
} 

if(!ExactlynOneFlagSet(Foo myFoo)) 
{ 
    //Do something 
} 

Answer 1

private bool ExatlyOneFlagSet(Foo myFoo) 
{ 
    return !myFoo.ToString().Contains(','); 
} 

Answer 2

Si la enumeración no define combinaciones explícitas de banderas, sólo puede comprobar si el valor se define en la enumeración:

private bool ExactlynOneFlagSet(Foo myFoo) 
{ 
    return Enum.IsDefined(typeof(Foo), myFoo); 
} 

Answer 3

Es una operación poco!

if ((myFoo & (myFoo -1)) != 0) //has more than 1 flag 

Las comprobaciones de los estados si el valor de myFoo no es potencia de dos. O, viceversa, la instrucción (myFoo & (myFoo -1)) == 0 comprueba la potencia de dos. La idea es que solo los valores de bandera única serán potencia de dos. Establecer más de un indicador dará como resultado una potencia no de dos valores de myFoo.

Más información se puede encontrar en esta respuesta a una pregunta similar: https://stackoverflow.com/a/1662162/2404788.

Para obtener más información acerca de las operaciones de bits van a http://en.wikipedia.org/wiki/Bitwise_operation

Answer 4

Como Jacob explica en un comentario de su método no es correcto en absoluto. Personalmente siempre evito programar matemáticamente, especialmente cuando se trata de lógica. Entonces, mi solución sería algo así como "si quisiera saber que el recuento es uno, cuenten y compárenlo con el número uno".

Aquí está:

public static bool OneIsSet(Type enumType, byte value) 
    { 
     return Enum.GetValues(enumType).Cast<byte>().Count(v => (value & v) == v) == 1; 
    } 

    public static bool OneIsSet(Type enumType, int value) 
    { 
     return Enum.GetValues(enumType).Cast<byte>().Count(v => (value & v) == v) == 1; 
    } 

Y usted puede utilizarlo para su tipo foo como esto:

var toReturnFalse = (byte)(foo.Flag1 | foo.Flag2); 
    var toReturnTrue = (byte)foo.Flag1; 
    var trueWillBeReturned = OneIsSet(typeof(foo), toReturnTrue); 
    var falseWillBeReturned = OneIsSet(typeof(foo), toReturnFalse); 

Creo que estos métodos pueden ser escritos de una manera más genérica utilizando los genéricos y el tipo métodos de manejo Sin embargo, incluí los métodos para los tipos de base más comunes para enumeraciones que son int y byte. Pero también puedes escribir lo mismo para abreviar y otros tipos. También puede insertar el código en su código. Es solo una linea de codigo

También utilizando este método, puede ver si el número de banderas establecidas es dos o más. El código siguiente devuelve verdadero si el recuento de banderas establecidas es igual a 'n'.

Enum.GetValues(enumType).Cast<byte>().Count(v => (value & v) == v) == n;