สำหรับชีวิตของฉันฉันจำไม่ได้ว่าจะตั้งลบสลับหรือทดสอบบิตในบิตฟิลด์ ฉันไม่แน่ใจหรือผสมกันเพราะฉันไม่ค่อยต้องการสิ่งเหล่านี้ ดังนั้น "บิตโกงแผ่น" น่าจะมี

ตัวอย่างเช่น:

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

หรือ

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

คุณสามารถยกตัวอย่างการดำเนินงานทั่วไปอื่น ๆ ทั้งหมดโดยเฉพาะอย่างยิ่งในไวยากรณ์ C # โดยใช้ [Flags] enum หรือไม่

ฉันทำงานส่วนขยายเหล่านี้เพิ่มเติม - คุณสามารถค้นหารหัสได้ที่นี่

ฉันเขียนวิธีการขยายบางอย่างที่ขยาย System.Enum ที่ฉันใช้บ่อย ... ฉันไม่ได้อ้างว่ามันเป็นกระสุน แต่พวกเขาช่วย ... ความคิดเห็นลบ ...

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

    }
}

จากนั้นพวกเขาจะใช้ดังต่อไปนี้

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

ใน. NET 4 ตอนนี้คุณสามารถเขียน:

flags.HasFlag(FlagsEnum.Bit4)

สำนวนคือการใช้ตัวดำเนินการ bitwise หรือเท่ากันเพื่อตั้งบิต:

flags |= 0x04;

เพื่อล้างบิต, สำนวนคือการใช้บิตและด้วยการปฏิเสธ:

flags &= ~0x04;

บางครั้งคุณมีออฟเซ็ตที่ระบุบิตของคุณแล้วสำนวนคือการใช้สิ่งเหล่านี้รวมกับการเปลี่ยนแปลงซ้าย:

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

@Drew

โปรดทราบว่ายกเว้นในกรณีที่ง่ายที่สุด Enum.HasFlag มีบทลงโทษที่หนักหน่วงเมื่อเปรียบเทียบกับการเขียนโค้ดด้วยตนเอง พิจารณารหัสต่อไปนี้:

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

การทำซ้ำกว่า 10 ล้านครั้งวิธีการขยาย HasFlags ใช้เวลาถึง 4793 มิลลิวินาทีเมื่อเทียบกับ 27 มิลลิวินาทีสำหรับการใช้งานระดับบิตมาตรฐาน

การดำเนินการ enum ค่าสถานะของ. NET นั้นค่อนข้าง จำกัด เวลาส่วนใหญ่ที่ผู้ใช้เหลืออยู่ด้วยการหาตรรกะการดำเนินการระดับบิต

ใน. NET 4 วิธีการที่HasFlagเพิ่มเข้ามาEnumซึ่งช่วยให้รหัสของผู้ใช้ง่ายขึ้น แต่น่าเสียดายที่มีปัญหามากมายกับมัน

1. HasFlag ไม่ปลอดภัยสำหรับประเภทเพราะยอมรับข้อโต้แย้งค่า enum ทุกประเภทไม่ใช่เฉพาะประเภท enum ที่กำหนด
2. HasFlagคลุมเครือว่าจะตรวจสอบหรือไม่ว่าค่านั้นมีค่าสถานะทั้งหมดหรือใด ๆ ที่ระบุโดยอาร์กิวเมนต์ค่า enum มันคือทั้งหมดที่โดยวิธีการ
3. HasFlag ค่อนข้างช้าเนื่องจากต้องใช้มวยซึ่งเป็นสาเหตุของการจัดสรรและทำให้มีการรวบรวมขยะมากขึ้น

เนื่องจากส่วนหนึ่งของ. NET ที่สนับสนุนอย่าง จำกัด สำหรับการกำหนดค่าสถานะฉันเขียนไลบรารี OSS Enums.NETซึ่งจัดการปัญหาเหล่านี้แต่ละรายการและทำให้การจัดการกับค่าสถานะ enums ง่ายขึ้นมาก

ด้านล่างนี้คือการดำเนินการบางอย่างที่มีให้พร้อมกับการใช้งานที่เทียบเท่าโดยใช้เพียงกรอบงาน. NET

รวมธง

.สุทธิ             flags | otherFlags

Enums.NET flags.CombineFlags(otherFlags)

ลบค่าสถานะ

.สุทธิ             flags & ~otherFlags

Enums.NET flags.RemoveFlags(otherFlags)

ธงทั่วไป

.สุทธิ             flags & otherFlags

Enums.NET flags.CommonFlags(otherFlags)

สลับค่าสถานะ

.สุทธิ             flags ^ otherFlags

Enums.NET flags.ToggleFlags(otherFlags)

มีธงทั้งหมด

. NET             (flags & otherFlags) == otherFlagsหรือflags.HasFlag(otherFlags)

Enums.NET flags.HasAllFlags(otherFlags)

มีธง

.สุทธิ             (flags & otherFlags) != 0

Enums.NET flags.HasAnyFlags(otherFlags)

รับค่าสถานะ

.สุทธิ

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

ฉันพยายามรับการปรับปรุงเหล่านี้รวมอยู่ใน. NET Core และอาจเป็น. NET Framework แบบเต็ม คุณสามารถตรวจสอบข้อเสนอของฉันที่นี่

ไวยากรณ์ C ++ สมมติว่าบิต 0 คือ LSB สมมติว่าแฟล็กไม่ได้ลงนามนาน:

ตรวจสอบว่าตั้ง:

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

ตรวจสอบว่าไม่ได้ตั้งค่า:

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

ตั้ง:

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

ชัดเจน:

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

สลับ:

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

เพื่อประสิทธิภาพที่ดีที่สุดและไม่มีขยะให้ใช้สิ่งนี้:

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

ในการทดสอบบิตคุณต้องทำดังนี้: (สมมติว่าค่าสถานะเป็นตัวเลข 32 บิต)

ทดสอบบิต:

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

flags = flags ^ 0x08;

flags = flags & 0xFFFFFF7F;

สิ่งนี้ได้รับแรงบันดาลใจจากการใช้ Sets as indexers ใน Delphi ย้อนกลับไปเมื่อ:

/// 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 ++ คือ: & | ^ ~ (สำหรับและ, หรือ, xor และไม่ใช่การทำงานระดับบิต) สิ่งที่น่าสนใจก็คือ >> และ << ซึ่งเป็นการดำเนินการบิตบิท

ดังนั้นในการทดสอบการตั้งค่าบิตในแฟล็กคุณควรใช้: ถ้า (ค่าสถานะ & 8) // การทดสอบบิตที่ 4 ได้รับการตั้งค่า