Wie vergleiche ich Flags in C #?

Ich habe unten eine Flaggenaufzählung.

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

Ich kann die if-Anweisung nicht als wahr bewerten lassen.

FlagTest testItem = FlagTest.Flag1 | FlagTest.Flag2;

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

Wie kann ich das wahr machen?

In .NET 4 gibt es eine neue Methode Enum.HasFlag . So können Sie schreiben:

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

Das ist viel besser lesbar, IMO.

Die .NET-Quelle gibt an, dass dies dieselbe Logik wie die akzeptierte Antwort ausführt:

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) ist eine bitweise UND-Verknüpfung.

FlagTest.Flag1entspricht 001der Aufzählung von OP. Lassen Sie uns jetzt sagen testItemhat Flag1 und Flag2 (so ist es bitweise 101):

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

Für diejenigen, die Probleme haben, sich vorzustellen, was mit der akzeptierten Lösung passiert (was das ist),

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

testItem (gemäß der Frage) ist definiert als,

testItem 
 = flag1 | flag2  
 = 001 | 010  
 = 011

Dann ist in der if-Anweisung die linke Seite des Vergleichs:

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

Und die vollständige if-Anweisung (die als true ausgewertet wird, wenn gesetzt flag1ist testItem),

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

@ Phil-Devaney

Beachten Sie, dass Enum.HasFlag , außer in den einfachsten Fällen, im Vergleich zum manuellen Schreiben des Codes eine erhebliche Leistungsminderung mit sich bringt. Betrachten Sie den folgenden Code:

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

Über 10 Millionen Iterationen benötigt die HasFlags-Erweiterungsmethode satte 4793 ms, verglichen mit 27 ms für die standardmäßige bitweise Implementierung.

Ich habe dafür eine Erweiterungsmethode eingerichtet: verwandte Frage .

Grundsätzlich:

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

Dann können Sie tun:

FlagTests testItem = FlagTests.Flag1 | FlagTests.Flag2;

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

Übrigens ist die Konvention, die ich für Enums verwende, Singular für Standard, Plural für Flags. Auf diese Weise wissen Sie anhand des Aufzählungsnamens, ob er mehrere Werte enthalten kann.

Noch ein Ratschlag ... Führen Sie niemals die Standard-Binärprüfung mit dem Flag durch, dessen Wert "0" ist. Ihre Überprüfung dieser Flagge wird immer wahr sein.

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

Wenn Sie den Eingabeparameter binär gegen FullInfo prüfen, erhalten Sie:

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

bPRez ist immer wahr als ALLES & 0 immer == 0.

Stattdessen sollten Sie einfach überprüfen, ob der Wert der Eingabe 0 ist:

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

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

Für Bitoperationen müssen Sie bitweise Operatoren verwenden.

Dies sollte den Trick tun:

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

Bearbeiten: Meine if-Prüfung wurde behoben. Ich bin wieder in meine C / C ++ - Methoden zurückgekehrt (danke an Ryan Farley für den Hinweis).

In Bezug auf die Bearbeitung. Du kannst es nicht wahr machen. Ich schlage vor, dass Sie das, was Sie wollen, in eine andere Klasse (oder Erweiterungsmethode) einbinden, um der von Ihnen benötigten Syntax näher zu kommen.

dh

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

Versuche dies:

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

Auch ohne [Flags] könnten Sie so etwas verwenden

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

oder wenn Sie eine Nullwert-Aufzählung haben

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