Comment comparer les drapeaux en C #?

J'ai une énumération de drapeau ci-dessous.

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

Je ne peux pas donner à l'instruction if la valeur true.

FlagTest testItem = FlagTest.Flag1 | FlagTest.Flag2;

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

Comment puis-je rendre cela vrai?

Dans .NET 4, il existe une nouvelle méthode Enum.HasFlag . Cela vous permet d'écrire:

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

ce qui est beaucoup plus lisible, IMO.

La source .NET indique que cela exécute la même logique que la réponse acceptée:

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

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

(testItem & FlagTest.Flag1) est une opération AND au niveau du bit.

FlagTest.Flag1équivaut à 001l'énumération de OP. Maintenant, disons testItema Flag1 et Flag2 (donc c'est au niveau du bit 101):

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

Pour ceux qui ont du mal à visualiser ce qui se passe avec la solution acceptée (qui est la suivante),

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

testItem (selon la question) est défini comme,

testItem 
 = flag1 | flag2  
 = 001 | 010  
 = 011

Ensuite, dans l'instruction if, le côté gauche de la comparaison est,

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

Et l'instruction if complète (qui prend la valeur true si flag1est définie dans testItem),

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

@ phil-devaney

Notez que, sauf dans les cas les plus simples, Enum.HasFlag entraîne une forte pénalité de performances par rapport à l'écriture manuelle du code. Considérez le code suivant:

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

Plus de 10 millions d'itérations, la méthode d'extension HasFlags prend 4793 ms, contre 27 ms pour l'implémentation standard au niveau du bit.

J'ai mis en place une méthode d'extension pour le faire: question connexe .

Fondamentalement:

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

Ensuite, vous pouvez faire:

FlagTests testItem = FlagTests.Flag1 | FlagTests.Flag2;

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

Incidemment, la convention que j'utilise pour les énumérations est au singulier pour le standard, au pluriel pour les drapeaux. De cette façon, vous savez à partir du nom enum s'il peut contenir plusieurs valeurs.

Un conseil de plus ... Ne faites jamais la vérification binaire standard avec le drapeau dont la valeur est "0". Votre vérification sur ce drapeau sera toujours vraie.

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

Si vous vérifiez le paramètre d'entrée binaire par rapport à FullInfo - vous obtenez:

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

bPRez sera toujours vrai comme TOUT & 0 toujours == 0.

Au lieu de cela, vous devez simplement vérifier que la valeur de l'entrée est 0:

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

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

Pour les opérations sur les bits, vous devez utiliser des opérateurs de bits.

Cela devrait faire l'affaire:

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

Edit: Correction de mon if check - je suis retourné dans mes méthodes C / C ++ (merci à Ryan Farley pour l'avoir signalé)

Concernant l'édition. Vous ne pouvez pas le rendre vrai. Je vous suggère d'envelopper ce que vous voulez dans une autre classe (ou méthode d'extension) pour vous rapprocher de la syntaxe dont vous avez besoin.

c'est à dire

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

Essaye ça:

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

même sans [Flags], vous pouvez utiliser quelque chose comme ça

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

ou si vous avez une énumération de valeur zéro

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