Получить значение int из перечисления в C #

public enum ViewType
{
    List = 1,
    Table = 2,
};
            
// You can use the Enum type as a parameter, so any enumeration from any enumerator 
// cshtml
// using proyects.Helpers
// @if (Model.ViewType== (int)<variable>.List )

предоставит вам список со всеми целыми значениями перечисления:

Список enumValues ​​= Enum.GetValues ​​(typeof (EnumClass)). Cast (). ToList ();

Вы должны были использовать Приведение типов , как мы можем использовать на любом другом языке.

Если ваш enum такой:

public enum Question
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

И вам нужно преобразовать в int, затем сделайте следующее -

Question q = Question.Role;
.............
.............
int something = (int) q;

Re-

В C # существует два типа приведения типов:

• Неявное приведение ( автоматически ) - преобразование меньшего типа в больший размер, например -

char -> int -> long -> float -> double

• Явное приведение ( вручную ) - преобразование большего типа в тип меньшего размера, например -

double -> float -> long -> int -> char

Больше можно найти в здесь .

Использование:

Question question = Question.Role;
int value = question.GetHashCode();

Результатом будет value == 2.

Это верно, только если перечисление помещается внутри int.

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

public static class EnumEx
{
    public static dynamic Value(this Enum e)
    {
        switch (e.GetTypeCode())
        {
            case TypeCode.Byte:
            {
                return (byte) (IConvertible) e;
            }

            case TypeCode.Int16:
            {
                return (short) (IConvertible) e;
            }

            case TypeCode.Int32:
            {
                return (int) (IConvertible) e;
            }

            case TypeCode.Int64:
            {
                return (long) (IConvertible) e;
            }

            case TypeCode.UInt16:
            {
                return (ushort) (IConvertible) e;
            }

            case TypeCode.UInt32:
            {
                return (uint) (IConvertible) e;
            }

            case TypeCode.UInt64:
            {
                return (ulong) (IConvertible) e;
            }

            case TypeCode.SByte:
            {
                return (sbyte) (IConvertible) e;
            }
        }

        return 0;
    }

public enum Suit : int
{
    Spades = 0,
    Hearts = 1,
    Clubs = 2,
    Diamonds = 3
}

Console.WriteLine((int)(Suit)Enum.Parse(typeof(Suit), "Clubs"));

// From int
Console.WriteLine((Suit)1);

// From a number you can also
Console.WriteLine((Suit)Enum.ToObject(typeof(Suit), 1));

if (typeof(Suit).IsEnumDefined("Spades"))
{
    var res = (int)(Suit)Enum.Parse(typeof(Suit), "Spades");
    Console.Out.WriteLine("{0}", res);
}

Поскольку перечисления могут быть объявлены с несколькими примитивными типами, может быть полезен общий метод расширения для приведения любого типа перечисления.

enum Box
{
    HEIGHT,
    WIDTH,
    DEPTH
}

public static void UseEnum()
{
    int height = Box.HEIGHT.GetEnumValue<int>();
    int width = Box.WIDTH.GetEnumValue<int>();
    int depth = Box.DEPTH.GetEnumValue<int>();
}

public static T GetEnumValue<T>(this object e) => (T)e;

Ниже приведен метод расширения

public static string ToEnumString<TEnum>(this int enumValue)
{
    var enumString = enumValue.ToString();
    if (Enum.IsDefined(typeof(TEnum), enumValue))
    {
        enumString = ((TEnum) Enum.ToObject(typeof (TEnum), enumValue)).ToString();
    }
    return enumString;
}

В Visual Basic это должно быть:

Public Enum Question
    Role = 2
    ProjectFunding = 3
    TotalEmployee = 4
    NumberOfServers = 5
    TopBusinessConcern = 6
End Enum

Private value As Integer = CInt(Question.Role)

Пример, который я хотел бы предложить, «получить значение int из перечисления»:

public enum Sample
{
    Book = 1, 
    Pen = 2, 
    Pencil = 3
}

int answer = (int)Sample.Book;

Теперь ответ будет 1.

Мой любимый хак с перечислениями int или меньше:

GetHashCode();

Для перечисления

public enum Test
{
    Min = Int32.MinValue,
    One = 1,
    Max = Int32.MaxValue,
}

Это,

var values = Enum.GetValues(typeof(Test));

foreach (var val in values)
{
    Console.WriteLine(val.GetHashCode());
    Console.WriteLine(((int)val));
    Console.WriteLine(val);
}

выходы

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Заявление об отказе от ответственности :

Не работает для перечислений на основе long.

Может быть, я это пропустил, но пробовал ли кто-нибудь простой универсальный метод расширения?

У меня это отлично работает. Таким образом можно избежать приведения типов в API, но в конечном итоге это приведет к операции изменения типа. Это хороший случай для программирования Roslyn, чтобы компилятор создал для вас метод GetValue <T>.

