C # හි එනූම් වෙතින් int අගය ලබා ගන්න

මට Questions(බහු) නමින් පන්තියක් තිබේ. මෙම පංතියේ මේ Questionආකාරයට පෙනෙන (ඒකීය) නම් එනූමයක් ඇත.

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

තුළ Questionsපන්ති, මට දැන් ඇති get(int foo)වන ශ්රිතයක්ම Questionsඒ සඳහා වස්තුව foo. මට මේ වගේ දෙයක් කළ හැකි වන පරිදි පූර්ණ සංඛ්‍යා අගය එනුම් වලින් ලබා ගැනීමට පහසු ක්‍රමයක් Questions.Get(Question.Role)තිබේද?

එනූම් දමන්න, උදා

int something = (int) Question.Role;

ඉහත සඳහන් කළ පරිදි ඔබ වනයේ දකින එනූම් වලින් බහුතරයක් සඳහා ක්‍රියා කරනු intඇත.

කෙසේ වෙතත්, සිසිල් ෆිලිප් පෙන්වා දෙන පරිදි, එනුම් වලට විවිධ යටින් පවතින වර්ග තිබිය හැකිය. එනමාවක් a ලෙස ප්‍රකාශයට පත් කරන්නේ නම් uint, longහෝ ulong, එය එනුම් වර්ගයට දැමිය යුතුය; උදා

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

ඔබ භාවිතා කළ යුතුයි

long something = (long)StarsInMilkyWay.Wolf424B;

Enums ඕනෑම අවියෝජනීය වර්ගය (විය හැකි බැවින් 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 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 question = Question.Role;
int value = (int) question;

ප්රති result ලය වනු ඇත value == 2.

අදාළ සටහනක, ඔබට 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);

අන්තිම දෙක සරල කැතයි. මම කැමතියි පළමුවැන්නාට.

ඔබ සිතනවාට වඩා එය පහසුය - එනූම් දැනටමත් int වේ. එය මතක් කළ යුතුය:

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

උදාහරණයක්:

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

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 හි විලාසිතා) එක් එක් සිද්ධිය විසඳීම සඳහා ඔබේ කේතය පුරා බොහෝ සිද්ධි ප්‍රකාශ කිරීමට වඩා වෙනස්ව.

සැ.යු: C # 6 විශේෂාංග භාවිතා කිරීම සඳහා යාවත්කාලීන කරන ලද පිළිතුර 2018-04-27; එනම් ප්‍රකාශන ප්‍රකාශන සහ ලැම්බඩා ප්‍රකාශන ශරීර අර්ථ දැක්වීම්. මුල් කේතය සඳහා සංශෝධන ඉතිහාසය බලන්න . අර්ථ දැක්වීම මඳක් අඩු වාචික බවට පත් කිරීමේ වාසිය මෙයට ඇත; මෙම පිළිතුරේ ප්‍රවේශය පිළිබඳ ප්‍රධාන පැමිණිලි වලින් එකක් විය.

විචල්යයක ගබඩා කර ඇති එනුම් අගය සඳහා පූර්ණ සංඛ්‍යාවක් ලබා ගැනීමට ඔබට අවශ්ය නම්, ඒ සඳහා වර්ගය වනු ඇත 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() + ".");

සමහර විට මට එය මඟ හැරී ඇත, නමුත් යමෙක් සරල ජනක දිගු කිරීමේ ක්‍රමයක් උත්සාහ කර තිබේද?

මෙය මට හොඳට වැඩ කරයි. ඔබට මේ ආකාරයෙන් ඔබගේ API හි වාත්තු කිරීම වළක්වා ගත හැකි නමුත් අවසානයේ එය වෙනස්වන ආකාරයේ මෙහෙයුමකට හේතු වේ. රොස්ලින් ක්‍රමලේඛනය සඳහා මෙය හොඳ අවස්ථාවක් වන අතර සම්පාදකයා ඔබට 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);

එහි ප්‍රති result ලය වනු ඇත්තේ:

Name: Role, Value: 2

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

... කදිම ප්‍රකාශයකි.

ඔබට ප්‍රති result ලය 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

විකල්පයක් ලෙස, බොහෝ ප්‍රදේශවල මෙම ආකාරයේ අපේක්ෂාවන් සපුරාලන විෂුවල් බේසික් සමඟ ඔබට වඩාත් පහසුවක් දැනෙනු ඇත.

int number = Question.Role.GetHashCode();

numberවටිනාකම තිබිය යුතුය 2.

ඔබේ නිර්වචනය කරන ලද එනුම් වර්ගයට දිගු කිරීමේ ක්‍රමයක් ක්‍රියාත්මක කිරීමෙන් ඔබට මෙය කළ හැකිය :

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

මෙය වත්මන් enum අගයෙහි int අගය ලබා ගැනීම සරල කරයි:

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

හෝ

int value = Question.Role.getNumberValue();

ඒ වෙනුවට දිගු කිරීමේ ක්‍රමයක් භාවිතා කරන්න:

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

භාවිතය තරමක් ලස්සනයි:

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

භාවිත:

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

එහි ප්‍රති result ලය වනු ඇත value == 2.

මෙය සත්‍ය වන්නේ එනුම් එක ඇතුළත ගැලපෙන්නේ නම් පමණි int.

බහු ප්‍රාථමික වර්ග සමඟ එනූම්ස් ප්‍රකාශ කළ හැකි බැවින්, ඕනෑම එනුම් වර්ගයක් වාත්තු කිරීම සඳහා සාමාන්‍ය දිගු කිරීමේ ක්‍රමයක් ප්‍රයෝජනවත් වේ.

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

මට සිතිය හැකි පහසුම විසඳුම 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);
    }
}

Int හෝ කුඩා enums සහිත මගේ ප්‍රියතම හැක්:

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

වියාචනය:

දිගු මත පදනම්ව එනූම් සඳහා එය ක්‍රියා නොකරයි.

මම යෝජනා කිරීමට කැමති උදාහරණය “එනූමයකින් 'ඉන්ටර්' අගයක් ලබා ගැනීමට"

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

int answer = (int)Sample.Book;

දැන් පිළිතුර 1 වනු ඇත.

භාවිත:

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

Enum int බවට පරිවර්තනය කරනවා වෙනුවට මෙය උත්සාහ කරන්න:

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

දෘශ්‍ය මූලික වශයෙන්, එය විය යුත්තේ:

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

Private value As Integer = CInt(Question.Role)

වර්තමාන භාෂා අංග ඇතුළත් මෙම ව්‍යාප්ති ක්‍රමය මා විසින් ඉදිරිපත් කරන ලදී. ගතිකය භාවිතා කිරීමෙන්, මෙය සාමාන්‍ය ක්‍රමයක් බවට පත් කිරීමට මට අවශ්‍ය නැත.

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