148

flags 列挙型を保持する変数がある場合、その特定の変数のシングルビット値を反復処理できますか? または、Enum.GetValues を使用して列挙型全体を反復処理し、どの列挙型が設定されているかを確認する必要がありますか?

4

18 に答える 18

196 
static IEnumerable<Enum> GetFlags(Enum input)
{
    foreach (Enum value in Enum.GetValues(input.GetType()))
        if (input.HasFlag(value))
            yield return value;
}
于 2010-11-13T06:26:12.017 に答える
41

私の知る限り、各コンポーネントを取得するための組み込みメソッドはありません。しかし、これがあなたがそれらを得ることができる1つの方法です：

[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
于 2010-11-13T05:46:44.590 に答える
29

数年後にこれに戻って、もう少し経験を積んで、最下位ビットから最上位ビットに移動する単一ビット値のみに対する私の究極の答えは、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 の速度が向上した可能性は十分にあります。私が知っている限りでは...私はテストしていません。)

于 2014-03-06T10:52:15.663 に答える
3

私がしたことは、メソッドの入力パラメーターを型として入力する代わりに、アプローチを変更することでした。型 ( )enumの配列として入力しました。この方法では、ループ内で switch ステートメントを使用して配列を反復処理するだけです。enumMyEnum[] myEnums

于 2012-08-23T17:03:57.950 に答える
2

すべての値を繰り返す必要はありません。次のように特定のフラグを確認してください。

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

または（pstrjdsがコメントで述べたように）次のように使用を確認できます。

if(myVar.HasFlag(FlagsEnum.Flag1))
{
   //do something...
}
于 2010-11-13T05:47:00.800 に答える
2

上記の回答には満足していませんでしたが、それらは出発点でした。

ここでいくつかの異なるソースをつなぎ合わせた後:
このスレッドの前のポスター SO QnA
Code Project Enum Flags Check Post
Great Enum<T> Utility

これを作ったので感想を聞かせてください。
パラメータ: :フラグ値として
bool checkZero許可するように指示します。0デフォルトでinput = 0は空を返します。: が属性で装飾され
bool checkFlagsているかどうかを確認するよう指示します。 PS。ビットの組み合わせである列挙値を無視するように強制するalgを理解する時間がありません。Enum[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;
            }
        }

    }

これは、 forを使用するように更新したここにある 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;
    }
于 2011-09-11T20:05:06.290 に答える
2

上記の Greg の回答に基づいて構築すると、None = 0 など、列挙型に値 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 | ...

于 2012-10-24T20:20:53.300 に答える
1

列挙型からイテレータを使用できます。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を使用する別の関数に分割する必要があります。アウトラインでどこかに行けるかもしれません。

于 2010-11-13T06:02:15.273 に答える
0

すべての答えは単純なフラグでうまく機能します。フラグを組み合わせると、おそらく問題が発生するでしょう。

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

おそらく、列挙値自体が組み合わせであるかどうかをテストするチェックを追加する必要があります。要件を満たすには、 Henk van Boeijenがここに投稿したようなものが必要になるでしょう (少し下にスクロールする必要があります)。

于 2019-07-09T14:42:37.413 に答える
0

ゲーム開発で重要なパフォーマンスに関して言えば、提供されたすべてのソリューションは、ガベージ割り当てと速度の遅さのためにひどいものです。これはゴミのない、受け入れられている回答よりも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;
于 2022-01-30T10:39:41.157 に答える