Перебирать значения в Flags Enum?

Question

Если у меня есть переменная, содержащая перечисление flags, могу ли я как-то перебрать значения битов в этой конкретной переменной? Или я должен использовать Enum.GetValues ​​для перебора всего перечисления и проверки, какие из них установлены?

Answer 1

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

Answer 2

Насколько я знаю, нет встроенных методов для получения каждого компонента. Но вот один из способов, которым вы можете получить их:

[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

Вот решение Linq для этой проблемы.

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

Answer 4

Возвращаясь к этому несколько лет спустя, имея немного больше опыта, мой окончательный ответ только для однобитных значений, переход от младшего к старшему, является небольшим вариантом внутренней процедуры Джеффа Меркадо:

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 5

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

Answer 6

Выход из метода @ Грега, но добавление новой функции из C # 7.3, ограничение Enum:

public static IEnumerable<T> GetUniqueFlags<T>(this Enum 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;
}

Новое ограничение позволяет использовать этот метод расширения без необходимости проходить через(int)(object)e, и я могу использовать метод HasFlag и приводить непосредственно к T из value.

C # 7.3 также добавлены ограничения для делагатов и unmanaged.

Answer 7

Не был удовлетворен ответами выше, хотя они были началом.

После объединения нескольких различных источников здесь:
Предыдущий постер в этой теме SO QnA
Код Project Enum Flags Check Post
Великий Enum Утилита

Я создал это, поэтому дайте мне знать, что вы думаете.
Параметры:
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 , найденный здесь , который я обновил, чтобы использовать 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 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;
}

Кто-нибудь знает, как улучшить это еще дальше, чтобы он мог обрабатывать случай, когда все флаги в перечислении установлены супер-умным способом, который может обрабатывать все базовые типы перечисления, и случай All = ~ 0 и All = EnumValue1 | EnumValue2 | EnumValue3 | ...

Answer 9

Что я сделал, так это изменил мой подход, вместо того, чтобы вводить входной параметр метода как тип enum, я набрал его как массив типа enum (MyEnum[] myEnums), так что я просто повторяючерез массив с оператором switch внутри цикла.

Answer 10

Вам не нужно повторять все значения.просто отметьте ваши конкретные флаги следующим образом:

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

или (как сказано в комментариях pstrjds ) вы можете проверить его использование следующим образом:

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