¿Cómo comparar las banderas en C#?

Question

Tengo una enumeración de la bandera a continuación.

[Flags] 
public enum FlagTest 
{ 
    None = 0x0, 
    Flag1 = 0x1, 
    Flag2 = 0x2, 
    Flag3 = 0x4 
} 

No puedo hacer que la sentencia if se evalúe como verdadera.

FlagTest testItem = FlagTest.Flag1 | FlagTest.Flag2; 

if (testItem == FlagTest.Flag1) 
{ 
    // Do something, 
    // however This is never true. 
} 

¿Cómo puedo hacer esto cierto?

Answer 1

En .NET 4 hay un método nuevo Enum.HasFlag. Esto le permite escribir:

if (testItem.HasFlag(FlagTest.Flag1)) 
{ 
    // Do Stuff 
} 

que es mucho más legible, IMO.

El.fuente neta indica que este realiza la misma lógica que la respuesta aceptada:

public Boolean HasFlag(Enum flag) { 
    if (!this.GetType().IsEquivalentTo(flag.GetType())) { 
     throw new ArgumentException(
      Environment.GetResourceString(
       "Argument_EnumTypeDoesNotMatch", 
       flag.GetType(), 
       this.GetType())); 
    } 

    ulong uFlag = ToUInt64(flag.GetValue()); 
    ulong uThis = ToUInt64(GetValue()); 
    // test predicate 
    return ((uThis & uFlag) == uFlag); 
} 

Answer 2

Para operaciones de bits, necesita utilizar operadores bit a bit.

Esto debería hacer el truco:

if ((testItem & FlagTest.Flag1) == FlagTest.Flag1) 
{ 
    // Do something, 
    // however This is never true. 
} 

Editar: fijo mi si cheque - Me puse de nuevo en mi C/C++ maneras (gracias a Ryan Farley para señalarlo)

Answer 3

if ((testItem & FlagTest.Flag1) == FlagTest.Flag1) 
{ 
    // Do something 
} 

(testItem & FlagTest.Flag1) es una operación Y a nivel de bit.

FlagTest.Flag1 es equivalente a 001 con la enumeración de OP. Ahora digamos que testItem tiene Flag1 y Flag2 (por lo que es bit a bit 101):

001 
&101 
---- 
    001 == FlagTest.Flag1 

Answer 4

if((testItem & FlagTest.Flag1) == FlagTest.Flag1) 
{ 
... 
} 

Answer 5

Prueba esto:

if ((testItem & FlagTest.Flag1) == FlagTest.Flag1) 
{ 
    // do something 
} 

Básicamente, el código está preguntando si tienen ambos indicadores establecidos es lo mismo que tener un conjunto bandera, que obviamente es falso El código de arriba dejará solo el bit de Flag1 establecido si está configurado en absoluto, luego compara este resultado con Flag1.

Answer 6

Configuré un método de extensión para hacerlo: related question.

Básicamente:

public static bool IsSet(this Enum input, Enum matchTo) 
{ 
    return (Convert.ToUInt32(input) & Convert.ToUInt32(matchTo)) != 0; 
} 

entonces usted puede hacer:

FlagTests testItem = FlagTests.Flag1 | FlagTests.Flag2; 

if(testItem.IsSet (FlagTests.Flag1)) 
    //Flag1 is set 

---

A propósito de la convención que utilizo para enumeraciones es singular para el estándar, plural para banderas. De esta forma sabrá a partir del nombre enum si puede contener múltiples valores.

Answer 7

En cuanto a la edición. No puedes hacer que sea verdad. Te sugiero que envuelvas lo que quieras en otra clase (o método de extensión) para acercarte a la sintaxis que necesitas.

es decir

public class FlagTestCompare 
{ 
    public static bool Compare(this FlagTest myFlag, FlagTest condition) 
    { 
     return ((myFlag & condition) == condition); 
    } 
} 

Answer 8

Para aquellos que tienen problemas para visualizar lo que está sucediendo con la solución aceptada (que es esto),

if ((testItem & FlagTest.Flag1) == FlagTest.Flag1) 
{ 
    // Do stuff. 
} 

testItem (de acuerdo con la pregunta) se define como,

testItem 
= flag1 | flag2 
= 001 | 010 
= 011 

a continuación, en la sentencia if, el lado izquierdo de la comparación es,

(testItem & flag1) 
= (011 & 001) 
= 001 

y la plena instrucción if (que es verdadero si flag1 se encuentra en testItem),

(testItem & flag1) == flag1 
= (001) == 001 
= true 

Answer 9

Un consejo más ... Nunca hacer la comprobación binaria estándar con la bandera cuya el valor es "0". Su cheque en esta bandera siempre será verdadero.

[Flags] 
public enum LevelOfDetail 
{ 
    [EnumMember(Value = "FullInfo")] 
    FullInfo=0, 
    [EnumMember(Value = "BusinessData")] 
    BusinessData=1 
} 

---

Si parámetro de entrada binaria cheque contra FullInfo - se obtiene:

detailLevel = LevelOfDetail.BusinessData; 
bool bPRez = (detailLevel & LevelOfDetail.FullInfo) == LevelOfDetail.FullInfo; 

bPRez siempre será cierto como cualquier cosa & 0 siempre == 0.

---

En su lugar, simplemente debe verificar que el valor de la entrada sea 0:

bool bPRez = (detailLevel == LevelOfDetail.FullInfo); 

Answer 10

@ Phil-devaney

Tenga en cuenta que, excepto en los casos más sencillos, la Enum.HasFlag lleva una penalización de rendimiento pesada en comparación con escribir el código manualmente. Considere el siguiente código:

[Flags] 
public enum TestFlags 
{ 
    One = 1, 
    Two = 2, 
    Three = 4, 
    Four = 8, 
    Five = 16, 
    Six = 32, 
    Seven = 64, 
    Eight = 128, 
    Nine = 256, 
    Ten = 512 
} 


class Program 
{ 
    static void Main(string[] args) 
    { 
     TestFlags f = TestFlags.Five; /* or any other enum */ 
     bool result = false; 

     Stopwatch s = Stopwatch.StartNew(); 
     for (int i = 0; i < 10000000; i++) 
     { 
      result |= f.HasFlag(TestFlags.Three); 
     } 
     s.Stop(); 
     Console.WriteLine(s.ElapsedMilliseconds); // *4793 ms* 

     s.Restart(); 
     for (int i = 0; i < 10000000; i++) 
     { 
      result |= (f & TestFlags.Three) != 0; 
     } 
     s.Stop(); 
     Console.WriteLine(s.ElapsedMilliseconds); // *27 ms*   

     Console.ReadLine(); 
    } 
} 

Más de 10 millones de iteraciones, el método de extensión HasFlags lleva la friolera de 4793 ms, en comparación con los 27 ms para la puesta en práctica a nivel de bits estándar.

Answer 11

incluso sin [Banderas], podría utilizar algo como esto

if((testItem & (FlagTest.Flag1 | FlagTest.Flag2))!=0){ 
//.. 
} 

o si tiene una enumeración valor cero

if((testItem & (FlagTest.Flag1 | FlagTest.Flag2))!=FlagTest.None){ 
//.. 
}