Как преобразовать из System.Enum в базовое целое число?

Если ты не хочешь кастовать,

Convert.ToInt32()

мог сделать свое дело.

Прямая трансляция (через (int)enumValue) невозможна. Обратите внимание, что это также было бы «опасно», поскольку перечисление может иметь разные базовые типы (int, long, _5 _...).

Более формально: System.Enum не имеет прямого отношения наследования с Int32 (хотя оба являются ValueTypes), поэтому явное приведение не может быть правильным в системе типов

Я заставил его работать, приведя к объекту, а затем к int:

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

Это некрасивый и, наверное, не лучший способ. Я буду продолжать возиться с этим, чтобы посмотреть, смогу ли я придумать что-нибудь получше ...

РЕДАКТИРОВАТЬ: как раз собирался опубликовать, что Convert.ToInt32 (enumValue) также работает, и заметил, что MartinStettner превзошел меня в этом.

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

Контрольная работа:

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

РЕДАКТИРОВАТЬ 2: В комментариях кто-то сказал, что это работает только в С # 3.0. Я только что протестировал это в VS2005, и это сработало:

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

Если вам нужно преобразовать любое перечисление в его базовый тип (не все перечисления поддерживаются int), вы можете использовать:

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

Зачем нужно изобретать велосипед с помощью вспомогательного метода? Совершенно законно привести значение enum к его базовому типу.

Он меньше печатает и, на мой взгляд, более читается в использовании ...

int x = (int)DayOfWeek.Tuesday;

... а не что-то вроде ...

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

Из моего ответа здесь:

Учитывая e, как в:

Enum e = Question.Role;

Тогда работают такие:

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

Последние два уродливые. Первый должен быть более читабельным, а второй - намного быстрее. Или может быть метод расширения является лучшим, лучшим из обоих миров.

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

Теперь вы можете позвонить:

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

Трансляция из System.Enum в int мне подходит (это также на MSDN < / а>). Возможно, это ошибка Resharper.

Поскольку перечисления ограничены байтами, sbyte, short, ushort, int, uint, long и ulong, мы можем сделать некоторые предположения.

Мы можем избежать исключений во время преобразования, используя самый большой из доступных контейнеров. К сожалению, неясно, какой контейнер использовать, потому что ulong взорвется для отрицательных чисел, а long - для чисел между long.MaxValue и ulong.MaxValue. Нам нужно переключаться между этими вариантами в зависимости от базового типа.

Конечно, вам все равно нужно решить, что делать, если результат не помещается в int. Я думаю, что кастинг - это нормально, но все же есть некоторые подводные камни:

1. для перечислений, основанных на типе с полем, большим, чем int (long и ulong), возможно, некоторые перечисления будут оценивать одно и то же значение.
2. приведение числа больше int.MaxValue вызовет исключение, если вы находитесь в отмеченной области.

Вот мое предложение, я оставляю читателю решать, где раскрыть эту функцию; как помощник или расширение.

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

Если вы прочитаете код для Convert.ToInt32, вы увидите, что он преобразует Enum в IConvertible, а затем вызывает ToInt32(null).

Не забывайте, что в самом типе Enum есть множество статических вспомогательных функций. Если все, что вам нужно сделать, это преобразовать экземпляр перечисления в соответствующий ему целочисленный тип, то приведение типов, вероятно, является наиболее эффективным способом.

Я думаю, что ReSharper жалуется, потому что Enum не является перечислением какого-либо конкретного типа, а сами перечисления происходят от скалярного типа значений, а не от Enum. Если вам нужно универсальное адаптируемое приведение, я бы сказал, что это может вам подойти (обратите внимание, что сам тип перечисления также включен в общий:

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

Затем это можно было бы использовать так:

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

// ...

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

Я не могу сказать наверняка, но приведенный выше код может даже поддерживаться выводом типа C #, позволяя следующее:

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