在。net 4中，你现在可以这样写:

flags.HasFlag(FlagsEnum.Bit4)

为了测试一点，你可以做以下事情: (假设flags是一个32位的数字)

测试点: if((flags & 0x08) == 0x08)(如果第4位设置为真) 切换回(1 - 0或0 - 1):flags = flags ^ 0x08; 重置位4到零:flags = flags & 0xFFFFFF7F;

. net的内置标志枚举操作非常有限。大多数情况下，用户需要弄清楚按位操作的逻辑。

在。net 4中，HasFlag方法被添加到Enum中，这有助于简化用户的代码，但不幸的是，它存在许多问题。

HasFlag不是类型安全的，因为它接受任何类型的枚举值参数，而不仅仅是给定的枚举类型。 HasFlag对于是否检查值是否具有enum value参数提供的所有或任何标志具有歧义性。顺便说一下。 HasFlag相当慢，因为它需要装箱，这会导致分配和更多的垃圾收集。

由于. net对标志枚举的支持有限，我编写了OSS库enums。NET解决了这些问题，使处理标志枚举更加容易。

下面是它提供的一些操作以及仅使用. net框架的等效实现。

把国旗

.NET标志| otherFlags

Enums.NET 标志。CombineFlags（otherFlags）

---

删除标志

.NET标志& ~otherFlags

Enums.NET 标志。删除标志（其他标志）

---

常见的旗帜

.NET标志和其他标志

Enums.NET 标志。CommonFlags（otherFlags）

---

切换的旗帜

.NET flags ^ otherFlags

Enums.NET 标志。切换标志（其他标志）

---

拥有所有旗帜

.NET (flags & otherFlags) == otherFlags或flags. hasflag (otherFlags)

Enums.NET 标志。HasAllFlags（otherFlags）

---

是否有旗帜

.NET (flags & otherFlags) != 0

Enums.NET 标志。HasAnyFlags（otherFlags）

---

让国旗

.NET

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 标志。GetFlags（）

---

我正试图将这些改进整合到。net Core中，并最终整合到完整的。net框架中。你可以在这里查看我的提案。

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

我写了一些扩展方法来扩展System。枚举，我经常使用…我并不是说它们是无懈可击的，但它们确实有所帮助……删除注释……

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

c++操作为:& | ^ ~(用于和，或，xor，而不是位操作)。还有>>和<<，它们是位移位操作。

因此，要测试是否在标志中设置了位，你可以使用: 如果(flags & 8) //测试位4已设置

c++语法，假设第0位是LSB，假设flags是unsigned long:

检查是否设置:

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

检查是否未设置:

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

Set:

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

明确:

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

切换:

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