Iterate sui valori in Flags Enum?

Question

Se ho una variabile che contiene un enumerazione di flag, posso in qualche modo scorrere i valori di bit in quella specifica variabile? O devo usare Enum.GetValues ​​per iterare sull'intero enum e controllare quali sono impostati?

Answer 1

Tornando a questo un paio di anni più tardi, con un po 'più di esperienza, la mia risposta definitiva per solo valori singoli bit, passando dal bit più basso al più alto bit, è una leggera variante di Jeff Mercado interna di 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; 
     } 
    } 
} 

sembra funzionare, e nonostante le mie obiezioni di alcuni anni fa, io uso hasFlag qui, dal momento che è molto più leggibile rispetto all'utilizzo di confronto bit per bit e la differenza di velocità è insignificante per qualsiasi cosa farò. (È del tutto possibile che abbiano migliorato la velocità di HasFlags da allora comunque, per quel che ne so ... non ho provato.)

Answer 2

Non ci sono metodi AFAIK per ottenere ogni componente. Ecco un modo si possono ottenere:

[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 

---

Ho adattato quello Enum fa internamente per generare la stringa di restituire invece le bandiere. Puoi guardare il codice nel riflettore e dovrebbe essere più o meno equivalente. Funziona bene per i casi di uso generale dove ci sono valori che contengono più bit.

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

Il metodo di estensione GetIndividualFlags() ottiene tutti i singoli bandiere per un tipo. Quindi i valori contenenti più bit sono esclusi.

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

Answer 3

Non è necessario ripetere tutti i valori. basta controllare i flag specifici in questo modo:

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

o (come detto pstrjds nei commenti), è possibile verificare la presenza di utilizzarlo come:

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

Answer 4

È possibile utilizzare un Iterator dal Enum. A partire dal codice 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]; 
      } 
     } 
    } 
} 

Non è testato, quindi se ho fatto un errore non esitate a chiamarmi. (ovviamente non è ri-entrante.) Dovresti assegnare un valore in anticipo, o scomporlo in un'altra funzione che usa enum.dayflag ed enum.days. Potresti essere in grado di andare da qualche parte con il contorno.

Answer 5

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

Answer 6

Non soddisfatto delle risposte di cui sopra, sebbene fossero l'inizio.

Dopo mettendo insieme alcune fonti differenti qui:
Previous poster in this thread's SO QnA
Code Project Enum Flags Check Post
Great Enum<T> Utility

Ho creato questo modo fatemi sapere cosa ne pensate.
Parametri:
bool checkZero: indica di consentire 0 come valore di contrassegno. Per impostazione predefinita, input = 0 restituisce vuoto.
bool checkFlags: indica per verificare se lo Enum è decorato con l'attributo [Flags].
PS. Non ho tempo ora per capire l'alg checkCombinators = false che lo costringerà a ignorare tutti i valori enum che sono combinazioni di bit.

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

    } 

Questo fa uso della classe di supporto Enum<T> found here che ho aggiornato da usare yield return per 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); 
    } 
} 

Infine, ecco un esempio di utilizzo di esso:

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

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

     return cts; 
    } 

Answer 7

Quello che ho fatto è stato cambiare il mio approccio, invece di digitare il parametro di input del metodo come il tipo enum, l'ho digitato come un array del enum tipo (MyEnum[] myEnums), in questo modo ho solo scorrere l'array con un'istruzione switch all'interno del ciclo.

Answer 8

Basandosi sulla risposta di Greg sopra, questo si occupa anche del caso in cui si ha un valore 0 nel proprio enum, come None = 0. In tal caso, non dovrebbe iterare su quel valore.

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

Qualcuno sapere come migliorare su questo ancora di più in modo che possa gestire il caso in cui sono fissati in un modo super intelligente in grado di gestire tutti i sottostanti tipo enum e il caso di tutti i = tutte le bandiere del enum ~ 0 e Tutti = EnumValue1 | EnumValue2 | EnumValue3 | ...

Answer 9

Ecco una soluzione Linq al problema.

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

Answer 10

Puoi farlo direttamente convertendo in int ma perderai il controllo del tipo. Penso che il modo migliore sia usare qualcosa di simile alla mia proposta. Mantiene il tipo corretto fino in fondo. Nessuna conversione richiesta. Non è perfetto a causa del pugilato che aggiungerà un piccolo successo in termini di prestazioni.

Non perfetta (pugilato), ma fa il lavoro senza preavviso ...

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

Usage:

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

Answer 11

+1 per la risposta fornita da @ RobinHood70. Ho trovato che una versione generica del metodo era conveniente per me.

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