Nhận giá trị int từ enum trong C #

Tôi có một lớp gọi là Questions(số nhiều). Trong lớp này có một enum gọi là Question(số ít) trông như thế này.

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

Trong Questionslớp tôi có một get(int foo)hàm trả về một Questionsđối tượng cho điều đó foo. Có một cách dễ dàng để lấy giá trị nguyên ra khỏi enum để tôi có thể làm một cái gì đó như thế này Questions.Get(Question.Role)?

Chỉ cần bỏ enum, vd

int something = (int) Question.Role;

Ở trên sẽ làm việc cho phần lớn các enum bạn thấy trong tự nhiên, như kiểu cơ bản mặc định cho một enum là int.

Tuy nhiên, như cecilphillip chỉ ra, enum có thể có các loại cơ bản khác nhau. Nếu một enum được khai báo là a uint, longhoặc ulong, thì nó nên được chuyển thành loại enum; ví dụ cho

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

bạn nên sử dụng

long something = (long)StarsInMilkyWay.Wolf424B;

Kể từ Enums thể được bất kỳ loại tách rời ( byte, int, short, vv), một cách mạnh mẽ hơn để có được giá trị không thể thiếu cơ bản của enum sẽ được tận dụng các GetTypeCodephương pháp kết hợp với các Convertlớp:

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

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

Điều này sẽ làm việc bất kể loại tích phân cơ bản.

Khai báo nó như là một lớp tĩnh có các hằng công khai:

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

Và sau đó bạn có thể tham chiếu nó như là Question.Role, và nó luôn đánh giá một inthoặc bất cứ điều gì bạn định nghĩa nó là.

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

Sẽ có kết quả value == 2.

Trên một lưu ý liên quan, nếu bạn muốn nhận intgiá trị từ System.Enum, sau đó đưa ra eở đây:

Enum e = Question.Role;

Bạn có thể dùng:

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

Hai cái cuối cùng là xấu xí. Tôi thích cái đầu tiên.

Nó dễ hơn bạn nghĩ - một enum đã là một int. Nó chỉ cần được nhắc nhở:

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

Thí dụ:

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

Và trong mã phía sau để lấy giá trị enum:

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

hoặc là

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

Enums sẽ tăng thêm 1 và bạn có thể đặt giá trị bắt đầu. Nếu bạn không đặt giá trị bắt đầu, nó sẽ được gán là 0 ban đầu.

Gần đây tôi đã chuyển đổi từ việc sử dụng enum trong mã của mình thay vì sử dụng các lớp với các hàm tạo được bảo vệ và các thể hiện tĩnh được xác định trước (nhờ Roelof - C # Đảm bảo các giá trị Enum hợp lệ - Phương thức Futureproof ).

Xét về vấn đề đó, dưới đây là cách tôi tiếp cận vấn đề này (bao gồm chuyển đổi ngầm sang / từ 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)
}

Ưu điểm của phương pháp này là bạn có được mọi thứ bạn có từ enum, nhưng mã của bạn giờ đã linh hoạt hơn rất nhiều, vì vậy bạn cần thực hiện các hành động khác nhau dựa trên giá trị của Question, bạn có thể đặt logic vào Questionchính nó (ví dụ như trong OO ưa thích thời trang) trái ngược với việc đưa ra nhiều tuyên bố tình huống trong toàn bộ mã của bạn để giải quyết từng tình huống.

NB: Trả lời cập nhật 2018-04-27 để sử dụng các tính năng C # 6; tức là biểu thức khai báo và định nghĩa cơ thể biểu thức lambda. Xem lịch sử sửa đổi cho mã gốc. Điều này có lợi ích làm cho định nghĩa ít dài dòng hơn; đó là một trong những phàn nàn chính về cách tiếp cận của câu trả lời này.

Nếu bạn muốn lấy một số nguyên cho giá trị enum được lưu trữ trong một biến, mà kiểu đó sẽ là Question, để sử dụng ví dụ trong một phương thức, bạn có thể chỉ cần làm điều này tôi đã viết trong ví dụ này:

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

