Wie iteriere ich über Werte einer Aufzählung mit Flags?

Wenn ich eine Variable habe, die eine Flags-Aufzählung enthält, kann ich dann irgendwie über die Bitwerte in dieser bestimmten Variablen iterieren? Oder muss ich Enum.GetValues ​​verwenden, um die gesamte Enumeration zu durchlaufen und zu überprüfen, welche festgelegt sind?

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

Hier ist eine Linq-Lösung für das Problem.

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

Soweit ich weiß, gibt es keine integrierten Methoden, um jede Komponente abzurufen. Aber hier ist eine Möglichkeit, wie Sie sie erhalten können:

[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

Ich habe die Enuminternen Funktionen angepasst , um die Zeichenfolge zu generieren und stattdessen die Flags zurückzugeben. Sie können den Code im Reflektor betrachten und sollten mehr oder weniger gleichwertig sein. Funktioniert gut für allgemeine Anwendungsfälle, in denen Werte mehrere Bits enthalten.

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

Die Erweiterungsmethode GetIndividualFlags()ruft alle einzelnen Flags für einen Typ ab. Werte, die mehrere Bits enthalten, werden also weggelassen.

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

Als ich einige Jahre später mit etwas mehr Erfahrung darauf zurückkomme, ist meine ultimative Antwort nur für Einzelbitwerte, die vom niedrigsten zum höchsten Bit übergehen, eine leichte Variante von Jeff Mercados innerer Routine:

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

Es scheint zu funktionieren, und trotz meiner Einwände vor einigen Jahren verwende ich hier HasFlag, da es weitaus besser lesbar ist als bitweise Vergleiche und der Geschwindigkeitsunterschied für alles, was ich tun werde, unbedeutend ist. (Es ist durchaus möglich, dass sie seitdem die Geschwindigkeit von HasFlags verbessert haben, soweit ich weiß ... ich habe es nicht getestet.)

Wenn Sie die Methode von @ Greg verlassen, aber eine neue Funktion aus C # 7.3 hinzufügen, lautet die EnumEinschränkung:

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

Die neue Einschränkung ermöglicht es, dass dies eine Erweiterungsmethode ist, ohne dass sie durchgearbeitet werden muss (int)(object)e, und ich kann die HasFlagMethode verwenden und direkt von Taus umwandeln value.

C # 7.3 fügte auch Einschränkungen für Verzögerungen und hinzu unmanaged.

+1 für die Antwort von @ RobinHood70. Ich fand, dass eine generische Version der Methode für mich praktisch war.

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

EDIT Und +1 für @AustinWBryan, um C # 7.3 in den Lösungsraum zu bringen.

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

Sie müssen nicht alle Werte iterieren. Überprüfen Sie einfach Ihre spezifischen Flags wie folgt:

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

oder (wie pstrjds in den Kommentaren sagte) Sie können überprüfen, ob Sie es verwenden, wie:

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

Ich habe meinen Ansatz geändert, anstatt den Eingabeparameter der Methode als enumTyp einzugeben , habe ich ihn als Array vom enumTyp ( MyEnum[] myEnums) eingegeben. Auf diese Weise durchlaufe ich das Array einfach mit einer switch-Anweisung innerhalb der Schleife.

War mit den obigen Antworten nicht zufrieden, obwohl sie der Anfang waren.

Nachdem Sie hier einige verschiedene Quellen zusammengesetzt haben:
Vorheriges Poster im SO QnA-
Code-Projekt Enum Flags dieses Threads Check Post
Great Enum <T> Utility

Ich habe das erstellt, also lass mich wissen, was du denkst.
Parameter ::
bool checkZeroWeist es an, 0als Flag-Wert zuzulassen . Standardmäßig wird input = 0leer zurückgegeben.
bool checkFlags: weist es an zu prüfen, ob das Enummit dem [Flags]Attribut dekoriert ist .
PS. Ich habe momentan keine Zeit, die checkCombinators = falseAlge herauszufinden, die sie dazu zwingt, alle Enum-Werte zu ignorieren, die Kombinationen von Bits sind.

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

    }

Hierbei wird die hier gefundene Helper Class Enum <T> verwendet, die ich aktualisiert habe, um sie zu verwenden yield returnfür 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);
    }
}  

Zum Schluss noch ein Beispiel für die Verwendung:

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

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

        return cts;
    }

Aufbauend auf Gregs obiger Antwort wird auch der Fall behandelt, in dem Sie einen Wert 0 in Ihrer Aufzählung haben, z. B. None = 0. In diesem Fall sollte dieser Wert nicht durchlaufen werden.

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

Würde jemand wissen, wie man dies noch weiter verbessern kann, damit es den Fall behandeln kann, in dem alle Flags in der Aufzählung auf eine super intelligente Weise gesetzt sind, die alle zugrunde liegenden Aufzählungstypen und den Fall von All = ~ 0 und All = EnumValue1 | behandeln kann EnumValue2 | EnumValue3 | ...

Sie können einen Iterator aus der Aufzählung verwenden. Ausgehend vom MSDN-Code:

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

Es ist nicht getestet. Wenn ich also einen Fehler gemacht habe, können Sie mich gerne anrufen. (Offensichtlich ist es kein Wiedereintritt.) Sie müssten den Wert vorher zuweisen oder ihn in eine andere Funktion aufteilen, die enum.dayflag und enum.days verwendet. Möglicherweise können Sie mit der Gliederung irgendwohin gehen.

Es könnte auch der folgende Code sein:

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(',');
}

Es geht nur dann hinein, wenn der Aufzählungswert im Wert enthalten ist

Alle Antworten funktionieren gut mit einfachen Flags. Wenn Sie Flags kombinieren, werden Sie wahrscheinlich auf Probleme stoßen.

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

Möglicherweise muss eine Prüfung hinzugefügt werden, um zu testen, ob der Enum-Wert selbst eine Kombination ist. Sie würden wahrscheinlich etwas brauchen, wie es hier von Henk van Boeijen gepostet wurde , um Ihren Bedarf zu decken (Sie müssen ein wenig nach unten scrollen)

Erweiterungsmethode unter Verwendung der neuen Enum-Einschränkung und der neuen Generika, um das Casting zu verhindern:

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

Sie können dies direkt tun, indem Sie in int konvertieren, aber Sie verlieren die Typprüfung. Ich denke, der beste Weg ist, etwas Ähnliches wie meinen Vorschlag zu verwenden. Es behält den richtigen Typ den ganzen Weg. Keine Konvertierung erforderlich. Es ist nicht perfekt, weil das Boxen die Leistung ein wenig beeinträchtigt.

Nicht perfekt (Boxen), aber es macht den Job ohne Vorwarnung ...

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

Verwendung:

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