Untuk kehidupan saya, saya tidak ingat bagaimana mengatur, menghapus, beralih atau menguji sedikit di bitfield. Entah saya tidak yakin atau saya mencampurnya karena saya jarang membutuhkan ini. Jadi "bit-cheat-sheet" akan menyenangkan untuk dimiliki.

Sebagai contoh:

flags = flags | FlagsEnum.Bit4;  // Set bit 4.

atau

if ((flags & FlagsEnum.Bit4)) == FlagsEnum.Bit4) // Is there a less verbose way?

Bisakah Anda memberikan contoh dari semua operasi umum lainnya, lebih disukai dalam sintaks C # menggunakan enum [Bendera]?

Saya melakukan beberapa pekerjaan pada ekstensi ini - Anda dapat menemukan kode di sini

Saya menulis beberapa metode ekstensi yang memperpanjang System.Enum yang sering saya gunakan ... Saya tidak mengklaim bahwa mereka antipeluru, tetapi mereka telah membantu ... Komentar dihapus ...

namespace Enum.Extensions {

    public static class EnumerationExtensions {

        public static bool Has<T>(this System.Enum type, T value) {
            try {
                return (((int)(object)type & (int)(object)value) == (int)(object)value);
            } 
            catch {
                return false;
            }
        }

        public static bool Is<T>(this System.Enum type, T value) {
            try {
                return (int)(object)type == (int)(object)value;
            }
            catch {
                return false;
            }    
        }


        public static T Add<T>(this System.Enum type, T value) {
            try {
                return (T)(object)(((int)(object)type | (int)(object)value));
            }
            catch(Exception ex) {
                throw new ArgumentException(
                    string.Format(
                        "Could not append value from enumerated type '{0}'.",
                        typeof(T).Name
                        ), ex);
            }    
        }


        public static T Remove<T>(this System.Enum type, T value) {
            try {
                return (T)(object)(((int)(object)type & ~(int)(object)value));
            }
            catch (Exception ex) {
                throw new ArgumentException(
                    string.Format(
                        "Could not remove value from enumerated type '{0}'.",
                        typeof(T).Name
                        ), ex);
            }  
        }

    }
}

Kemudian mereka digunakan seperti berikut ini

SomeType value = SomeType.Grapes;
bool isGrapes = value.Is(SomeType.Grapes); //true
bool hasGrapes = value.Has(SomeType.Grapes); //true

value = value.Add(SomeType.Oranges);
value = value.Add(SomeType.Apples);
value = value.Remove(SomeType.Grapes);

bool hasOranges = value.Has(SomeType.Oranges); //true
bool isApples = value.Is(SomeType.Apples); //false
bool hasGrapes = value.Has(SomeType.Grapes); //false

Di .NET 4 Anda sekarang dapat menulis:

flags.HasFlag(FlagsEnum.Bit4)

Idiomnya adalah menggunakan operator bitwise atau-sama untuk mengatur bit:

flags |= 0x04;

Untuk menghapus sedikit, idiomnya adalah menggunakan bitwise dan dengan negasi:

flags &= ~0x04;

Kadang-kadang Anda memiliki offset yang mengidentifikasi bit Anda, dan kemudian idiomnya adalah menggunakan ini dikombinasikan dengan shift kiri:

flags |= 1 << offset;
flags &= ~(1 << offset);

@Drew

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.

Sayangnya, operasi flag enum bawaan NET. Cukup terbatas. Sebagian besar waktu pengguna dibiarkan mencari tahu logika operasi bitwise.

Dalam. NET 4, metode HasFlagini ditambahkan ke Enumyang membantu menyederhanakan kode pengguna tetapi sayangnya ada banyak masalah dengannya.

1. HasFlag bukan tipe-aman karena menerima semua jenis argumen nilai enum, bukan hanya tipe enum yang diberikan.
2. HasFlagtidak jelas apakah memeriksa apakah nilai memiliki semua atau salah satu flag yang disediakan oleh argumen nilai enum. Semua itu omong-omong.
3. HasFlag agak lambat karena membutuhkan tinju yang menyebabkan alokasi dan dengan demikian lebih banyak pengumpulan sampah.

Sebagian karena .NET dukungan terbatas untuk flag enums saya menulis perpustakaan OSS Enums.NET yang membahas masing-masing masalah ini dan membuat berurusan dengan flag enums lebih mudah.

Di bawah ini adalah beberapa operasi yang disediakan beserta implementasinya yang setara hanya dengan menggunakan .NET framework.

Gabungkan Bendera

.BERSIH             flags | otherFlags

Enums.NET flags.CombineFlags(otherFlags)

Hapus Bendera

.BERSIH             flags & ~otherFlags