    public static void Main()
    {
        int test = MyCSharpWrapperMethod(TestEnum.Test1);

        Debug.Assert(test == 1);
    }

    public static int MyCSharpWrapperMethod(TestEnum customFlag)
    {
        return MyCPlusPlusMethod(customFlag.GetValue<int>());
    }

    public static int MyCPlusPlusMethod(int customFlag)
    {
        // Pretend you made a PInvoke or COM+ call to C++ method that require an integer
        return customFlag;
    }

    public enum TestEnum
    {
        Test1 = 1,
        Test2 = 2,
        Test3 = 3
    }
}

public static class EnumExtensions
{
    public static T GetValue<T>(this Enum enumeration)
    {
        T result = default(T);

        try
        {
            result = (T)Convert.ChangeType(enumeration, typeof(T));
        }
        catch (Exception ex)
        {
            Debug.Assert(false);
            Debug.WriteLine(ex);
        }

        return result;
    }
}

Еще один способ:

Console.WriteLine("Name: {0}, Value: {0:D}", Question.Role);

Результатом будет:

Name: Role, Value: 2

int number = Question.Role.GetHashCode();

number должно иметь значение 2.

Используйте вместо этого метод расширения:

public static class ExtensionMethods
{
    public static int IntValue(this Enum argEnum)
    {
        return Convert.ToInt32(argEnum);
    }
}

И использование немного красивее:

var intValue = Question.Role.IntValue();

public enum QuestionType
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

... это заявление о наложении штрафа.

Вы должны преобразовать результат в int следующим образом:

int Question = (int)QuestionType.Role

В противном случае тип по-прежнему QuestionType.

Такой уровень строгости - это стиль C #.

Альтернативой является использование вместо этого объявления класса:

public class QuestionType
{
    public static int Role = 2,
    public static int ProjectFunding = 3,
    public static int TotalEmployee = 4,
    public static int NumberOfServers = 5,
    public static int TopBusinessConcern = 6
}

Объявление менее элегантно, но вам не нужно приводить его в коде:

int Question = QuestionType.Role

В качестве альтернативы вы можете чувствовать себя более комфортно с Visual Basic, который удовлетворяет такие ожидания во многих областях.

Попробуйте это вместо преобразования enum в int:

public static class ReturnType
{
    public static readonly int Success = 1;
    public static readonly int Duplicate = 2;
    public static readonly int Error = -1;        
}

В связи с этим, если вы хотите получить значение int из System.Enum, укажите здесь 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);

Последние два уродливые. Я предпочитаю первый.

