Come posso verificare se è stato impostato più di un flag enum?

Question

Voglio solo sapere se è impostato esattamente un flag enum, non quali. Il mio attuale pensiero è quello di verificare se è un potere di 2. C'è un modo migliore integrato nei tipi di enumerazione?

[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

Se l'enum non definisce combinazioni espliciti di bandiere, si può solo controllare se il valore è definito nel enum:

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

Answer 3

E 'un operazione Bit!

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

la dichiarazione controlla se il valore di myFoo non è potenza di due. Oppure, vice versa, la dichiarazione (myFoo & (myFoo -1)) == 0 controlla la potenza di due. L'idea è che solo i valori di un singolo flag saranno due. L'impostazione di più di un flag comporterà l'assenza del valore di due valori di .

Ulteriori informazioni possono essere trovate in questa risposta a una domanda simile: https://stackoverflow.com/a/1662162/2404788.

Per ulteriori informazioni sulle operazioni bit vanno a http://en.wikipedia.org/wiki/Bitwise_operation

Answer 4

Come Jacob ha spiegato in un commento il metodo non è corretto a tutti. Personalmente evito sempre di programmare matematicamente, specialmente quando si tratta di logica. Quindi la mia soluzione sarebbe qualcosa come "se volessi sapere che il conteggio è uno, quindi contalo e confrontalo con il numero uno".

Eccolo:

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

E lo si può utilizzare per il vostro tipo foo in questo modo:

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

Credo che questo metodi potrebbero essere scritti in modo più generico utilizzando Generics e tipo metodi di manipolazione. Tuttavia ho incluso i metodi per i tipi di base più comuni per enumerazioni int e byte. Ma potresti anche scrivere lo stesso per brevi e altri tipi. Inoltre puoi semplicemente inserire il codice nel tuo codice. È solo una riga di codice.

Anche utilizzando questo metodo è possibile vedere se il numero di flag di serie è due o più. Il codice qui sotto restituisce true se il conteggio dei flag set è uguale a 'n'.

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