Jak porównać flagi w C #?

Poniżej mam wyliczenie flag.

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

Nie mogę sprawić, by stwierdzenie if było prawdziwe.

FlagTest testItem = FlagTest.Flag1 | FlagTest.Flag2;

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

Jak mogę to urzeczywistnić?

W .NET 4 jest nowa metoda Enum.HasFlag . Dzięki temu możesz napisać:

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

co jest dużo bardziej czytelne, IMO.

Źródło .NET wskazuje, że działa to tak samo, jak zaakceptowana odpowiedź:

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) jest operacją bitową AND.

FlagTest.Flag1jest równoważne 001z wyliczeniem OP. Teraz powiedzmy, że testItemma Flag1 i Flag2 (więc jest bitowa 101):

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

Dla tych, którzy mają problem z wizualizacją tego, co dzieje się z przyjętym rozwiązaniem (czyli tym),

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

testItem (zgodnie z pytaniem) definiuje się jako:

testItem 
 = flag1 | flag2  
 = 001 | 010  
 = 011

Następnie w instrukcji if lewa strona porównania to:

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

A pełna instrukcja if (która flag1daje wartość true, jeśli jest ustawiona w testItem),

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

@ phil-devaney

Zauważ, że z wyjątkiem najprostszych przypadków, Enum.HasFlag niesie znaczny spadek wydajności w porównaniu z ręcznym pisaniem kodu. Rozważ następujący kod:

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

Ponad 10 milionów iteracji, metoda rozszerzenia HasFlags zajmuje aż 4793 ms, w porównaniu z 27 ms dla standardowej implementacji bitowej.

Ustawiłem metodę rozszerzenia, aby to zrobić: pytanie powiązane .

Gruntownie:

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

Następnie możesz:

FlagTests testItem = FlagTests.Flag1 | FlagTests.Flag2;

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

Nawiasem mówiąc, konwencja, której używam dla wyliczeń, jest pojedyncza dla standardu, liczba mnoga dla flag. W ten sposób na podstawie nazwy wyliczenia wiesz, czy może on zawierać wiele wartości.

Jeszcze jedna rada ... Nigdy nie wykonuj standardowego testu binarnego z flagą, której wartość wynosi "0". Twoje sprawdzenie tej flagi zawsze będzie prawdziwe.

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

Jeśli binarnie sprawdzisz parametr wejściowy względem FullInfo - otrzymasz:

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

bPRez zawsze będzie prawdziwe jako WSZYSTKO i 0 zawsze == 0.

Zamiast tego powinieneś po prostu sprawdzić, czy wartość wejścia wynosi 0:

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

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

W przypadku operacji bitowych należy używać operatorów bitowych.

To powinno załatwić sprawę:

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

Edycja: Naprawiono mój czek if - wróciłem do moich sposobów C / C ++ (dzięki Ryanowi Farleyowi za wskazanie tego)

Odnośnie edycji. Nie możesz tego zrobić. Sugeruję zawinięcie tego, co chcesz, do innej klasy (lub metody rozszerzenia), aby zbliżyć się do potrzebnej składni.

to znaczy

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

Spróbuj tego:

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

nawet bez [Flags] możesz użyć czegoś takiego

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

lub jeśli masz wyliczenie o wartości zero

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