Bagaimana Membandingkan Bendera dalam C #?

Saya memiliki bendera enum di bawah ini.

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

Saya tidak bisa membuat pernyataan if mengevaluasi ke true.

FlagTest testItem = FlagTest.Flag1 | FlagTest.Flag2;

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

Bagaimana saya bisa mewujudkannya?

Di .NET 4 ada metode baru Enum.HasFlag . Ini memungkinkan Anda untuk menulis:

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

yang jauh lebih mudah dibaca, IMO.

Sumber .NET menunjukkan bahwa ini melakukan logika yang sama dengan jawaban yang diterima:

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) adalah operasi DAN bitwise.

FlagTest.Flag1setara dengan 001dengan enum OP. Sekarang katakanlah testItemmemiliki Flag1 dan Flag2 (jadi bitwise 101):

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

Bagi mereka yang kesulitan memvisualisasikan apa yang terjadi dengan solusi yang diterima (yang ini),

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

testItem (sesuai pertanyaan) didefinisikan sebagai,

testItem 
 = flag1 | flag2  
 = 001 | 010  
 = 011

Kemudian, dalam pernyataan if, sisi kiri perbandingan adalah,

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

Dan pernyataan if penuh (yang mengevaluasi true jika flag1diatur dalam testItem),

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

@ phil-devaney

Perhatikan bahwa kecuali dalam kasus yang paling sederhana, Enum.HasFlag membawa penalti performa yang berat dibandingkan dengan menuliskan kode secara manual. Pertimbangkan kode berikut:

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

Lebih dari 10 juta iterasi, metode ekstensi HasFlags mengambil 4793 ms kekalahan, dibandingkan dengan 27 ms untuk implementasi bitwise standar.

Saya menyiapkan metode ekstensi untuk melakukannya: pertanyaan terkait .

Pada dasarnya:

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

Maka Anda dapat melakukan:

FlagTests testItem = FlagTests.Flag1 | FlagTests.Flag2;

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

Kebetulan konvensi yang saya gunakan untuk enums adalah singular untuk standar, jamak untuk bendera. Dengan begitu Anda tahu dari nama enum apakah itu bisa menampung beberapa nilai.

Satu saran lagi ... Jangan pernah melakukan pemeriksaan biner standar dengan flag yang nilainya "0". Cek Anda pada bendera ini akan selalu benar.

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

Jika Anda biner memeriksa parameter input terhadap FullInfo - Anda mendapatkan:

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

bPRez akan selalu benar karena APA SAJA & 0 selalu == 0.

Sebagai gantinya, Anda cukup memeriksa bahwa nilai input adalah 0:

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

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

Untuk operasi bit, Anda perlu menggunakan operator bitwise.

Ini harus melakukan trik:

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

Sunting: Memperbaiki cek saya jika - Saya kembali ke C / C ++ cara saya (terima kasih kepada Ryan Farley untuk menunjukkannya)

Mengenai hasil edit. Anda tidak bisa mewujudkannya. Saya sarankan Anda membungkus apa yang Anda inginkan ke kelas lain (atau metode ekstensi) untuk lebih dekat dengan sintaks yang Anda butuhkan.

yaitu

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

Coba ini:

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

bahkan tanpa [Bendera], kamu bisa menggunakan sesuatu seperti ini

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

atau jika Anda memiliki nilai nol enum

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