c# - 如何迭代具有标志的枚举的值？

Question

如果我有一个包含标志枚举的变量，我可以以某种方式迭代该特定变量中的单位值吗？还是我必须使用 Enum.GetValues 来遍历整个枚举并检查设置了哪些？

score 196 · Accepted Answer

static IEnumerable<Enum> GetFlags(Enum input)
{
    foreach (Enum value in Enum.GetValues(input.GetType()))
        if (input.HasFlag(value))
            yield return value;
}

score 62 · Accepted Answer

这是该问题的Linq解决方案。

public static IEnumerable<Enum> GetFlags(this Enum e)
{
      return Enum.GetValues(e.GetType()).Cast<Enum>().Where(e.HasFlag);
}

score 41 · Accepted Answer

据我所知，没有任何内置方法可以获取每个组件。但这是获得它们的一种方法：

[Flags]
enum Items
{
    None = 0x0,
    Foo  = 0x1,
    Bar  = 0x2,
    Baz  = 0x4,
    Boo  = 0x6,
}

var value = Items.Foo | Items.Bar;
var values = value.ToString()
                  .Split(new[] { ", " }, StringSplitOptions.None)
                  .Select(v => (Items)Enum.Parse(typeof(Items), v));

// This method will always end up with the most applicable values
value = Items.Bar | Items.Baz;
values = value.ToString()
              .Split(new[] { ", " }, StringSplitOptions.None)
              .Select(v => (Items)Enum.Parse(typeof(Items), v)); // Boo

我调整了Enum内部生成的字符串，而不是返回标志。您可以查看反射器中的代码，应该或多或少等效。适用于包含多个位的值的一般用例。

static class EnumExtensions
{
    public static IEnumerable<Enum> GetFlags(this Enum value)
    {
        return GetFlags(value, Enum.GetValues(value.GetType()).Cast<Enum>().ToArray());
    }

    public static IEnumerable<Enum> GetIndividualFlags(this Enum value)
    {
        return GetFlags(value, GetFlagValues(value.GetType()).ToArray());
    }

    private static IEnumerable<Enum> GetFlags(Enum value, Enum[] values)
    {
        ulong bits = Convert.ToUInt64(value);
        List<Enum> results = new List<Enum>();
        for (int i = values.Length - 1; i >= 0; i--)
        {
            ulong mask = Convert.ToUInt64(values[i]);
            if (i == 0 && mask == 0L)
                break;
            if ((bits & mask) == mask)
            {
                results.Add(values[i]);
                bits -= mask;
            }
        }
        if (bits != 0L)
            return Enumerable.Empty<Enum>();
        if (Convert.ToUInt64(value) != 0L)
            return results.Reverse<Enum>();
        if (bits == Convert.ToUInt64(value) && values.Length > 0 && Convert.ToUInt64(values[0]) == 0L)
            return values.Take(1);
        return Enumerable.Empty<Enum>();
    }

    private static IEnumerable<Enum> GetFlagValues(Type enumType)
    {
        ulong flag = 0x1;
        foreach (var value in Enum.GetValues(enumType).Cast<Enum>())
        {
            ulong bits = Convert.ToUInt64(value);
            if (bits == 0L)
                //yield return value;
                continue; // skip the zero value
            while (flag < bits) flag <<= 1;
            if (flag == bits)
                yield return value;
        }
    }
}

扩展方法GetIndividualFlags()获取一个类型的所有单独的标志。因此，包含多个位的值被忽略了。

var value = Items.Bar | Items.Baz;
value.GetFlags();           // Boo
value.GetIndividualFlags(); // Bar, Baz

score 29 · Accepted Answer

几年后回来，有了更多的经验，我对单个位值的最终答案，从最低位到最高位，是 Jeff Mercado 内部例程的一个轻微变体：

public static IEnumerable<Enum> GetUniqueFlags(this Enum flags)
{
    ulong flag = 1;
    foreach (var value in Enum.GetValues(flags.GetType()).Cast<Enum>())
    {
        ulong bits = Convert.ToUInt64(value);
        while (flag < bits)
        {
            flag <<= 1;
        }

        if (flag == bits && flags.HasFlag(value))
        {
            yield return value;
        }
    }
}

它似乎有效，尽管我几年前反对，但我在这里使用 HasFlag，因为它比使用按位比较更易读，而且速度差异对于我将要做的任何事情都无关紧要。（从那以后他们完全有可能提高了 HasFlags 的速度，据我所知......我还没有测试过。）

score 18 · Accepted Answer

脱离@Greg 的方法，但从 C# 7.3 添加一个新功能，即Enum约束：

public static IEnumerable<T> GetUniqueFlags<T>(this T flags)
    where T : Enum    // New constraint for C# 7.3
{
    foreach (Enum value in Enum.GetValues(flags.GetType()))
        if (flags.HasFlag(value))
            yield return (T)value;
}

新的约束允许 this 成为扩展方法，而不必强制转换(int)(object)e，我可以使用该HasFlag方法并直接转换为Tfrom value。

C# 7.3 还为委托和unmanaged.

score 14 · Accepted Answer

