Đối với cuộc sống của tôi, tôi không thể nhớ cách thiết lập, xóa, chuyển đổi hoặc kiểm tra một chút trong bitfield. Hoặc là tôi không chắc chắn hoặc tôi trộn chúng lên vì tôi hiếm khi cần những thứ này. Vì vậy, một "bit-cheat-sheet" sẽ rất tốt để có.

Ví dụ:

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

hoặc là

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

Bạn có thể đưa ra ví dụ về tất cả các hoạt động phổ biến khác, tốt nhất là theo cú pháp C # bằng cách sử dụng enum [Cờ] không?

Tôi đã thực hiện thêm một số công việc trên các tiện ích mở rộng này - Bạn có thể tìm thấy mã ở đây

Tôi đã viết một số phương thức mở rộng mở rộng System.Enum mà tôi thường sử dụng ... Tôi không cho rằng chúng có khả năng chống đạn, nhưng chúng đã giúp ... Nhận xét đã bị xóa ...

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

    }
}

Sau đó, chúng được sử dụng như sau

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

Trong .NET 4 bây giờ bạn có thể viết:

flags.HasFlag(FlagsEnum.Bit4)

Thành ngữ là sử dụng toán tử bitwise hoặc bằng để đặt bit:

flags |= 0x04;

Để xóa một chút, thành ngữ là sử dụng bitwise và với phủ định:

flags &= ~0x04;

Đôi khi bạn có một phần bù xác định bit của bạn, và sau đó thành ngữ là sử dụng các giá trị này kết hợp với dịch chuyển trái:

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

@Đã vẽ

Lưu ý rằng ngoại trừ trường hợp đơn giản nhất, Enum.HasFlag mang một hình phạt hiệu năng nặng so với việc viết mã bằng tay. Hãy xem xét các mã sau đây:

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

Hơn 10 triệu lần lặp lại, phương pháp mở rộng HasFlags chiếm 4793 ms, so với 27 ms cho việc thực hiện theo tiêu chuẩn bitwise.

Rất tiếc, các hoạt động cờ enum tích hợp của .NET rất tiếc. Hầu hết thời gian người dùng còn lại với việc tìm ra logic hoạt động bitwise.

Trong .NET 4, phương thức HasFlagđã được thêm vào để Enumgiúp đơn giản hóa mã của người dùng nhưng không may có nhiều vấn đề với nó.

1. HasFlag không an toàn kiểu vì nó chấp nhận bất kỳ loại đối số giá trị enum nào, không chỉ loại enum đã cho.
2. HasFlagkhông rõ ràng về việc nó kiểm tra xem giá trị có tất cả hoặc bất kỳ cờ nào được cung cấp bởi đối số giá trị enum hay không. Nhân tiện đây là tất cả.
3. HasFlag là khá chậm vì nó đòi hỏi quyền anh gây ra sự phân bổ và do đó nhiều bộ sưu tập rác hơn.

Do một phần hỗ trợ hạn chế của .NET cho enum cờ, tôi đã viết thư viện OSS Enums.NET để giải quyết từng vấn đề này và giúp việc xử lý các enum cờ dễ dàng hơn nhiều.

Dưới đây là một số hoạt động mà nó cung cấp cùng với các triển khai tương đương của chúng chỉ sử dụng .NET framework.

Cờ kết hợp

.MẠNG LƯỚI             flags | otherFlags

Enums.NET flags.CombineFlags(otherFlags)

Xóa cờ

.MẠNG LƯỚI             flags & ~otherFlags

Enums.NET flags.RemoveFlags(otherFlags)

Cờ chung

.MẠNG LƯỚI             flags & otherFlags

Enums.NET flags.CommonFlags(otherFlags)

Chuyển đổi cờ

.MẠNG LƯỚI             flags ^ otherFlags

Enums.NET flags.ToggleFlags(otherFlags)

Có tất cả cờ

.NET             (flags & otherFlags) == otherFlags hoặcflags.HasFlag(otherFlags)

Enums.NET flags.HasAllFlags(otherFlags)

Có cờ nào không

.MẠNG LƯỚI             (flags & otherFlags) != 0

Enums.NET flags.HasAnyFlags(otherFlags)

Nhận cờ

.MẠNG LƯỚI

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()

Tôi đang cố gắng để có những cải tiến này được tích hợp vào .NET Core và cuối cùng có thể là .NET Framework đầy đủ. Bạn có thể kiểm tra đề xuất của tôi ở đây .

Cú pháp C ++, giả sử bit 0 là LSB, giả sử các cờ không dấu dài:

Kiểm tra nếu Đặt:

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

Kiểm tra nếu không được đặt:

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

Bộ:

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

Thông thoáng:

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

Chuyển đổi:

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

Để có hiệu suất tốt nhất và không rác, hãy sử dụng:

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

Để kiểm tra một chút, bạn sẽ làm như sau: (giả sử cờ là số 32 bit)

Kiểm tra bit:

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

flags = flags ^ 0x08;

flags = flags & 0xFFFFFF7F;

Điều này được lấy cảm hứng bằng cách sử dụng Bộ làm chỉ mục trong Delphi, quay trở lại khi:

/// 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];

  }
}

Các hoạt động của C ++ là: & | ^ ~ (cho và, hoặc, xor và không hoạt động bitwise). Cũng đáng quan tâm là >> và <<, đó là các hoạt động bithift.

Vì vậy, để kiểm tra một bit được đặt trong cờ, bạn sẽ sử dụng: if (flags & 8) // tests bit 4 đã được đặt