3

我有一个这样定义的枚举：

[Flags]
public enum Orientation
{
    North = 1,
    North_East = 2,
    East = 4,
    South_East = 8,
    South = 16,
    South_West = 32,
    West = 64,
    North_West = 128
}

有没有一种通用的方法来判断是否设置了一个标志，多个或没有？我不在乎枚举的值是多少，我只想知道设置了多少个标志。

这不是用于计算位数的重复项。如果我像这样初始化枚举并计算位数，我得到 10。但设置标志的数量为 8。

GeographicOrientation go = (GeographicOrientation) 1023;
4

6 回答 6

5

将值转换为 后，您可以通过一个简单的技巧来确定这一点int：

int v = (int)枚举值；

  1. 如果v == 0，则不设置任何标志
  2. 否则，如果((v-1)&v) == 0，则恰好设置一个标志
  3. 否则，设置多个标志。

唯一棘手的是#2。这是一个解释：考虑一个二进制数，其中一位设置为1。然后减去1将进行以下更改：

  0000010000000
-             1
  -------------
  0000001111111

后面的所有零都1变成1s，1变成零，其余位保持不变。AND-ingv并v-1产生零，因为在两个数字之间的同一位置没有一对1s。

当有两个或多个1s 时，单独的左边的位1将保持不变。1因此，在bitwise 的结果中至少有一个位置会有 a AND。

于 2016-06-13T17:32:43.450 回答
4

您可以使用此代码：

var item = Orientation.North | Orientation.South;
int i = 0;
foreach (Orientation e in Enum.GetValues(typeof(Orientation)))
    if(item.HasFlag(e))
        i++;

Console.WriteLine(i);
于 2016-06-13T17:23:14.690 回答
3 
var test = Orientation.North;
var flagCount = GetFlagCount(test);

public int GetFlagCount(Enum testValue)
{
    return Enum.GetValues(testValue.GetType()).Cast<Enum>().Count(testValue.HasFlag);
}
于 2016-06-13T17:30:12.680 回答
2

如果您正在寻找“最短”的方式：

Orientation o = Orientation.East | Orientation.West;   // o.ToString() = "East, West"
var c = o.ToString().Split().Count();

甚至更短：

var c = (o + "").Split().Count();

更新

要支持高于 255 的值，您可以使用任何这些丑陋的技巧：

Orientation o = (Orientation) 1023;   
var c = ((Orientation)(byte)o + "").Split().Count();
c = ((Orientation)((int)o & 255) + "").Split().Count();

或者只是将枚举定义为字节：

    [Flags]
    public enum Orientation : byte
    {
        North = 1,
        North_East = 2,
        East = 4,
        South_East = 8,
        South = 16,
        South_West = 32,
        West = 64,
        North_West = 128
    }

更新 2 我个人不会在生产代码中使用字符串方法，尤其是在只需要位计数时。

无论如何，我只是为了好玩而想到了另一个黑客。当设置一位时，Base 2 log 将返回一个整数，当设置为 0 时返回 -Infinity，当设置多于一位时返回任何其他值。例如

 Math.Log(0, 2 ) // -Infinity
 Math.Log(0, 64) // 6.0
 Math.Log(0, 65) // 6.0223678130284544

因此，(byte)go != 0可用于检查是否设置了任何标志，然后Math.Log((byte)go, 2) % 1 == 0检查是否仅设置了一个标志。

但是，dasblinkenlight 的解决方案似乎是最好的。

于 2016-06-13T17:51:52.840 回答
1

在我的头顶上：

var map = 1;
var count = 0;

while (map <= North_West)
{
    if( ((int)Value & map) > 0) 
       count += 1; 
    map = map << 1; //left shift, a.k.a. multiply by 2
}
于 2016-06-13T17:25:43.677 回答
0

这不是用于计算位数的重复项。如果我像这样初始化枚举并计算位数，我得到 10。但设置标志的数量为 8。

请直接从 MSDN考虑此声明：

标志枚举用于屏蔽位域和进行按位比较。

如果您以某种不允许使用按位运算计算标志数量的方式设计或使用枚举，那么您正在设计或使用不正确的枚举。

    [Flags]
    public enum MyEnum
    {
        Foo = 1,
        Bar = 2,
        Bizz = 4,
        Buzz = 8,
        Boo = 16
    }


var foo = MyEnum.Foo | MyEnum.Foo | MyEnum.Bizz;
// foo == MyEnum.Foo | MyEnum.Bizz because setting the same flag twice does nothing

var bar = (MyEnum)27 // Some invalid combination
// bar == 27.  Why would you do this instead of MyEnum.Boo | MyEnum.Buzz | MyEnum.Bar | MyEnum.Foo

如果您正确设计枚举，则可以计算标志，如果设置了多个标志，则可以选择短路，因为继续计数将毫无意义。

        var foo = MyEnum.Foo | MyEnum.Bizz;
        int fooValue = (int)foo;
        int numberOfFlags = 0;

        while (fooValue > 0 && numberOfFlags < 2) // Stop counting if more than one flag since we don't need exact count
        {
            if ((fooValue & 1) == 1)
            {
                numberOfFlags++;
            }

            fooValue >>= 1;
        }

        Console.WriteLine(numberOfFlags);
于 2016-06-13T18:00:54.427 回答