Quando usi flag (Enum) hai un limite di 64. Quali sono le alternative quando raggiungi il limite?

Question

Con enum sotto .net il numero più grande che è possibile utilizzare è ULong.
Questo significa un massimo di 64 flag.

Quale sarebbe l'alternativa quando sono necessarie più di 64 bandiere?

Modifica

Siamo spiacenti, ho dimenticato di aggiungere questo, un'alternativa che avrebbe ancora lavorare con operazioni bit per bit almeno questi uno; e e o.

utilizzando Josh Einstein suggerimento, mi sono inventato questo, ha senso?

class bitArrayFlag 
{ 
    private const int flagSize = 255; //allow X numbers of flags 

    public BitArray flag1; 
    public BitArray flag2; 
    public BitArray flagN; 

    public bitArrayFlag() 
    { 
     int flagPos = 0; 
     bool[] flagBit = new bool[flagSize]; 

     flagBit[flagPos] = true; 
     flag1 = new BitArray(flagBit); 

     flagBit[flagPos] = false; 
     flagPos += 1; 
     flagBit[flagPos] = true; 
     flag2 = new BitArray(flagBit); 

     //... 
     //... 
     //... 

     flagBit[flagPos] = false; 
     flagPos += 1; 
     flagBit[flagPos] = true; 
     flagN = new BitArray(flagBit); 
    } 
} 

Answer 1

È quindi possibile passare all'utilizzo di BitArray. Si perderebbero tutte le "caratteristiche" di una enumerazione come la formattazione della stringa predefinita e l'abilità di analisi. Un BitArray sarebbe fondamentalmente simile ad avere un sacco di campi booleani, tranne che lo storage è molto più efficiente.

Infatti, come dice Jeff nei commenti con molti stati di bit indipendenti, sembra comunque che un Enum sia la soluzione sbagliata. Un BitArray potrebbe essere molto più adatto per il tuo particolare scenario.

Answer 2

Quante bandiere sembrano eccessive e suggerirebbero una riprogettazione. Tuttavia, potresti prendere in considerazione l'utilizzo di due serie di flag. Il primo a designare il "gruppo flag" e il secondo a designare i flag all'interno di quel gruppo. Dovresti avere una classe che gestisca il tuo "enum raggruppato" in modo da poter verificare se una bandiera è stata impostata o meno in un modo semplice.

struct BigFlags<TGroupEnum, TFlagEnum> 
{ 
    private Dictionary<TGroupEnum, TFlagEnum> flags; 

    public BigFlags(IDictionary<TGroupEnum, TFlagEnum> flags) 
    { 
     this.flags = new Dictionary<TGroupEnum, TFlagEnum>(flags); 
    } 

    public BigFlags(TGroupEnum group, TFlagEnum flags) 
    { 
     this.flags = new Dictionary<TGroupEnum, TFlagEnum>() { { group, flags } }; 
    } 

    public bool Contains(BigFlags<TGroupEnum, TFlagEnum> flags) 
    { 
     // TODO: Compare dictionaries and see if the passed flags are a subset of these flags. 
    } 

    // TODO: Equality to check exact match 
    // TODO: Logical operators and operators for setting/removing flags. 
} 

Answer 3

Quando sono necessari più di 64 flag, è possibile utilizzare la versione a 128 bandiere.

public class BigFlags<TEnumHi, TEnumLo> 
{ 
    private long _hi; 
    private long _lo; 

    public bool HasFlags(TEnumHi value) 
    { 
     var hiValue = (long)(object)value; 

     return (_hi & hiValue) == hiValue; 
    } 

    public bool HasFlags(TEnumLo value) 
    { 
     var loValue = (long)(object)value; 

     return (_lo & loValue) == loValue; 
    } 

    public bool HasFlags(TEnumHi hiPart, TEnumLo loPart) 
    { 
     return HasFlags(hiPart) && HasFlags(loPart); 
    } 

    public void SetFlags(TEnumHi value) 
    { 
     var hiValue = (long)(object)value; 

     _hi = _hi | hiValue; 
    } 

    public void SetFlags(TEnumLo value) 
    { 
     var loValue = (long)(object)value; 

     _lo = _lo | loValue; 
    } 

    public override string ToString() 
    { 
     var hiEnum = ((TEnumHi)(object)_hi).ToString(); 
     var loEnum = ((TEnumLo)(object)_lo).ToString(); 

     if (hiEnum.Length == 0) 
     { 
      return loEnum; 
     } 

     if (loEnum.Length == 0) 
     { 
      return hiEnum; 
     } 

     return string.Concat(hiEnum, " , ", loEnum); 
    } 
}