Erhalten Integralwert von Boxed Enum

Question

Ich habe beschlossen, es unmöglich ist, die folgenden (äquivalent) Enum-Operationen über Reflexion zu tun - wie die Enum-Klasse keine Operatoren hat, und auch nicht die emittierte Code keine Betreiber ausgesetzt:

object boxedEnum = MyEnum.Flag1 | MyEnum.Flag2; 
boxedEnum &= ~MyEnum.Flag2; // Remove the flag. 

Also habe ich zur Zeit die folgenden (äquivalent) tue:

int boxedEnumValue = (int) boxedEnum; 
boxedEnumValue &= ~MyEnum.Flag2; 
boxedEnum = Enum.ToObject(boxedEnum.GetType(), boxedEnumValue); 

der gut arbeitet, ist das einzige Problem, dass der entsprechende Code der boxedEnum in eine ganze Zahl zu drehen ist:

int boxedEnumValue = int.Parse(Enum.Format(boxedEnum.GetType(), boxedEnum, "X"), System.Globalization.NumberStyles.HexNumber); 

Welcher bin ich sicher, dass Sie zustimmen werden, ist schrecklich und hacky.

Also diese Frage hat zwei Zinken. Es wäre toll, wenn jemand mir einen Fehler beweisen und ein Mittel zur Verfügung stellen könnte, um binäre Operationen an Box-Enums durchzuführen - andernfalls wäre jeder Weg, den String-Round-Trip zu vermeiden, geschätzt.

Guffa gab mir, was ich brauchte, um die Enum zu einem bestimmten Typ zu konvertieren. Ich verfasste eine Erweiterungsmethode, die die Nitty-gritties tut:

/// <summary> 
    /// Gets the integral value of an enum. 
    /// </summary> 
    /// <param name="value">The enum to get the integral value of.</param> 
    /// <returns></returns> 
    public static T ToIntegral<T>(this object value) 
    { 
     if(object.ReferenceEquals(value, null)) 
      throw new ArgumentNullException("value"); 
     Type rootType = value.GetType(); 
     if (!rootType.IsEnum) 
      throw new ArgumentOutOfRangeException("value", "value must be a boxed enum."); 
     Type t = Enum.GetUnderlyingType(rootType); 

     switch (t.Name.ToUpperInvariant()) 
     { 
      case "SBYTE": 
       return (T)Convert.ChangeType((sbyte) value, typeof(T)); 
      case "BYTE": 
       return (T) Convert.ChangeType((byte) value, typeof(T)); 
      case "INT16": 
       return (T) Convert.ChangeType((Int16) value, typeof(T)); 
      case "UINT16": 
       return (T) Convert.ChangeType((UInt16) value, typeof(T)); 
      case "INT32": 
       return (T) Convert.ChangeType((Int32) value, typeof(T)); 
      case "UINT32": 
       return (T) Convert.ChangeType((UInt32) value, typeof(T)); 
      case "INT64": 
       return (T) Convert.ChangeType((Int64) value, typeof(T)); 
      case "UINT64": 
       return (T) Convert.ChangeType((UInt64) value, typeof(T)); 
      default: 
       throw new NotSupportedException(); 
     } 
    } 

Answer 1

Ein Boxed-Wert kann niemals geändert werden. Sie müssen nur die Enum unbox, um den Betrieb zu tun und es Kasten wieder:

boxedEnum = (MyEnum)boxedEnum & ~MyEnum.Flag2; 

Edit:

Vorausgesetzt, dass der zugrunde liegende Typ des ENUM-int ist, können Sie einfach es unbox es in int und Kasten zu int. Der Box-Int kann später auf den Enum-Typ entpackt werden:

boxedEnum = (int)boxedEnum & ~2; 

MyEnum value = (MyEnum)boxedEnum; // works both for a boxed int and a boxed MyEnum 

Answer 2

int enumValue = (int)SomeEnum.Val1 | (int)SomeEnum.Val2; 
SomeEnum e = (SomeEnum)enumValue; 

Haben Sie so etwas erreichen?