Konvertieren einer Ganzzahl in eine Box enum-Typ erst zur Laufzeit bekannt

Sich vorstellen, wir haben eine enum:

enum Foo { A=1,B=2,C=3 }

Wenn der Typ bekannt ist zur compile-Zeit, eine direkte Besetzung kann verwendet werden, um zwischen den enum-Typ und den zugrunde liegenden Typ (in der Regel int):

static int GetValue() { return 2; }
...
Foo foo = (Foo)GetValue(); //becomes Foo.B

- Und Boxen-das gibt ein Feld vom Typ Foo:

object o1 = foo;
Console.WriteLine(o1.GetType().Name); //writes Foo

(und in der Tat, können Sie die box als Foo und unbox als int oder der box als int und unbox als Foo ganz glücklich)

Jedoch (das problem); wenn dem enum-Typ erst zur Laufzeit bekannt ist, die Dinge sind... schwieriger. Es ist offensichtlich trivial box als int - aber kann ich die box als Foo? (Im Idealfall ohne die Verwendung von Generika und MakeGenericMethod, das wäre unschön). Convert.ChangeType eine exception wirft. ToString und Enum.Parse funktioniert, aber ist schrecklich ineffizient.

Konnte ich schaue auf die angegebenen Werte (Enum.GetValues oder Type.GetFields), aber das ist sehr schwer für [Flags], und auch ohne erfordern würde immer wieder zu den zugrunde liegenden Typ der ersten (das ist nicht so schwer, zum Glück).

Aber; gibt es einen direkteren, einen Wert des richtigen zugrunde liegenden Typs zu einem Feld der enum-Typ, wobei der Typ erst zur Laufzeit bekannt ist?

InformationsquelleAutor Marc Gravell | 2010-04-17
  1. 71

    Ich denke, die Enum.ToObject Methode wird tun, was Sie wollen.

    Type type= typeof(Foo);
object o1 = Enum.ToObject(type,GetValue());
    • Wie die |$(*&%$( habe ich da was übersehen! Danke, das ist genau das, was ich will.
    • Einfach zu verpassen. Scheint wie ein schrecklicher name der Methode. So etwas wie Enum.FromValue vielleicht besser gewesen.
    InformationsquelleAutor aaronb
  2. 8

    Wollte gerade etwas hinzufügen, um @aaronb Antwort: ich musste das tun, was für einige auto-mapping-code und fand heraus, dass ich brauchte, um zu tun einige Kontrollen, um die code-Arbeit für beliebige Typen. Insbesondere, null-Werte und null-Werte zulässt enums geben Sie Kopfschmerzen.

    Der sicherste code, den ich im moment haben, ist dies:

    static object CastBoxedValue(object value, Type destType)
{
    if (value == null)
        return value;

    Type enumType = GetEnumType(destType);
    if (enumType != null)
        return Enum.ToObject(enumType, value);

    return value;
}

private static Type GetEnumType(Type type)
{
    if (type.IsEnum)
        return type;

    if (type.IsGenericType)
    {
        var genericDef = type.GetGenericTypeDefinition();
        if (genericDef == typeof(Nullable<>))
        {
            var genericArgs = type.GetGenericArguments();
            return (genericArgs[0].IsEnum) ? genericArgs[0] : null;
        }
    }
    return null;
}

    Wenn Sie können nie ein nullable-Typ, dann ignorieren Sie diese. 🙂

    • Wertvolle Gedanken, aber in der Tat habe ich bereits entfernt Dinge wie Nullable<T>, List<T> etc vor dieser.
    • Nullable.GetUnderlyingType vielleicht ein wenig einfacher als die Prüfung der generischen Argumente.
    InformationsquelleAutor Aaronaught
Schreibe einen Kommentar