Comment convertir System.Enum en entier de base?

Je voudrais créer une méthode générique pour convertir n'importe quel type dérivé de System.Enum en sa valeur entière correspondante, sans conversion et de préférence sans analyse de chaîne.

Par exemple, ce que je veux, c'est quelque chose comme ceci:

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

Mais cela ne semble pas fonctionner. Resharper signale que vous ne pouvez pas convertir une expression de type «System.Enum» en type «int».

Maintenant, j'ai trouvé cette solution, mais je préfère avoir quelque chose de plus efficace.

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

Aucune suggestion?

Si vous ne voulez pas lancer,

Convert.ToInt32()

pourrait faire l'affaire.

La diffusion directe (via (int)enumValue) n'est pas possible. Notez que ce serait aussi « dangereux » car un ENUM peut avoir différents types sous - jacents ( int, long, byte...).

Plus formellement: System.Enumn'a pas de relation d'héritage directe avec Int32(bien que les deux soient ValueTypes), donc le cast explicite ne peut pas être correct dans le système de types

Je l'ai fait fonctionner en castant sur un objet puis sur un int:

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

C'est moche et probablement pas la meilleure façon. Je vais continuer à jouer avec, pour voir si je peux trouver quelque chose de mieux ...

EDIT: J'étais sur le point de publier que Convert.ToInt32 (enumValue) fonctionne également, et j'ai remarqué que MartinStettner m'a battu.

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

Tester:

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

EDIT 2: Dans les commentaires, quelqu'un a dit que cela ne fonctionne qu'en C # 3.0. Je viens de tester ceci dans VS2005 comme ceci et cela a fonctionné:

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));
    }

Si vous devez convertir une énumération en son type sous-jacent (toutes les énumérations ne sont pas sauvegardées par int), vous pouvez utiliser:

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

Pourquoi avez-vous besoin de réinventer la roue avec une méthode d'aide? Il est parfaitement légal de convertir une enumvaleur en son type sous-jacent.

C'est moins typant, et à mon avis plus lisible, à utiliser ...

int x = (int)DayOfWeek.Tuesday;

... plutôt que quelque chose comme ...

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

De ma réponse ici :

Donné ecomme dans:

Enum e = Question.Role;

Ensuite, ces travaux:

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);

Les deux derniers sont vraiment laids. Le premier devrait être plus lisible, bien que le second soit beaucoup plus rapide. Ou peut-être qu'une méthode d'extension est la meilleure, le meilleur des deux mondes.

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;
}

Vous pouvez maintenant appeler:

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

Casting from a System.Enumto an intfonctionne très bien pour moi (c'est aussi sur MSDN ). C'est peut-être un bogue Resharper.

Puisque les Enums sont limités à byte, sbyte, short, ushort, int, uint, long et ulong, nous pouvons faire certaines hypothèses.

Nous pouvons éviter les exceptions lors de la conversion en utilisant le plus grand conteneur disponible. Malheureusement, quel conteneur utiliser n'est pas clair car ulong explosera pour les nombres négatifs et long explosera pour les nombres entre long.MaxValue et ulong.MaxValue. Nous devons basculer entre ces choix en fonction du type sous-jacent.

Bien sûr, vous devez toujours décider quoi faire lorsque le résultat ne rentre pas dans un int. Je pense que le casting est correct, mais il y a encore des pièges:

1. pour les énumérations basées sur un type avec un espace de champ plus grand que int (long et ulong), il est possible que certaines énumérations évaluent à la même valeur.
2. la conversion d'un nombre supérieur à int.MaxValue lèvera une exception si vous êtes dans une région cochée.

Voici ma suggestion, je laisserai au lecteur le soin de décider où exposer cette fonction; comme aide ou extension.

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

N'oubliez pas que le type Enum lui-même contient un tas de fonctions d'assistance statiques. Si tout ce que vous voulez faire est de convertir une instance de l'énumération en son type entier correspondant, alors la conversion est probablement le moyen le plus efficace.

Je pense que ReSharper se plaint car Enum n'est pas une énumération d'un type particulier, et les énumérations elles-mêmes dérivent d'un type de valeur scalaire, pas Enum. Si vous avez besoin d'un casting adaptable de manière générique, je dirais que cela pourrait bien vous convenir (notez que le type d'énumération lui-même est également inclus dans le générique:

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

Cela pourrait alors être utilisé comme ceci:

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

// ...

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

Je ne peux pas le dire avec certitude, mais le code ci-dessus pourrait même être pris en charge par l'inférence de type C #, permettant ce qui suit:

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