枚举字符串 - 从C#中的枚举中获取int值




int转enum (16)

我有一个叫做Questions (复数)的课。 在这个类中有一个名为Question (单数)的枚举,看起来像这样。

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

Questions类中,我有一个get(int foo)函数,它返回该foo一个Questions对象。 有没有一种简单的方法从枚举中获得整数值,所以我可以做一些像Questions.Get(Question.Role)


为了确保枚举值存在并解析它,还可以执行以下操作。

// 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() + ".");

我希望这有帮助。


也许我错过了它,但有人尝试过一种简单的通用扩展方法。 这对我很好。 您可以通过这种方式避免API中的类型转换,但最终会导致更改类型的操作。 这对编程Roselyn来说是一个很好的例子,让编译器为你制作一个GetValue方法。

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

例:

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 something = (int) Question.Role;

以上将适用于你在野外看到的绝大多数枚举,因为枚举的默认基础类型是int

但是,正如cecilphillip指出的,枚举可以有不同的基础类型。 如果枚举被声明为uintlongulong ,则应将其转换为enum的类型; 例如

enum StarsInMilkyWay:long {Sun = 1, V645Centauri = 2 .. Wolf424B = 2147483649};

你应该使用

long something = (long)StarsInMilkyWay.Wolf424B;

在相关说明中,如果您想从System.Enum获取int值,则在此给出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 class ExtensionMethods
{
    public static int IntValue(this Enum argEnum)
    {
        return Convert.ToInt32(argEnum);
    }
}

用法稍微漂亮些:

var intValue = Question.Role.IntValue();

将其声明为具有公共常量的静态类:

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或者你定义它的任何东西。


尝试这个 :

int value = YourEnum.ToString("D");

我想建议'从enum获得'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的枚举不起作用


最近,我转而使用代码中的枚举,转而使用带有受保护的构造函数和预定义的静态实例的类(感谢Roelof - C#确保有效的Enum值 - Futureproof方法 )。

鉴于此,下面是我现在要解决这个问题的方法(包括从intint隐式转换)。

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本身中(例如在首选OO时尚),而不是在整个代码中添加大量的病例陈述来处理每种情况。

NB:回复更新2018-04-27以利用C#6功能; 即声明表达式和lambda表达式主体定义。 请参阅原始代码的修订历史 。 这有利于使定义略少一些; 这是这个答案的主要抱怨之一。


由于枚举可以是任何整型( byteintshort等),所以获得枚举底层整型值的更强大的方法是将GetTypeCode方法与Convert类结合使用:

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

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

无论基础整体类型如何,这都应该起作用。


试试这个而不是将enum转换为int:

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

还有一种方法可以做到这一点:

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

将导致:

Name: Role, Value: 2

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

将导致value == 2


int number = Question.Role.GetHashCode();

number应该是2的值。





int