Lista wszystkich nazw bitów z flagi Enum

Question

Próbuję utworzyć pomocniczą metodę wymieniania nazw wszystkich bitów ustawionych w wartości wyliczenia (do celów rejestrowania). Chcę mieć metodę, która zwróci listę wszystkich wartości enum określonych w niektórych zmiennych. W moim przykładzie

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

karmię go 0x81 i powinien zapewnić mi z IEnumerable<HWResponse> zawierający {Ready, Error}.

Ponieważ nie znalazłem prostszego sposobu, próbowałem napisać poniższy kod, ale nie mogę go skompilować.

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

W tej wersji kodu kompilator skarży się, że nie może rzutować litery T na wyrażenie.

Co zrobiłem źle? Czy istnieje lepszy (prostszy) sposób to zrobić? Jak mogłem wykonać obsadę?

Również próbowałem napisać metodę jako

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

ale Enum jest ze specjalnego rodzaju, który zabrania „gdzie” składni (przy użyciu C# 4.0)

Answer 1

Oto prosty sposób, aby zapisać go przy użyciu LINQ:

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

Jeśli pożądany efekt końcowy jest lista tytułów, po prostu zadzwoń mask.ToString().

Co byś zrobił, jeśli wyliczenia zostały zdefiniowane następująco:

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

Co do rozwiązywania błąd kompilatora, należy to zrobić:

Enum bit = (Enum)(object)curValueBit; 

Jon Skeet ma projekt o nazwie unconstrained melody że pozwala dodać ograniczenie enum po kompilacji przez przepisanie IL. Działa to, ponieważ CLR obsługuje takie ograniczenie, mimo że C# nie.

Inna myśl: To będzie bardziej efektywne, aby rzutować wartości zwracanej getValues ​​bezpośrednio do T[]:

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

Answer 3

Co jeśli po prostu zrobić coś takiego:

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

Jako as nie ma czas kompilacji. Kompilator tutaj "wierzy" w ciebie, mając nadzieję, że wiesz, co robisz, więc błąd kompilacji nie został podniesiony.

Answer 4

budynek na Gabe's answer wymyśliłem to:

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

zorganizowałem rzeczy nieco inaczej, a mianowicie Włożyłem czek typu (tj .: weryfikacja, że ​​T jest rzeczywiście wyliczeniem) i uzyskanie wartości wyliczeniowych w konstruktorze statycznym, więc robi się to tylko raz (byłoby to poprawa wydajności).

Kolejna rzecz, dodałem opcjonalny parametr , dzięki czemu można zignorować typową "zero"/"Brak"/"Niezałożalna"/"Nieokreślona"/etc wartość wyliczenia.