Недавно я отказался от использования перечислений в своем коде в пользу вместо использования классов с защищенными конструкторами и предопределенными статическими экземплярами (благодаря Roelof - C # Ensure Valid Enum Values ​​- Futureproof Method).

В свете этого ниже я расскажу, как я теперь подхожу к этой проблеме (включая неявное преобразование в / из int).

public class Question
{
    // Attributes
    protected int index;
    protected string name;
    // Go with a dictionary to enforce unique index
    //protected static readonly ICollection<Question> values = new Collection<Question>();
    protected static readonly IDictionary<int,Question> values = new Dictionary<int,Question>();

    // Define the "enum" values
    public static readonly Question Role = new Question(2,"Role");
    public static readonly Question ProjectFunding = new Question(3, "Project Funding");
    public static readonly Question TotalEmployee = new Question(4, "Total Employee");
    public static readonly Question NumberOfServers = new Question(5, "Number of Servers");
    public static readonly Question TopBusinessConcern = new Question(6, "Top Business Concern");

    // Constructors
    protected Question(int index, string name)
    {
        this.index = index;
        this.name = name;
        values.Add(index, this);
    }

    // Easy int conversion
    public static implicit operator int(Question question) =>
        question.index; //nb: if question is null this will return a null pointer exception

    public static implicit operator Question(int index) =>        
        values.TryGetValue(index, out var question) ? question : null;

    // Easy string conversion (also update ToString for the same effect)
    public override string ToString() =>
        this.name;

    public static implicit operator string(Question question) =>
        question?.ToString();

    public static implicit operator Question(string name) =>
        name == null ? null : values.Values.FirstOrDefault(item => name.Equals(item.name, StringComparison.CurrentCultureIgnoreCase));


    // If you specifically want a Get(int x) function (though not required given the implicit converstion)
    public Question Get(int foo) =>
        foo; //(implicit conversion will take care of the conversion for you)
}

Преимущество этого подхода в том, что вы получаете все, что могли бы получить из перечисления, но теперь ваш код стал намного более гибким, поэтому, если вам нужно выполнить различные действия на основе значения Question, вы можете поместить логику в Question самого себя (т.е. в предпочтительном объектно-ориентированном стиле), в отличие от размещения множества операторов case в коде для решения каждого сценария.

NB: ответ обновлен 2018-04-27, чтобы использовать возможности C # 6; то есть выражения объявления и определения тела лямбда-выражения. См. Историю изменений для исходного кода. Это дает возможность сделать определение менее подробным; что было одной из основных претензий к подходу этого ответа.

Самым простым решением, которое я могу придумать, является перегрузка метода Get(int) следующим образом:

[modifiers] Questions Get(Question q)
{
    return Get((int)q);
}

, где [modifiers] обычно может быть таким же, как для метода Get(int). Если вы не можете редактировать класс Questions или по какой-то причине не хотите, вы можете перегрузить метод, написав расширение:

public static class Extensions
{
    public static Questions Get(this Questions qs, Question q)
    {
        return qs.Get((int)q);
    }
}

Вы можете сделать это, реализовав метод расширения для вашего определенного типа перечисления:

public static class MyExtensions
{
    public static int getNumberValue(this Question questionThis)
    {
        return (int)questionThis;
    }
}

Это упрощает получение значения int текущего значения перечисления:

Question question = Question.Role;
int value = question.getNumberValue();

или

int value = Question.Role.getNumberValue();

Объявить его как статический класс с общедоступными константами:

public static class Question
{
    public const int Role = 2;
    public const int ProjectFunding = 3;
    public const int TotalEmployee = 4;
    public const int NumberOfServers = 5;
    public const int TopBusinessConcern = 6;
}

И затем вы можете ссылаться на него как на Question.Role, и он всегда оценивается как int или как вы его определяете как.

Если вы хотите получить целое число для значения перечисления, которое хранится в переменной, тип которой будет Question, для использования, например, в методе, вы можете просто сделать это, я написал в этом примере:

enum Talen
{
    Engels = 1, Italiaans = 2, Portugees = 3, Nederlands = 4, Duits = 5, Dens = 6
}

Talen Geselecteerd;    

public void Form1()
{
    InitializeComponent()
    Geselecteerd = Talen.Nederlands;
}

// You can use the Enum type as a parameter, so any enumeration from any enumerator can be used as parameter
void VeranderenTitel(Enum e)
{
    this.Text = Convert.ToInt32(e).ToString();
}

Это изменит заголовок окна на 4, потому что переменная Geselecteerd равна Talen.Nederlands. Если я изменю его на Talen.Portugees и снова вызову метод, текст изменится на 3.

Чтобы убедиться, что значение перечисления существует, а затем проанализировать его, вы также можете сделать следующее.

// Fake Day of Week
string strDOWFake = "SuperDay";

// Real Day of Week
string strDOWReal = "Friday";

// Will hold which ever is the real DOW.
DayOfWeek enmDOW;

// See if fake DOW is defined in the DayOfWeek enumeration.
if (Enum.IsDefined(typeof(DayOfWeek), strDOWFake))
{
    // This will never be reached since "SuperDay"
    // doesn't exist in the DayOfWeek enumeration.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWFake);
}
// See if real DOW is defined in the DayOfWeek enumeration.
else if (Enum.IsDefined(typeof(DayOfWeek), strDOWReal))
{
    // This will parse the string into it's corresponding DOW enum object.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWReal);
}

// Can now use the DOW enum object.
Console.Write("Today is " + enmDOW.ToString() + ".");

Поскольку перечисления могут быть любого целочисленного типа (byte, int, short и т. Д.), Более надежным способом получения базового целочисленного значения перечисления было бы использование GetTypeCode метод в сочетании с классом Convert:

enum Sides {
    Left, Right, Top, Bottom
}
Sides side = Sides.Bottom;

object val = Convert.ChangeType(side, side.GetTypeCode());
Console.WriteLine(val);

Это должно работать независимо от базового целочисленного типа.

Пример:

public enum EmpNo
{
    Raj = 1,
    Rahul,
    Priyanka
}

И в приведенном ниже коде для получения значения перечисления:

int setempNo = (int)EmpNo.Raj; // This will give setempNo = 1

или

int setempNo = (int)EmpNo.Rahul; // This will give setempNo = 2

Перечисления будут увеличиваться на 1, и вы можете установить начальное значение. Если вы не установите начальное значение, ему будет изначально присвоено значение 0.

Это проще, чем вы думаете - перечисление уже является int. Просто нужно напомнить:

int y = (int)Question.Role;
Console.WriteLine(y); // Prints 2

Question question = Question.Role;
int value = (int) question;

Результатом будет value == 2.