+1 @RobinHood70 提供的答案。我发现该方法的通用版本对我来说很方便。

public static IEnumerable<T> GetUniqueFlags<T>(this Enum flags)
{
    if (!typeof(T).IsEnum)
        throw new ArgumentException("The generic type parameter must be an Enum.");

    if (flags.GetType() != typeof(T))
        throw new ArgumentException("The generic type parameter does not match the target type.");

    ulong flag = 1;
    foreach (var value in Enum.GetValues(flags.GetType()).Cast<T>())
    {
        ulong bits = Convert.ToUInt64(value);
        while (flag < bits)
        {
            flag <<= 1;
        }

        if (flag == bits && flags.HasFlag(value as Enum))
        {
            yield return value;
        }
    }
}

编辑并为@AustinWBryan +1 将 C# 7.3 带入解决方案空间。

public static IEnumerable<T> GetUniqueFlags<T>(this T flags) where T : Enum
{
    ulong flag = 1;
    foreach (var value in Enum.GetValues(flags.GetType()).Cast<T>())
    {
        ulong bits = Convert.ToUInt64(value);
        while (flag < bits)
        {
            flag <<= 1;
        }

        if (flag == bits && flags.HasFlag(value as Enum))
        {
            yield return value;
        }
    }
}

score 3 · Accepted Answer

我所做的是改变我的方法，而不是将方法的输入参数键入为enum类型，而是将其键入为enum类型 ( MyEnum[] myEnums) 的数组，这样我只需在循环中使用 switch 语句遍历数组。

score 3 · Accepted Answer

使用新的 Enum 约束和泛型来防止强制转换的扩展方法：

public static class EnumExtensions
{
    public static T[] GetFlags<T>(this T flagsEnumValue) where T : Enum
    {
        return Enum
            .GetValues(typeof(T))
            .Cast<T>()
            .Where(e => flagsEnumValue.HasFlag(e))
            .ToArray();
    }
}

score 3 · Accepted Answer

继续努力使代码更短，这是我最新版本的例程。（我是 OP……长篇大论。）如前所述，这忽略了 None 和多位值。

请注意，这使用 Enum 约束和 var 模式，因此至少需要 C# 7.3。

public static IEnumerable<T> GetUniqueFlags<T>(this T value)
    where T : Enum
{
    var valueLong = Convert.ToUInt64(value, CultureInfo.InvariantCulture);
    foreach (var enumValue in value.GetType().GetEnumValues())
    {
        if (
            enumValue is T flag // cast enumValue to T
            && Convert.ToUInt64(flag, CultureInfo.InvariantCulture) is var bitValue // convert flag to ulong
            && (bitValue & (bitValue - 1)) == 0 // is this a single-bit value?
            && (valueLong & bitValue) != 0 // is the bit set?
           )
        {
            yield return flag;
        }
    }
}

score 2 · Accepted Answer

您不需要迭代所有值。只需检查您的特定标志，如下所示：

if((myVar & FlagsEnum.Flag1) == FlagsEnum.Flag1) 
{
   //do something...
}

或者（正如pstrjds在评论中所说）您可以检查是否使用它，例如：

if(myVar.HasFlag(FlagsEnum.Flag1))
{
   //do something...
}

score 2 · Accepted Answer

对上面的答案不满意，尽管它们是开始。

在此处拼凑一些不同的来源后：
此线程的 SO QnA
代码项目 Enum Flags Check Post
Great Enum<T> Utility中的前一张海报

我创造了这个，所以让我知道你的想法。
参数：
bool checkZero: 告诉它允许0作为标志值。默认情况下input = 0返回空。
bool checkFlags: 告诉它检查是否用属性Enum装饰。 PS。我现在没有时间弄清楚将迫使它忽略任何作为位组合的枚举值的算法。[Flags]
checkCombinators = false

    public static IEnumerable<TEnum> GetFlags<TEnum>(this TEnum input, bool checkZero = false, bool checkFlags = true, bool checkCombinators = true)
    {
        Type enumType = typeof(TEnum);
        if (!enumType.IsEnum)
            yield break;

        ulong setBits = Convert.ToUInt64(input);
        // if no flags are set, return empty
        if (!checkZero && (0 == setBits))
            yield break;

        // if it's not a flag enum, return empty
        if (checkFlags && !input.GetType().IsDefined(typeof(FlagsAttribute), false))
            yield break;

        if (checkCombinators)
        {
            // check each enum value mask if it is in input bits
            foreach (TEnum value in Enum<TEnum>.GetValues())
            {
                ulong valMask = Convert.ToUInt64(value);

                if ((setBits & valMask) == valMask)
                    yield return value;
            }
        }
        else
        {
            // check each enum value mask if it is in input bits
            foreach (TEnum value in Enum <TEnum>.GetValues())
            {
                ulong valMask = Convert.ToUInt64(value);

                if ((setBits & valMask) == valMask)
                    yield return value;
            }
        }

    }

这利用了我在此处更新的 Helper Class Enum<T>yield return用于GetValues：

public static class Enum<TEnum>
{
    public static TEnum Parse(string value)
    {
        return (TEnum)Enum.Parse(typeof(TEnum), value);
    }

