我偶尔会看到像以下这样的枚举：
[Flags]
public enum Options
{
None = 0,
Option1 = 1,
Option2 = 2,
Option3 = 4,
Option4 = 8
}
我不理解[Flags]属性到底是做什么的。
有没有人能够提供一个好的解释或示例呢？
14个回答
2503
当可枚举类型表示可能值的集合而不是单个值时，应使用 [Flags] 特性。这种集合通常与位运算符一起使用，例如：
var allowedColors = MyColor.Red | MyColor.Green | MyColor.Blue;
请注意，
[Flags] 属性本身并不使其生效 - 它只允许.ToString()方法显示漂亮的表示形式。enum Suits { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }
[Flags] enum SuitsFlags { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }
...
var str1 = (Suits.Spades | Suits.Diamonds).ToString();
// "5"
var str2 = (SuitsFlags.Spades | SuitsFlags.Diamonds).ToString();
// "Spades, Diamonds"
需要注意的是，[Flags] 并不会 自动将枚举值变成2的幂。如果省略数字值，则枚举在按位运算中无法像人们预期的那样工作，因为默认情况下枚举值从0开始递增。
错误的声明：
[Flags]
public enum MyColors
{
Yellow, // 0
Green, // 1
Red, // 2
Blue // 3
}
如果以这种方式声明值，Yellow将为0，Green将为1，Red将为2，Blue将为3。这将使其作为标志无效。
以下是一个正确声明的示例：
[Flags]
public enum MyColors
{
Yellow = 1,
Green = 2,
Red = 4,
Blue = 8
}
为检索属性中的唯一值，可以采用以下方法：
if (myProperties.AllowedColors.HasFlag(MyColor.Yellow))
{
// Yellow is allowed...
}
或者在 .NET 4 之前：
if((myProperties.AllowedColors & MyColor.Yellow) == MyColor.Yellow)
{
// Yellow is allowed...
}
if((myProperties.AllowedColors & MyColor.Green) == MyColor.Green)
{
// Green is allowed...
}
实现原理
这是因为您在枚举中使用了2的幂。在背后，您的枚举值以二进制的形式表示为0和1：
Yellow: 00000001
Green: 00000010
Red: 00000100
Blue: 00001000
同样的，当你使用二进制位或运算符 | 将属性 AllowedColors 设置为红色、绿色和蓝色之后，AllowedColors 就会变成这个样子:
myProperties.AllowedColors: 00001110
因此，当您检索该值时，实际上是对这些值执行按位与 & 操作：
myProperties.AllowedColors: 00001110
MyColor.Green: 00000010
-----------------------
00000010 // Hey, this is the same as MyColor.Green!
None = 0 值
关于在枚举中使用 0，引用MSDN的说法：
[Flags]
public enum MyColors
{
None = 0,
....
}
将枚举常量值为零的标志枚举变量命名为 None。但您不能在按位与操作中使用 None 枚举常量以测试标志，因为结果总是零。但是，您可以在数字值和 None 枚举常量之间执行逻辑比较（而不是按位比较），以确定数字值中是否设置了任何位。
您可以在msdn和msdn 设计标志中找到有关 flags 属性及其用法的更多信息。
- andynil
14
180Flags 本身并没有实际作用。同时，C# 并不强制要求使用 Flags。但是，你的枚举类型的 ToString 实现、Enum.IsDefined、Enum.Parse 等方法都使用了 Flags。如果尝试去掉 Flags，然后执行 MyColor.Yellow | MyColor.Red 的操作，你得到的结果是 "5"，而加上 Flags 后则会得到 "Yellow, Red"。框架中的其他部分也使用 [Flags]（例如 XML 序列化）。 - Ruben
73我更喜欢使用形如 A = 1 << 0，B = 1 << 1，C = 1 << 2 ... 的常量。 这种方法更易于阅读、理解、进行视觉检查和更改。 - Nick Westgate
2@borrrden，太棒了！我找到了这个：http://msdn.microsoft.com/en-us/library/system.enum.aspx - 看看“Remarks”部分：“Enum是.NET Framework中所有枚举的基类。”和“枚举没有明确继承自Enum; 继承关系由编译器隐式处理。”所以，当你写：public enum bla bla bla - 这是一个值类型。但是，HasFlag方法希望您给他一个System.Enum的实例，它是一个类（引用类型）。 - Aleksei Chepovoi
1Enum.IsDefined不考虑FlagsAttribute。即使使用该属性，以下任何内容都不返回true：Yellow | Green，“Yellow，Green”，3。 - TheXenocide
8如果你想从枚举类型中排除一个标志，可以使用 C# 中的异或运算符“^”。例如，如果你有代码
myProperties.AllowedColors = MyColor.Red | MyColor.Green | MyColor.Blue;，你可以这样做：myProperties.AllowedColors = myProperties.AllowedColors ^ MyColor.Blue //myProperties.AllowedColors == MyColor.Red | Mycolor.Green。注意，这并不会改变原来的含义，只是将想要排除的标志从已有的标志中剔除掉。 - Josh Noe显示剩余9条评论
885
你也可以这样做
[Flags]
public enum MyEnum
{
None = 0,
First = 1 << 0,
Second = 1 << 1,
Third = 1 << 2,
Fourth = 1 << 3
}
我发现位移比输入 4、8、16、32 等更容易。它不会影响你的代码，因为这一切都是在编译时完成的。
- Orion Edwards
7
9“it's all done at compile time”这种评论可能对某些人来说很有趣，但我觉得它让人感到沮丧，因为它暗示在运行时进行20次位移操作会对性能产生任何可测量的影响。CPU非常擅长位移操作，枚举不会具有任意数量的成员，并且这种方法最多只适用于32或64个元素。作为性能问题，这不重要。 - jwg
20@JeremyWeir - 将会在标志枚举值中设置几个位。因此，您的数据分析方法是不正确的。请运行一个程序，以二进制表示您的整数值。
131,072 [十进制] = 0000 0000 0000 0001 0000 0000 0000 0000 [二进制] [32] ..将第17位设为1时，分配1<<17的枚举值很容易确定。0110 0011 0011 0101 0101 0011 0101 1011 [二进制] [32] .. 等等，枚举值分配1<<31，1<<30，1<<26，1<<25..等等都可以轻松确定，即使没有计算器的帮助，而我怀疑您没有二进制表示能力。 - Brett Caswell
17还要指出的是，你可以从“先前”的枚举值进行位移，而不是直接从数字进行位移，例如
Third = Second << 1 而不是 Third = 1 << 2 -- 可以参见下方的更完整的描述。 - drzaus37我喜欢这个，但是一旦到达底层枚举类型的上限，编译器就不会对比特位移发出警告，例如
1 << 31 == -2147483648, 1 << 32 == 1, 1 << 33 == 2 等。相比之下，如果你在 int 类型的枚举中声明 ThirtySecond = 2147483648，编译器会报错。 - aaaantoine13在C# 7中另一个新增的选项是，你可以使用
0b1、0b10等（或者如果你喜欢对齐的话，可以使用0b00000001）。 - Graham Wager显示剩余2条评论
140
结合答案https://dev59.com/i3VD5IYBdhLWcg3wWKPc#8462（通过位移进行声明）和https://dev59.com/i3VD5IYBdhLWcg3wWKPc#9117（在声明中使用组合），您可以对先前的值进行位移而不是使用数字。不一定推荐这样做，但只是指出您可以这样做。
而不是：
[Flags]
public enum Options : byte
{
None = 0,
One = 1 << 0, // 1
Two = 1 << 1, // 2
Three = 1 << 2, // 4
Four = 1 << 3, // 8
// combinations
OneAndTwo = One | Two,
OneTwoAndThree = One | Two | Three,
}
你可以声明
[Flags]
public enum Options : byte
{
None = 0,
One = 1 << 0, // 1
// now that value 1 is available, start shifting from there
Two = One << 1, // 2
Three = Two << 1, // 4
Four = Three << 1, // 8
// same combinations
OneAndTwo = One | Two,
OneTwoAndThree = One | Two | Three,
}
使用 LinqPad 进行确认：
foreach(var e in Enum.GetValues(typeof(Options))) {
string.Format("{0} = {1}", e.ToString(), (byte)e).Dump();
}
结果：
None = 0
One = 1
Two = 2
OneAndTwo = 3
Three = 4
OneTwoAndThree = 7
Four = 8
- drzaus
2
32这些组合是很好的建议，但我认为串联位移可能容易出现复制粘贴错误，例如 Two = One << 1，Three = One << 1 等等...以形如 1 << n 的递增整数更安全，意图更清晰。 - Rupert Rawnsley
2@RupertRawnsley 引用我的回答：> 不一定推荐，只是指出你可以这样做。 - drzaus
63
除了已被接受的答案之外，C#7还可以使用二进制字面值编写枚举标志：
[Flags]
public enum MyColors
{
None = 0b0000,
Yellow = 0b0001,
Green = 0b0010,
Red = 0b0100,
Blue = 0b1000
}
我认为这种表示清楚地说明了标志是如何在底层工作的。
- Thorkil Holm-Jacobsen
1
54
请参考以下示例，其中展示了声明和潜在用法：
namespace Flags
{
class Program
{
[Flags]
public enum MyFlags : short
{
Foo = 0x1,
Bar = 0x2,
Baz = 0x4
}
static void Main(string[] args)
{
MyFlags fooBar = MyFlags.Foo | MyFlags.Bar;
if ((fooBar & MyFlags.Foo) == MyFlags.Foo)
{
Console.WriteLine("Item has Foo flag set");
}
}
}
}
- OJ.
1
7即使省略 [Flags]，这个例子也能运行。我想了解的是 [Flags] 的作用。 - gbarry
45
在处理标志时，我经常声明额外的None和All项目。这些有助于检查是否所有标志都已设置或没有标志被设置。
[Flags]
enum SuitsFlags {
None = 0,
Spades = 1 << 0,
Clubs = 1 << 1,
Diamonds = 1 << 2,
Hearts = 1 << 3,
All = ~(~0 << 4)
}
用法：
Spades | Clubs | Diamonds | Hearts == All // true
Spades & Clubs == None // true
更新于2019年10月:
从C# 7.0开始，您可以使用二进制字面量，这可能更符合直觉：
[Flags]
enum SuitsFlags {
None = 0b0000,
Spades = 0b0001,
Clubs = 0b0010,
Diamonds = 0b0100,
Hearts = 0b1000,
All = 0b1111
}
- Jpsy
1
1是的，结合这个页面上的所有答案，我现在定期使用这个答案，但是带有前导分隔符
0b_1111。 - Marcelo Scofano Diniz45
最近，我提出了一个类似的问题。
如果你使用标志位，你可以为枚举类型添加扩展方法来更轻松地检查它包含哪些标志（详见文章）
这样，你就可以做到：
[Flags]
public enum PossibleOptions : byte
{
None = 0,
OptionOne = 1,
OptionTwo = 2,
OptionThree = 4,
OptionFour = 8,
//combinations can be in the enum too
OptionOneAndTwo = OptionOne | OptionTwo,
OptionOneTwoAndThree = OptionOne | OptionTwo | OptionThree,
...
}
然后你可以这样做：
PossibleOptions opt = PossibleOptions.OptionOneTwoAndThree
if( opt.IsSet( PossibleOptions.OptionOne ) ) {
//optionOne is one of those set
}
我觉得这种检查包含标志的方式比大多数其他方法更容易阅读。
- Keith
5
IsSet是一个扩展方法，我猜是吗？ - Robert MacLean
是的 - 有关详细信息，请阅读我链接的其他问题：https://dev59.com/IHVD5IYBdhLWcg3wWaRh - Keith
73.NET 4版本添加了“HasFlag”方法用于枚举，这样您就可以使用“opt.HasFlag(PossibleOptions.OptionOne)”而无需编写自己的扩展方法。 - Orion Edwards
1请注意，与执行位运算相比，
HasFlag速度要慢得多。 - Wai Ha Lee1@WaiHaLee 您可以使用 CodeJam.EnumHelper.IsFlagSet 扩展方法，该方法使用 Expression 编译为快速版本：https://github.com/rsdn/CodeJam/wiki/M_CodeJam_EnumHelper_IsFlagSet__1 - NN_
26
要将另一个标志添加到现有值集，请使用OR分配运算符。
Mode = Mode.Read;
//Add Mode.Write
Mode |= Mode.Write;
Assert.True(((Mode & Mode.Write) == Mode.Write)
&& ((Mode & Mode.Read) == Mode.Read)));
- scalvert
19
添加Mode.Write：
Mode = Mode | Mode.Write;
- David Wengier
1
或者，为了更短的语法：
Mode |= Mode.Write; - Scover16
对于if ((x & y) == y)...这个结构，我觉得有点过于冗长，特别是当x和y都是由一系列标志位组成的复合集合时，而你只想知道是否存在任何重叠。
在这种情况下，你真正需要知道的是，在对位掩码进行比较之后是否存在非零值[1]。
[1] 参见Jaime的评论。如果我们真正执行位掩码操作，那么我们只需要检查结果是否为正。但由于
enum可能是负数，即使与[Flags]属性结合使用时，也很奇怪，代码上采用!= 0而不是> 0是一种防御性措施。
在@andnil的设置基础上构建...
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BitFlagPlay
{
class Program
{
[Flags]
public enum MyColor
{
Yellow = 0x01,
Green = 0x02,
Red = 0x04,
Blue = 0x08
}
static void Main(string[] args)
{
var myColor = MyColor.Yellow | MyColor.Blue;
var acceptableColors = MyColor.Yellow | MyColor.Red;
Console.WriteLine((myColor & MyColor.Blue) != 0); // True
Console.WriteLine((myColor & MyColor.Red) != 0); // False
Console.WriteLine((myColor & acceptableColors) != 0); // True
// ... though only Yellow is shared.
Console.WriteLine((myColor & MyColor.Green) != 0); // Wait a minute... ;^D
Console.Read();
}
}
}
- ruffin
2
枚举可能基于有符号类型，因此您应该使用“！= 0”而不是“> 0”。 - raven
@JaimePardos -- 只要我们保持字节的正确性，就像我在这个例子中所做的那样，就没有负数的概念。只有0到255。正如MSDN警告，“如果您将负数定义为标志枚举常量，请小心，因为...[那]可能会使您的代码混乱并鼓励编码错误。”想象“负位标志”是很奇怪的！;^) 我稍后会进行更多编辑。但是你是对的，如果我们在
enum中使用负值，我们需要检查!= 0。 - ruffin网页内容由stack overflow 提供, 点击上面的可以查看英文原文，
原文链接
原文链接
CatAndDog = Cat | Dog（逻辑上的“或”而不是条件运算符），我猜对吗？ - DdW