Điều này sẽ thay đổi tiêu đề cửa sổ thành 4, bởi vì biến Geselecteerdlà Talen.Nederlands. Nếu tôi thay đổi nó Talen.Portugeesvà gọi lại phương thức, văn bản sẽ thay đổi thành 3.

Để đảm bảo giá trị enum tồn tại và sau đó phân tích nó, bạn cũng có thể làm như sau.

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

Có thể tôi đã bỏ lỡ nó, nhưng có ai đã thử một phương pháp mở rộng chung đơn giản chưa?

Điều này làm việc tuyệt vời cho tôi. Bạn có thể tránh kiểu truyền trong API theo cách này nhưng cuối cùng nó dẫn đến hoạt động loại thay đổi. Đây là một trường hợp tốt để lập trình Roslyn để trình biên dịch tạo phương thức GetValue <T> cho bạn.

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

Một cách nữa để làm điều đó:

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

Nó sẽ dẫn đến:

Name: Role, Value: 2

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

... là một tuyên bố tốt.

Bạn phải truyền kết quả cho int như vậy:

int Question = (int)QuestionType.Role

Nếu không, loại vẫn còn QuestionType.

Mức độ nghiêm ngặt này là cách C #.

Một cách khác là sử dụng khai báo lớp thay thế:

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
}

Việc khai báo ít thanh lịch hơn, nhưng bạn không cần phải viết mã:

int Question = QuestionType.Role

Ngoài ra, bạn có thể cảm thấy thoải mái hơn với Visual Basic, phục vụ cho loại kỳ vọng này trong nhiều lĩnh vực.

int number = Question.Role.GetHashCode();

numbernên có giá trị 2.

Bạn có thể làm điều này bằng cách thực hiện một phương thức mở rộng cho loại enum đã xác định của bạn:

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

Điều này giúp đơn giản hóa việc nhận giá trị int của giá trị enum hiện tại:

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

hoặc là

int value = Question.Role.getNumberValue();

Sử dụng phương pháp mở rộng thay thế:

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

Và việc sử dụng là một chút đẹp hơn:

var intValue = Question.Role.IntValue();

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

Sử dụng:

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

Nó sẽ dẫn đến value == 2.

Điều này chỉ đúng nếu enum vừa vặn bên trong một int.

Vì enum có thể được khai báo với nhiều kiểu nguyên thủy, nên một phương thức mở rộng chung để bỏ bất kỳ loại enum nào có thể hữu ích.

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;

Sau đây là phương pháp mở rộng

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

Hack yêu thích của tôi với en en int hoặc nhỏ hơn:

GetHashCode();

Cho một enum

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

Điều này,

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

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

đầu ra

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Tuyên bố từ chối trách nhiệm:

Nó không hoạt động cho enums dựa trên dài.

Giải pháp đơn giản nhất tôi có thể nghĩ đến là quá tải Get(int)phương thức như thế này:

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

nơi [modifiers]thường có thể giống như đối với Get(int)phương pháp. Nếu bạn không thể chỉnh sửa Questionslớp hoặc vì một số lý do không muốn, bạn có thể quá tải phương thức bằng cách viết một phần mở rộng:

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

Ví dụ tôi muốn đề xuất "để lấy giá trị 'int' từ enum", là

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

int answer = (int)Sample.Book;

Bây giờ câu trả lời sẽ là 1.

Sử dụng:

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

Hãy thử cái này thay vì chuyển enum thành int:

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

Trong Visual Basic, nó phải là:

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

Private value As Integer = CInt(Question.Role)

Tôi đã đưa ra phương pháp mở rộng này bao gồm các tính năng ngôn ngữ hiện tại. Bằng cách sử dụng động, tôi không cần biến phương thức này thành một phương thức chung và chỉ định kiểu giữ cho lệnh gọi đơn giản và nhất quán hơn:

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