    public static IEnumerable<TEnum> GetValues()   
    {
        foreach (object value in Enum.GetValues(typeof(TEnum)))
            yield return ((TEnum)value);
    }
}

最后，这是一个使用它的例子：

    private List<CountType> GetCountTypes(CountType countTypes)
    {
        List<CountType> cts = new List<CountType>();

        foreach (var ct in countTypes.GetFlags())
            cts.Add(ct);

        return cts;
    }

score 2 · Accepted Answer

基于上面 Greg 的回答，这也处理了枚举中值为 0 的情况，例如 None = 0。在这种情况下，它不应该迭代该值。

public static IEnumerable<Enum> ToEnumerable(this Enum input)
{
    foreach (Enum value in Enum.GetValues(input.GetType()))
        if (input.HasFlag(value) && Convert.ToInt64(value) != 0)
            yield return value;
}

有谁知道如何进一步改进这一点，以便它可以处理枚举中的所有标志都以超级智能方式设置的情况，该方式可以处理所有底层枚举类型以及 All = ~0 和 All = EnumValue1 | 的情况枚举值2 | 枚举值3 | ...

score 1 · Accepted Answer

您可以使用枚举中的迭代器。从 MSDN 代码开始：

public class DaysOfTheWeek : System.Collections.IEnumerable
{
    int[] dayflag = { 1, 2, 4, 8, 16, 32, 64 };
    string[] days = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
    public string value { get; set; }

    public System.Collections.IEnumerator GetEnumerator()
    {
        for (int i = 0; i < days.Length; i++)
        {
            if value >> i & 1 == dayflag[i] {
                yield return days[i];
            }
        }
    }
}

它没有经过测试，所以如果我犯了错误，请随时叫我出来。（显然它不是可重入的。）您必须事先分配值，或者将其分解为另一个使用 enum.dayflag 和 enum.days 的函数。你也许可以带着大纲去某个地方。

score 1 · Accepted Answer

这是另一个使用 Linq 的 C# 7.3 解决方案

public static class FlagEnumExtensions
{
    public static IEnumerable<T> GetFlags<T>(this T en) where T : struct, Enum
    {
        return Enum.GetValues<T>().Where(member => en.HasFlag(member));
    }
}

score 0 · Accepted Answer

它也可以是以下代码：

public static string GetEnumString(MyEnum inEnumValue)
{
    StringBuilder sb = new StringBuilder();

    foreach (MyEnum e in Enum.GetValues(typeof(MyEnum )))
    {
        if ((e & inEnumValue) != 0)
        {
           sb.Append(e.ToString());
           sb.Append(", ");
        }
    }

   return sb.ToString().Trim().TrimEnd(',');
}

只有当枚举值包含在值中时，它才会进入

score 0 · Accepted Answer

所有答案都适用于简单的标志，当标志组合时你可能会遇到问题。

[Flags]
enum Food
{
  None=0
  Bread=1,
  Pasta=2,
  Apples=4,
  Banana=8,
  WithGluten=Bread|Pasta,
  Fruits = Apples | Banana,
}

可能需要添加一个检查来测试它本身的枚举值是否是一个组合。您可能需要Henk van Boeijen在此处发布的内容来满足您的要求（您需要向下滚动一点）

score 0 · Accepted Answer

在游戏开发中很重要的性能方面，由于垃圾分配和速度慢，所有给出的解决方案都很糟糕。这是一个无垃圾的解决方案，比公认的答案快 100 倍以上。

[Flags]
public enum PersonalTraits : short
{
    None = 1 << 0,
    Strength = 1 << 1,
    Agility = 1 << 2,
    Attack = 1 << 3,
    Defence = 1 << 4,
    Vitality = 1 << 5,
    Stamina = 1 << 6,
    Accuracy = 1 << 7,
    Perception = 1 << 8,
    Charisma = 1 << 9,
}
PersonalTraits athlete = PersonalTraits.Stamina | PersonalTraits.Strength;

for (short i = 0, value = 0; value <= (short)PersonalTraits.Charisma; i++, value = (short)(1 << i))
    if (((short)athlete & value) != 0)
       yield return (PersonalTraits)value;

score -1 · Accepted Answer

您可以通过转换为 int 来直接执行此操作，但您将失去类型检查。我认为最好的方法是使用类似于我的提议的东西。它一直保持正确的类型。无需转换。它并不完美，因为拳击会增加一些性能。

不完美（拳击），但它在没有警告的情况下完成了这项工作......

/// <summary>
/// Return an enumerators of input flag(s)
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static IEnumerable<T> GetFlags<T>(this T input)
{
    foreach (Enum value in Enum.GetValues(input.GetType()))
    {
        if ((int) (object) value != 0) // Just in case somebody has defined an enum with 0.
        {
            if (((Enum) (object) input).HasFlag(value))
                yield return (T) (object) value;
        }
    }
}

用法：

    FileAttributes att = FileAttributes.Normal | FileAttributes.Compressed;
    foreach (FileAttributes fa in att.GetFlags())
    {
        ...
    }

c# - 如何迭代具有标志的枚举的值？

18 回答 18

Related

Reference