Abbildung einer Wert der Enum T auf gültige Flag-Werte (0, 1, 2, 4, 8, 16, 24 ...)

Question

Können sagen, ich habe folgendes Enum:

public enum SomeEnum 
{ 
    A, // = 0 
    B, // = 1 
    C, // = 2 
    D, // = 3 
    E, // = 4 
    ... 
} 

Im Grunde, was ich will Zu tun ist, jeden Wert einem gültigen Maskenwert zuzuweisen (0, 1, 2, 4, 8, 16, 32, 64, 128 ...), so dass SomeEnum.A gleich 0 ist, während SomeEnum.B zu 1, SomeEnum.C bis 2, SomeEnum.D bis 4, SomeEnum.E bis 8 und so weiter. Ich habe es irgendwie funktioniert, aber ich stehe vor einem anderen Problem: Je mehr Werte das gegebene Enum hat, desto größer wird dieses Mapping, was wahrscheinlich zu einer Super-Ultra-Riese-Long-Long-Long-Long-Nummer führt. Gibt es dafür bekannte Techniken?

Hier ist mein Code:

public class Flagger<T> where T : struct 
    { 
     private static Dictionary<int, ulong> dictionary = new Dictionary<int, ulong>(); 

     static Flagger() 
     { 
      int indexer = 0; 

      // Since values can be duplicated, we use names instead 
      foreach (String name in Enum.GetNames(typeof(T))) 
      { 
       ulong value = 1UL << indexer++; // 0, 1, 2, 4, 8, 16... 

       Console.WriteLine("{0} generated value {1}", name, value); 

       dictionary.Add(name.GetHashCode(), value); 
      } 
     } 

     private ulong flags; 

     public void Add(T value) 
     { 
      // Create hash only once for both checkup and storation 
      int hash = value.ToString().GetHashCode(); 

      if (Check(hash)) 
      { 
       ulong flag = dictionary[hash]; 

       flags &= flag; 
      } 
     } 

     public void Remove(T value) 
     { 
      // Create hash only once for both checkup and storation 
      int hash = value.ToString().GetHashCode(); 

      if (Check(hash)) 
      { 
       ulong flag = dictionary[hash]; 

       flags &= ~flag; 
      }    
     } 

     /// <summary> 
     /// Tests whether a value has already been added or not 
     /// </summary> 
     public bool Check(T value) 
     { 
      int hash = value.ToString().GetHashCode(); 

      return Check(hash); 
     } 

     /// <summary> 
     /// Quick checkup because no hash needs to be computed 
     /// </summary> 
     private bool Check(int hash) 
     { 
      if (dictionary.ContainsKey(hash)) 
      { 
       ulong flag = dictionary[hash]; 

       return (flags & flag) == flag; 
      } 

      return false; 
     } 
    } 

Der Grund dafür ist alles, was ich mit dem System.Window.Input.Key Enum bin zu arbeiten und ich bin nicht in der Lage, ob einige Flags zu testen freigegeben , zum Beispiel:

Die obige "if" Bedingung gibt mir wahr zurück, was nicht wirklich wahr ist!

Answer 1

Verwenden Bitverschiebung:

[Flags] 
public enum MyEnum 
{ 
    None = 0, 
    First = 1 << 0, 
    Second = 1 << 1, 
    Third = 1 << 2, 
    Fourth = 1 << 3 
} 

EDIT: nach Klärung des Problems, das ist, wie Sie über die Bewertung gehen würden, wenn ein gekennzeichnetes Schlüssel Enum-Wert den Gegenwert eines unterschiedlich typisierte enthält, aber in ähnlicher Weise -name enum Wert.

[Flags] 
public enum Keys1 
{ 
    O = 0, 
    K = 1, 
    A = 1 << 1, 
    Y = 1 << 2 
} 

public enum Keys2 
{ 
    O, 
    K, 
    A, 
    Y 
} 

public bool DoesIncludeKey(Keys1 keys1, Keys2 keys2) 
{ 
    var keys1Names = keys1.ToString().Split(','); 
    return keys1Names.Contains(keys2.ToString()); 
} 

//ToString() on keysVals results in "O,K", 
//which is what makes the above function work. 
var keysVals = Keys1.O | Keys1.K; 

//true! 
var includesK = DoesIncludeKey(keysVals, Keys2.K); 
//false. 
var includesA = DoesIncludeKey(keysVals, Keys2.A);