枚举上最常见的C#按位操作

对于我的生活,我不记得如何设置,删除,切换或测试位域中的位.要么我不确定,要么混淆它们,因为我很少需要这些.因此,"比特作弊表"会很好.

例如:

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

要么

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

您能举例说明所有其他常见操作,最好是使用[Flags]枚举的C#语法吗？

1> Hugoware..：

---

我在这些扩展上做了更多的工作 - 你可以在这里找到代码

我写了一些扩展方法,扩展了我经常使用的System.Enum ...我并没有声称它们是防弹的,但是他们帮助了...... 评论被删除了......

namespace Enum.Extensions {

    public static class EnumerationExtensions {

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

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


        public static T Add(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(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

---

这些扩展只是我的一天,我的一周,我的月份,很可能是我的一年.

---

@Drew:请参阅http://code.google.com/p/unconstrained-melody以获取避免装箱的方法:)

2> Drew Noakes..：

---

在.NET 4中,您现在可以编写:

flags.HasFlag(FlagsEnum.Bit4)

---

我知道!但丑陋的名字就像IE6,可能永远不会消失:(

---

@JimSchubert,我再次从原始问题中复制了类型名称,以免混淆问题.[.NET枚举类型命名指南](http://msdn.microsoft.com/en-us/library/4x252001(v = vs.71).aspx)表示所有`[Flags]`枚举应该有多个名称所以"FlagsEnum"这个名字比丑陋更严重.

---

虽然`FlagsEnum`是一个丑陋的名字,但是用于指出它的+1.:)

3> Stephen Deke..：

---

习惯用法是使用按位或等于运算符来设置位:

flags |= 0x04;

要清除一点,成语是按位使用和否定:

flags &= ~0x04;

有时你有一个标识你的位的偏移量,然后成语是使用这些与左移相结合:

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

4> Chuck Dee..：

---

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

超过1000万次迭代,HasFlags扩展方法需要高达4793 ms,而标准按位实现则为27 ms.

---

虽然肯定有趣并且很好​​地指出.您需要考虑使用情况.根据这个,如果你没有表演几十万或更多的操作你可能甚至没有注意到这一点.

---

根据使用情况,可能会出现问题.由于我与装载机工作了很多,我觉得很好指出.

---

'HasFlag`方法涉及装箱/拆箱,这解释了这种差异.但是成本是如此微不足道(0.4μs),除非你处于紧张的循环中,否则我会在任何一天采用更具可读性(并且不太可能错误)的声明性API调用.

5> TylerBrinkle..：

---

不幸的是,.NET的内置标志枚举操作非常有限.大多数时候,用户只能计算出按位运算逻辑.

在.NET 4中,HasFlag添加了Enum该方法有助于简化用户代码,但遗憾的是它存在许多问题.

HasFlag 不是类型安全的,因为它接受任何类型的枚举值参数,而不仅仅是给定的枚举类型.

HasFlag是否检查该值是否具有枚举值参数提供的全部或任何标志是不明确的.顺便说一下.

HasFlag 是相当慢,因为它需要拳击,导致分配,从而更多的垃圾收集.

部分由于.NET对标志枚举的有限支持,我编写了OSS库Enums.NET,它解决了这些问题并使得处理标志枚举变得更加容易.

下面是它提供的一些操作以及仅使用.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.你可以在这里查看我的建议.

6> Petesh..：

---

C++语法,假设第0位是LSB,假设flags是无符号长的:

检查是否设置:

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