Wie konvertiere ich von System.Enum in eine Basis-Ganzzahl?

Ich möchte eine generische Methode zum Konvertieren eines von System.Enum abgeleiteten Typs in seinen entsprechenden ganzzahligen Wert erstellen, ohne umzuwandeln und vorzugsweise ohne eine Zeichenfolge zu analysieren.

ZB was ich will ist so etwas:

// Trivial example, not actually what I'm doing.
class Converter
{
    int ToInteger(System.Enum anEnum)
    {
        (int)anEnum;
    }
}

Dies scheint jedoch nicht zu funktionieren. Resharper meldet, dass Sie den Ausdruck vom Typ 'System.Enum' nicht in den Typ 'int' umwandeln können.

Jetzt habe ich diese Lösung gefunden, aber ich hätte lieber etwas effizienteres.

class Converter
{
    int ToInteger(System.Enum anEnum)
    {
        return int.Parse(anEnum.ToString("d"));
    }
}

Irgendwelche Vorschläge?

Wenn du nicht besetzen willst,

Convert.ToInt32()

könnte den Trick machen.

Die direkte Besetzung (via (int)enumValue) ist nicht möglich. Beachten Sie, dass dies auch „gefährlich“ wäre da eine Enumeration verschiedene zugrunde liegende Typen haben kann ( int, long, byte...).

Formaler: System.EnumHat keine direkte Vererbungsbeziehung mit Int32(obwohl beide ValueTypes sind), so dass die explizite Umwandlung innerhalb des Typsystems nicht korrekt sein kann

Ich habe es zum Laufen gebracht, indem ich es auf ein Objekt und dann auf ein int geworfen habe:

public static class EnumExtensions
{
    public static int ToInt(this Enum enumValue)
    {
        return (int)((object)enumValue);
    }
}

Das ist hässlich und wahrscheinlich nicht der beste Weg. Ich werde weiter damit herumspielen, um zu sehen, ob ich mir etwas Besseres einfallen lassen kann ...

EDIT: Ich wollte gerade posten, dass Convert.ToInt32 (enumValue) auch funktioniert, und bemerkte, dass MartinStettner mich geschlagen hat.

public static class EnumExtensions
{
    public static int ToInt(this Enum enumValue)
    {
        return Convert.ToInt32(enumValue);
    }
}

Prüfung:

int x = DayOfWeek.Friday.ToInt();
Console.WriteLine(x); // results in 5 which is int value of Friday

EDIT 2: In den Kommentaren sagte jemand, dass dies nur in C # 3.0 funktioniert. Ich habe das gerade in VS2005 so getestet und es hat funktioniert:

public static class Helpers
{
    public static int ToInt(Enum enumValue)
    {
        return Convert.ToInt32(enumValue);
    }
}

    static void Main(string[] args)
    {
        Console.WriteLine(Helpers.ToInt(DayOfWeek.Friday));
    }

Wenn Sie eine Aufzählung in den zugrunde liegenden Typ konvertieren müssen (nicht alle Aufzählungen werden von unterstützt int), können Sie Folgendes verwenden:

return System.Convert.ChangeType(
    enumValue,
    Enum.GetUnderlyingType(enumValue.GetType()));

Warum müssen Sie das Rad mit einer Hilfsmethode neu erfinden? Es ist völlig legal, einen enumWert auf den zugrunde liegenden Typ zu setzen.

Es ist weniger tippen und meiner Meinung nach besser lesbar, ...

int x = (int)DayOfWeek.Tuesday;

... anstatt so etwas wie ...

int y = Converter.ToInteger(DayOfWeek.Tuesday);
// or
int z = DayOfWeek.Tuesday.ToInteger();

Aus meiner Antwort hier :

Gegeben ewie in:

Enum e = Question.Role;

Dann funktionieren diese:

int i = Convert.ToInt32(e);
int i = (int)(object)e;
int i = (int)Enum.Parse(e.GetType(), e.ToString());
int i = (int)Enum.ToObject(e.GetType(), e);

Die letzten beiden sind einfach hässlich. Der erste sollte besser lesbar sein, der zweite ist jedoch viel schneller. Oder vielleicht ist eine Erweiterungsmethode das Beste, das Beste aus beiden Welten.

public static int GetIntValue(this Enum e)
{
    return e.GetValue<int>();
}

public static T GetValue<T>(this Enum e) where T : struct, IComparable, IFormattable, IConvertible, IComparable<T>, IEquatable<T>
{
    return (T)(object)e;
}

Jetzt können Sie anrufen:

e.GetValue<int>(); //or
e.GetIntValue();

Das Casting von a System.Enumnach a intfunktioniert gut für mich (es ist auch auf dem MSDN ). Vielleicht ist es ein Resharper-Fehler.

Da Enums auf Byte, Sbyte, Short, Ushort, Int, Uint, Long und Ulong beschränkt sind, können wir einige Annahmen treffen.

Wir können Ausnahmen während der Konvertierung vermeiden, indem wir den größten verfügbaren Container verwenden. Leider ist nicht klar, welcher Container verwendet werden soll, da ulong für negative Zahlen und long für Zahlen zwischen long.MaxValue und ulong.MaxValue explodiert. Wir müssen zwischen diesen Auswahlmöglichkeiten basierend auf dem zugrunde liegenden Typ wechseln.

Natürlich müssen Sie immer noch entscheiden, was zu tun ist, wenn das Ergebnis nicht in ein int passt. Ich denke, Casting ist in Ordnung, aber es gibt noch einige Fallstricke:

1. Bei Aufzählungen, die auf einem Typ mit einem Feldraum größer als int (long und ulong) basieren, ist es möglich, dass einige Aufzählungen denselben Wert haben.
2. Wenn Sie eine Zahl größer als int.MaxValue eingeben, wird eine Ausnahme ausgelöst, wenn Sie sich in einem aktivierten Bereich befinden.

Hier ist mein Vorschlag, ich überlasse es dem Leser zu entscheiden, wo diese Funktion verfügbar gemacht werden soll. als Helfer oder Erweiterung.

public int ToInt(Enum e)
{
  unchecked
  {
    if (e.GetTypeCode() == TypeCode.UInt64)
      return (int)Convert.ToUInt64(e);
    else
      return (int)Convert.ToInt64(e);
  }
}

Vergessen Sie nicht, dass der Enum-Typ selbst eine Reihe statischer Hilfsfunktionen enthält. Wenn Sie lediglich eine Instanz der Enumeration in den entsprechenden Integer-Typ konvertieren möchten, ist das Casting wahrscheinlich der effizienteste Weg.

Ich denke, ReSharper beschwert sich, weil Enum keine Aufzählung eines bestimmten Typs ist und die Aufzählungen selbst von einem skalaren Werttyp abgeleitet sind, nicht von Enum. Wenn Sie generisch anpassbares Casting benötigen, würde ich sagen, dass dies gut zu Ihnen passt (beachten Sie, dass der Aufzählungstyp selbst auch im generischen enthalten ist:

public static EnumHelpers
{
    public static T Convert<T, E>(E enumValue)
    {
        return (T)enumValue;
    }
}

Dies könnte dann folgendermaßen verwendet werden:

public enum StopLight: int
{
    Red = 1,
    Yellow = 2,
    Green = 3
}

// ...

int myStoplightColor = EnumHelpers.Convert<int, StopLight>(StopLight.Red);

Ich kann es nicht mit Sicherheit sagen, aber der obige Code wird möglicherweise sogar durch die Typinferenz von C # unterstützt, was Folgendes ermöglicht:

int myStoplightColor = EnumHelpers.Convert<int>(StopLight.Red);