Listen Sie alle Bit-Namen von einem Flag Enum

Question

Ich versuche, eine Hilfsmethode für die Auflistung der Namen aller Bits in einem Enum-Wert (für Protokollierungszwecke) zu machen. Ich möchte eine Methode haben, die die Liste aller Enum-Werte in einigen Variablen zurückgeben würde. In meinem Beispiel

[Flag] 
Enum HWResponse 
{ 
    None = 0x0, 
    Ready = 0x1, 
    Working = 0x2, 
    Error = 0x80, 
} 

Ich füttere es 0x81, und es sollte mich sorgen mit einem IEnumerable<HWResponse>{Ready, Error} enthält.

Da ich keinen einfacheren Weg gefunden habe, habe ich versucht, den Code unten zu schreiben, aber ich kann es nicht kompilieren lassen.

public static IEnumerable<T> MaskToList<T>(Enum mask) 
{ 
    if (typeof(T).IsSubclassOf(typeof(Enum)) == false) 
    throw new ArgumentException(); 

    List<T> toreturn = new List<T>(100); 

    foreach(T curValueBit in Enum.GetValues(typeof (T)).Cast<T>()) 
    { 
    Enum bit = ((Enum) curValueBit); // Here is the error 

    if (mask.HasFlag(bit)) 
     toreturn.Add(curValueBit); 
    } 

    return toreturn; 
} 

Auf dieser Version des Codes, beschwert sich der Compiler, dass es nicht T Enum werfen können.

Was habe ich falsch gemacht? Gibt es einen besseren (einfacheren) Weg, dies zu tun? Wie könnte ich die Besetzung machen?

Außerdem habe ich versucht, das Verfahren, wie

public static IEnumerable<T> MaskToList<T>(Enum mask) where T:Enum 

aber ENUM ist von einer besonderen Art zu schreiben, die die ‚wo‘ Syntax (C# 4.0)

Answer 1

Hier ist eine einfache Möglichkeit, es zu schreiben LINQ mit:

public static IEnumerable<T> MaskToList<T>(Enum mask) 
{ 
    if (typeof(T).IsSubclassOf(typeof(Enum)) == false) 
     throw new ArgumentException(); 

    return Enum.GetValues(typeof(T)) 
         .Cast<Enum>() 
         .Where(m => mask.HasFlag(m)) 
         .Cast<T>(); 
} 

Answer 2

Wenn die gewünschte Endergebnis ein verbieten ist String-Liste von Namen, rufen Sie einfach mask.ToString().

Was würden Sie tun, wenn die Enumeration wie folgt definiert wurden:

[Flags] 
enum State 
{ 
    Ready = 1, 
    Waiting = 2, 
    ReadyAndWaiting = 3 
} 

Wie der Compiler-Fehler zu lösen, dies sollte es tun:

Enum bit = (Enum)(object)curValueBit; 

Jon Skeet ein Projekt unconstrained melody genannt hat, dass Mit dieser Option können Sie die Enum-Abhängigkeit nach der Kompilierung hinzufügen, indem Sie die IL neu schreiben. Dies funktioniert, weil die CLR eine solche Einschränkung unterstützt, obwohl C# dies nicht tut.

Ein anderer Gedanke: Es wird effizienter, den Rückgabewert von GetValues ​​zu T[] direkt zu werfen:

foreach(T curValueBit in (T[])Enum.GetValues(typeof (T))) 

Answer 3

Was passiert, wenn nur so etwas tun:

public static IEnumerable<T> MaskToList<T>(Enum mask) 
{ 
if (typeof(T).IsSubclassOf(typeof(Enum)) == false) 
    throw new ArgumentException(); 

    List<T> toreturn = new List<T>(100); 

    foreach(T curValueBit in Enum.GetValues(typeof (T)).Cast<T>()) 
    { 
    Enum bit = (curValueBit as Enum); // The only difference is actually here, 
             // use "as", instead of (Enum) cast 

    if (mask.HasFlag(bit)) 
     toreturn.Add(curValueBit); 
    } 

    return toreturn; 
} 

Als as hat nicht Kompilierzeitprüfung Compiler hier "glauben" Sie einfach, in der Hoffnung, dass Sie wissen, was Sie tun, so dass die Kompilierzeit Fehler nicht ausgelöst.

Answer 4

Aufbauend auf Gabe's answer Ich kam auf diese:

public static class EnumHelper<T> 
    where T : struct 
{ 
    // ReSharper disable StaticFieldInGenericType 
    private static readonly Enum[] Values; 
    // ReSharper restore StaticFieldInGenericType 
    private static readonly T DefaultValue; 

    static EnumHelper() 
    { 
     var type = typeof(T); 
     if (type.IsSubclassOf(typeof(Enum)) == false) 
     { 
      throw new ArgumentException(); 
     } 
     Values = Enum.GetValues(type).Cast<Enum>().ToArray(); 
     DefaultValue = default(T); 
    } 

    public static T[] MaskToList(Enum mask, bool ignoreDefault = true) 
    { 
     var q = Values.Where(mask.HasFlag); 
     if (ignoreDefault) 
     { 
      q = q.Where(v => !v.Equals(DefaultValue)); 
     } 
     return q.Cast<T>().ToArray(); 
    } 
} 

ich die Dinge ein wenig anders ausgedrückt, nämlich organisierte ich die Typprüfung (dh die Überprüfung, dass T tatsächlich eine Aufzählung ist) und das Ermitteln der Aufzählungswerte im statischen Konstruktor, so dass dies nur einmal erfolgt (dies wäre eine Leistungsverbesserung).

Eine andere Sache, fügte ich einen optionalen Parameter hinzu, so dass Sie die typische "Null"/"None"/"NotApplicable"/"Undefined"/etc Wert der Aufzählung ignorieren können.