C# 如何迭代具有标志的枚举的值?
如果我有一个包含标志枚举的变量,我能以某种方式迭代该特定变量中的单个位值吗?或者我必须使用Enum.GetValues来迭代整个枚举并检查设置了哪些?据我所知,没有任何内置方法来获取每个组件。但有一种方法可以让你得到它们:C# 如何迭代具有标志的枚举的值?,c#,enums,enum-flags,C#,Enums,Enum Flags,如果我有一个包含标志枚举的变量,我能以某种方式迭代该特定变量中的单个位值吗?或者我必须使用Enum.GetValues来迭代整个枚举并检查设置了哪些?据我所知,没有任何内置方法来获取每个组件。但有一种方法可以让你得到它们: [Flags] enum Items { None = 0x0, Foo = 0x1, Bar = 0x2, Baz = 0x4, Boo = 0x6, } var value = Items.Foo | Items.Bar;
[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
在内部执行的操作,以生成字符串,而不是返回标志。您可以在reflector中查看代码,代码应该或多或少是等效的。适用于包含多个位的值的一般用例
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;
}
}
}
您不需要迭代所有值。只需检查您的特定标志,如下所示:
if((myVar & FlagsEnum.Flag1) == FlagsEnum.Flag1)
{
//do something...
}
或者(如评论中所述),您可以检查是否使用它,如:
if(myVar.HasFlag(FlagsEnum.Flag1))
{
//do something...
}
您可以使用枚举中的迭代器。从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];
}
}
}
}
公共类DaysOfTheWeek:System.Collections.IEnumerable
{
int[]dayflag={1,2,4,8,16,32,64};
字符串[]天={“周一”、“周二”、“周三”、“周四”、“周五”、“周六”、“周日”};
公共字符串值{get;set;}
public System.Collections.IEnumerator GetEnumerator()
{
for(int i=0;i>i&1==dayflag[i]{
收益回报天数[i];
}
}
}
}
它没有经过测试,所以如果我犯了错误,请随时给我打电话。(显然它不是可重入的。)您必须事先赋值,或者将其分解为另一个使用enum.dayflag和enum.days的函数。您可能可以使用该大纲去某个地方。静态IEnumerable GetFlags(枚举输入)
static IEnumerable<Enum> GetFlags(Enum input)
{
foreach (Enum value in Enum.GetValues(input.GetType()))
if (input.HasFlag(value))
yield return value;
}
{
foreach(Enum.GetValues(input.GetType())中的枚举值)
if(输入.HasFlag(值))
收益回报值;
}
对上述答案不满意,尽管它们只是开始
在这里拼凑了一些不同的来源后:我创造了这个,让我知道你的想法。
参数:
bool checkZero
:告诉它允许0
作为标志值。默认情况下,input=0
返回空值。bool checkFlags
:告诉它检查Enum
是否使用[Flags]
属性修饰。顺便说一句,我现在没有时间找出
checkcombinats=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;
}
}
}
最后,这里是一个使用它的示例:
private List<CountType> GetCountTypes(CountType countTypes)
{
List<CountType> cts = new List<CountType>();
foreach (var ct in countTypes.GetFlags())
cts.Add(ct);
return cts;
}
私有列表GetCountTypes(CountType countTypes)
{
List cts=新列表();
foreach(countTypes.GetFlags()中的变量ct)
cts.Add(ct);
返回cts;
}
我所做的是改变我的方法,而不是将方法的输入参数键入enum
类型,而是将其键入enum
类型的数组(MyEnum[]myEnums
),这样我只需在循环中使用switch语句迭代数组。基于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;
}
公共静态IEnumerable到Enumerable(此枚举输入)
{
foreach(Enum.GetValues(input.GetType())中的枚举值)
if(输入.HasFlag(值)&&Convert.ToInt64(值)!=0)
收益回报值;
}
任何人都知道如何进一步改进这一点,以便它能够以超级智能的方式处理枚举中所有标志的设置,从而能够处理所有底层枚举类型以及all=~0和all=EnumValue1 | EnumValue2 | EnumValue3 |……这是一个Linq解决方案
public static IEnumerable<Enum> GetFlags(this Enum e)
{
return Enum.GetValues(e.GetType()).Cast<Enum>().Where(e.HasFlag);
}
公共静态IEnumerable GetFlags(此枚举e)
{
返回Enum.GetValues(e.GetType()).Cast().Where(e.HasFlag);
}
几年后,我带着更多的经验回到这里,我对单位值的最终答案是从最低位移到最高位,这是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;
}
}
}
公共静态IEnumerable GetUniqueFlags(此枚举标志)
{
乌龙旗=1;
foreach(Enum.GetValues(flags.GetType()).Cast()中的var值)
{
ulong位=Convert.ToUInt64(值);
while(标志<位)
{
flag您可以直接通过转换为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;
}
}
}
+对于@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;
}
}
}
公共静态IEnumerable GetUniqueFlags(此枚举标志)
{
if(!typeof(T).IsEnum)
抛出新ArgumentException(“泛型类型参数必须是枚举”);
if(flags.GetType()!=typeof(T))
抛出新ArgumentException(“泛型类型参数与目标类型不匹配”);
乌龙旗=1;
foreach(Enum.GetValues(flags.GetType()).Cast()中的var值)
{
ulong位=Convert.ToUInt64(值);
while(标志<位)
{
flag它可能与以下代码一样:
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(',');
}
如果仅当枚举值包含在@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;
}
公共静态IEnumerable GetUniqueFlags(此T标志)
其中T:Enum//C#7.3的新约束
{
foreach(Enum.GetValues(flags.GetType())中的枚举值)
if(flags.HasFlag(值))
收益率(T)值;
}
新的约束允许它成为一个扩展方法,而不必强制转换(int)(object)e
,并且我可以使用HasFlag
方法和ca
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;
}
}
}
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;
}
}
}
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(',');
}
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;
}
[Flags]
enum Food
{
None=0
Bread=1,
Pasta=2,
Apples=4,
Banana=8,
WithGluten=Bread|Pasta,
Fruits = Apples | Banana,
}
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();
}
}
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;
}
}
}
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));
}
}