Enums.NET flags.RemoveFlags(otherFlags)

Bendera umum

.BERSIH             flags & otherFlags

Enums.NET flags.CommonFlags(otherFlags)

Toggle Flags

.BERSIH             flags ^ otherFlags

Enums.NET flags.ToggleFlags(otherFlags)

Memiliki Semua Bendera

.NET             (flags & otherFlags) == otherFlags atauflags.HasFlag(otherFlags)

Enums.NET flags.HasAllFlags(otherFlags)

Memiliki Bendera Apa Pun

.BERSIH             (flags & otherFlags) != 0

Enums.NET flags.HasAnyFlags(otherFlags)

Dapatkan Bendera

.BERSIH

Enumerable.Range(0, 64)
  .Where(bit => ((flags.GetTypeCode() == TypeCode.UInt64 ? (long)(ulong)flags : Convert.ToInt64(flags)) & (1L << bit)) != 0)
  .Select(bit => Enum.ToObject(flags.GetType(), 1L << bit))`

Enums.NET flags.GetFlags()

Saya mencoba untuk mendapatkan perbaikan ini dimasukkan ke dalam. NET Core dan mungkin akhirnya .NET Framework. Anda dapat memeriksa proposal saya di sini .

Sintaks C ++, dengan asumsi bit 0 adalah LSB, dengan asumsi flag tidak ditandai:

Periksa apakah Set:

flags & (1UL << (bit to test# - 1))

Periksa apakah tidak disetel:

invert test !(flag & (...))

Set:

flag |= (1UL << (bit to set# - 1))

Bersih:

flag &= ~(1UL << (bit to clear# - 1))

Beralih:

flag ^= (1UL << (bit to set# - 1))

Untuk kinerja terbaik dan nol sampah, gunakan ini:

using System;
using T = MyNamespace.MyFlags;

namespace MyNamespace
{
    [Flags]
    public enum MyFlags
    {
        None = 0,
        Flag1 = 1,
        Flag2 = 2
    }

    static class MyFlagsEx
    {
        public static bool Has(this T type, T value)
        {
            return (type & value) == value;
        }

        public static bool Is(this T type, T value)
        {
            return type == value;
        }

        public static T Add(this T type, T value)
        {
            return type | value;
        }

        public static T Remove(this T type, T value)
        {
            return type & ~value;
        }
    }
}

Untuk menguji sedikit Anda akan melakukan hal berikut: (dengan asumsi bendera adalah angka 32 bit)

Bit Uji:

if((flags & 0x08) == 0x08)

flags = flags ^ 0x08;

flags = flags & 0xFFFFFF7F;

Ini terinspirasi oleh menggunakan Sets sebagai pengindeks di Delphi, jalan kembali ketika:

/// Example of using a Boolean indexed property
/// to manipulate a [Flags] enum:

public class BindingFlagsIndexer
{
  BindingFlags flags = BindingFlags.Default;

  public BindingFlagsIndexer()
  {
  }

  public BindingFlagsIndexer( BindingFlags value )
  {
     this.flags = value;
  }

  public bool this[BindingFlags index]
  {
    get
    {
      return (this.flags & index) == index;
    }
    set( bool value )
    {
      if( value )
        this.flags |= index;
      else
        this.flags &= ~index;
    }
  }

  public BindingFlags Value 
  {
    get
    { 
      return flags;
    } 
    set( BindingFlags value ) 
    {
      this.flags = value;
    }
  }

  public static implicit operator BindingFlags( BindingFlagsIndexer src )
  {
     return src != null ? src.Value : BindingFlags.Default;
  }

  public static implicit operator BindingFlagsIndexer( BindingFlags src )
  {
     return new BindingFlagsIndexer( src );
  }

}

public static class Class1
{
  public static void Example()
  {
    BindingFlagsIndexer myFlags = new BindingFlagsIndexer();

    // Sets the flag(s) passed as the indexer:

    myFlags[BindingFlags.ExactBinding] = true;

    // Indexer can specify multiple flags at once:

    myFlags[BindingFlags.Instance | BindingFlags.Static] = true;

    // Get boolean indicating if specified flag(s) are set:

    bool flatten = myFlags[BindingFlags.FlattenHierarchy];

    // use | to test if multiple flags are set:

    bool isProtected = ! myFlags[BindingFlags.Public | BindingFlags.NonPublic];

  }
}

Operasi C ++ adalah: & | ^ ~ (untuk dan, atau, xor dan bukan operasi bitwise). Yang juga menarik adalah >> dan <<, yang merupakan operasi bitshift.

Jadi, untuk menguji bit yang diatur dalam sebuah flag, Anda akan menggunakan: if (flags & 8) // tes bit 4 telah ditetapkan