迭代标志枚举中的值？

Question

如果我有一个变量持有一个标志枚举，我可以以某种方式遍历该特定变量中的位值？或者我必须使用Enum.GetValues遍历整个枚举并检查哪些被设置？

Answer 1

说回这几年后，带着几分更多的经验，我只的单比特值最终的答案，从最低位移动到最高位，是微不足道的变种杰夫·梅尔卡多的内部程序：

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的速度，无论如何，对于我所知道的...我还没有测试过。）

Answer 2

AFAIK没有任何方法可以获取每个组件。这里有一种方法可以让他们：

[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 

Answer 3

您不需要迭代所有值。请查看您的特定标志，像这样：

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

或（如pstrjds在评论中说的），你可以检查这样使用它：

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

Answer 4

您可以使用一个Iterator从枚举。从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的函数。你可能能够在大纲的某个地方去。

Answer 5

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

Answer 6

对上述答案不满意，虽然他们是开始。

这里拼凑一些不同的来源后：我创造了这个
Previous poster in this thread's SO QnA
Code Project Enum Flags Check Post
Great Enum<T> Utility

所以让我知道你在想什么。
参数：
bool checkZero：通知它允许0作为标志值。默认input = 0返回空。
bool checkFlags：通知它检查Enum是否装饰有[Flags]属性。 PS：我现在没有时间来计算出checkCombinators = false alg，这会迫使它忽略任何枚举值的组合。

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; 
      } 
     } 

    } 

这使得使用助手类Enum<T> found here的，我更新使用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; 
    } 

Answer 7

我做了什么改变了我的方法，而不是键入方法的输入参数作为enum类型，我键入它的数组enum类型（MyEnum[] myEnums），这样我只需在循环内用switch语句迭代数组。

Answer 8

基于格雷格的回答，上面的这个也适用于你的枚举值为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; 
} 

有没有人知道如何在这甚至进一步提高，使其能够应对在枚举所有标志的，可以处理所有基础枚举类型和所有=的情况下，超级智​​能的方式设置的情况下〜0和All = EnumValue1 | EnumValue2 | EnumValue3 | ...

Answer 9

这是一个Linq解决方案。

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

Answer 10

您可以直接通过转换为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()) 
    { 
     ... 
    } 

Answer 11

+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; 
     } 
    } 
}