Enum වෙත int දමන්නේ කෙසේද?

C # හි intකාස්ට් එකක් දැමිය හැක්කේ කෙසේද enum?

නූලකින්:

YourEnum foo = (YourEnum) Enum.Parse(typeof(YourEnum), yourString);

// The foo.ToString().Contains(",") check is necessary for enumerations marked with an [Flags] attribute
if (!Enum.IsDefined(typeof(YourEnum), foo) && !foo.ToString().Contains(","))
{
    throw new InvalidOperationException($"{yourString} is not an underlying value of the YourEnum enumeration.")
}

අන්තයකින්:

YourEnum foo = (YourEnum)yourInt;

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

අංකයෙන් ඔබට ද හැකිය

YourEnum foo = (YourEnum)Enum.ToObject(typeof(YourEnum) , yourInt);

එය දමන්න:

MyEnum e = (MyEnum)3;

Enum.IsDefined භාවිතයෙන් එය පරාසයේ තිබේදැයි ඔබට පරීක්ෂා කළ හැකිය .

if (Enum.IsDefined(typeof(MyEnum), 3)) { ... }

විකල්පයක් ලෙස, එක් ලයිනර් වෙනුවට දිගු කිරීමේ ක්‍රමයක් භාවිතා කරන්න:

public static T ToEnum<T>(this string enumString)
{
    return (T) Enum.Parse(typeof (T), enumString);
}

භාවිතය:

Color colorEnum = "Red".ToEnum<Color>();

හෝ

string color = "Red";
var colorEnum = color.ToEnum<Color>();

මම හිතන්නේ සම්පූර්ණ පිළිතුරක් ලබා ගැනීමට, .NET හි අභ්‍යන්තරව ක්‍රියා කරන ආකාරය ජනතාව දැනගත යුතුයි.

දේවල් ක්‍රියාත්මක වන ආකාරය

.NET හි එනූම් යනු අගයන් සමූහයක් (ක්ෂේත්‍ර) මූලික වර්ගයකට සිතියම් ගත කරන ව්‍යුහයකි (පෙරනිමිය int). කෙසේ වෙතත්, ඔබට ඇත්ත වශයෙන්ම ඔබේ එනුම් සිතියම් ගත කරන අනුකලනය වර්ගය තෝරා ගත හැකිය:

public enum Foo : short

මෙම අවස්ථාවේ දී එනූම් සිතියම් ගත කර ඇත short දත්ත වර්ගයට , එයින් අදහස් වන්නේ එය කෙටි ලෙස මතකයේ ගබඩා වන අතර ඔබ එය වාත්තු කර භාවිතා කරන විට එය කෙටි ලෙස හැසිරෙනු ඇත.

ඔබ එය IL දෘෂ්ටි කෝණයකින් බැලුවහොත්, (සාමාන්‍ය, int) enum එකක් මේ ආකාරයෙන් පෙනේ:

.class public auto ansi serializable sealed BarFlag extends System.Enum
{
    .custom instance void System.FlagsAttribute::.ctor()
    .custom instance void ComVisibleAttribute::.ctor(bool) = { bool(true) }

    .field public static literal valuetype BarFlag AllFlags = int32(0x3fff)
    .field public static literal valuetype BarFlag Foo1 = int32(1)
    .field public static literal valuetype BarFlag Foo2 = int32(0x2000)

    // and so on for all flags or enum values

    .field public specialname rtspecialname int32 value__
}

මෙහිදී ඔබේ අවධානයට ලක්විය යුතු දෙය value__නම් එනුම් අගයන්ගෙන් වෙන වෙනම ගබඩා කර තිබීමයි. Fooඉහත value__එනූම් සම්බන්ධයෙන් ගත් කල , වර්ගය int16 වේ. මෙයින් මූලික වශයෙන් අදහස් කරන්නේ වර්ග ගැලපෙන තාක් කල් ඔබට අවශ්‍ය ඕනෑම දෙයක් එනුම් එකක ගබඩා කළ හැකි බවයි.

මෙම අවස්ථාවෙහිදී System.Enum, එය අගය වර්ගයක් බව පෙන්වා දීමට මම කැමැත්තෙමි , එයින් මූලික වශයෙන් අදහස් කරන්නේ BarFlagමතකයේ බයිට් 4 ක් Fooගත වන අතර 2 - උදා. යටින් පවතින වර්ගයේ ප්‍රමාණය (එය ඇත්ත වශයෙන්ම ඊට වඩා සංකීර්ණ ය, නමුත් හේයි ...).

පිළිතුර

එබැවින්, ඔබට එනූමයකට සිතියම් ගත කිරීමට අවශ්‍ය පූර්ණ සංඛ්‍යාවක් තිබේ නම්, ධාවන වේලාවට කළ යුතුව ඇත්තේ කාරණා 2 ක් පමණි: බයිට් 4 පිටපත් කර වෙනත් දෙයක් නම් කරන්න (එනුම්ගේ නම). දත්ත අගය වර්ගයක් ලෙස ගබඩා කර ඇති නිසා පිටපත් කිරීම ගම්‍ය වේ - මෙයින් මූලික වශයෙන් අදහස් කරන්නේ ඔබ කළමනාකරණය නොකළ කේතයක් භාවිතා කරන්නේ නම්, දත්ත පිටපත් නොකර ඔබට සංඛ්‍යා සහ පූර්ණ සංඛ්‍යා හුවමාරු කර ගත හැකි බවයි.

එය ආරක්ෂිත කිරීම සඳහා, යටින් පවතින වර්ග එක සමාන හෝ ව්‍යංගයෙන් පරිවර්තනය කළ හැකි බව දැන ගැනීම සහ එනුම් අගයන් පවතින බව සහතික කිරීම (ඒවා පෙරනිමියෙන් පරික්ෂා නොකෙරේ!).

මෙය ක්‍රියාත්මක වන ආකාරය බැලීමට පහත කේතය උත්සාහ කරන්න:

public enum MyEnum : int
{
    Foo = 1,
    Bar = 2,
    Mek = 5
}

static void Main(string[] args)
{
    var e1 = (MyEnum)5;
    var e2 = (MyEnum)6;

    Console.WriteLine("{0} {1}", e1, e2);
    Console.ReadLine();
}

වාත්තු කිරීම e2ද ක්‍රියාත්මක වන බව සලකන්න ! ඉහත සම්පාදක දෘෂ්ටි කෝණයෙන් මෙය අර්ථවත් කරයි: value__ක්ෂේත්‍රය සරලවම 5 හෝ 6 කින් පිරී ඇති අතර Console.WriteLineඇමතුම් ලැබෙන ToString()විට නම e1නිරාකරණය වන අතර නමe2 නොමැති විට.

ඔබ අදහස් කළේ එය නොවේ Enum.IsDefined(typeof(MyEnum), 6)නම්, ඔබ සිතියම් වාත්තු කරන අගය නිර්වචනය කරන ලද එනුම් එකකට පරික්ෂා කරන්න.

සම්පාදකයා ඇත්ත වශයෙන්ම මෙය පරික්ෂා කළද, එනූම් වල යටි වර්ගය ගැන මම පැහැදිලිව සඳහන් කරමි. මම මෙය කරන්නේ මම පාරට බැස කිසිදු විස්මයකට පත් නොවීමට වග බලා ගැනීම සඳහා ය. මෙම විස්මයන් ක්‍රියාවට නැංවීම සඳහා, ඔබට පහත කේතය භාවිතා කළ හැකිය (ඇත්ත වශයෙන්ම මෙය දත්ත සමුදා කේතයෙන් බොහෝ දේ සිදුවන බව මම දැක ඇත්තෙමි):

public enum MyEnum : short
{
    Mek = 5
}

static void Main(string[] args)
{
    var e1 = (MyEnum)32769; // will not compile, out of bounds for a short

    object o = 5;
    var e2 = (MyEnum)o;     // will throw at runtime, because o is of type int

    Console.WriteLine("{0} {1}", e1, e2);
    Console.ReadLine();
}

පහත උදාහරණය ගන්න:

int one = 1;
MyEnum e = (MyEnum)one;

මම මෙම කේත කැබැල්ල භාවිතා කරන්නේ මගේ එනුම් වෙත යොමු කිරීමට ය:

if (typeof(YourEnum).IsEnumDefined(valueToCast)) return (YourEnum)valueToCast;
else { //handle it here, if its not defined }

මම එය හොඳම විසඳුම සොයා.

පහත දැක්වෙන්නේ එනුම්ස් සඳහා කදිම උපයෝගිතා පන්තියකි

public static class EnumHelper
{
    public static int[] ToIntArray<T>(T[] value)
    {
        int[] result = new int[value.Length];
        for (int i = 0; i < value.Length; i++)
            result[i] = Convert.ToInt32(value[i]);
        return result;
    }

    public static T[] FromIntArray<T>(int[] value) 
    {
        T[] result = new T[value.Length];
        for (int i = 0; i < value.Length; i++)
            result[i] = (T)Enum.ToObject(typeof(T),value[i]);
        return result;
    }


    internal static T Parse<T>(string value, T defaultValue)
    {
        if (Enum.IsDefined(typeof(T), value))
            return (T) Enum.Parse(typeof (T), value);

        int num;
        if(int.TryParse(value,out num))
        {
            if (Enum.IsDefined(typeof(T), num))
                return (T)Enum.ToObject(typeof(T), num);
        }

        return defaultValue;
    }
}

සංඛ්‍යාත්මක අගයන් සඳහා, මෙය ආරක්ෂිත බැවින් එය කුමක් වුවත් වස්තුවක් ආපසු ලබා දෙනු ඇත:

public static class EnumEx
{
    static public bool TryConvert<T>(int value, out T result)
    {
        result = default(T);
        bool success = Enum.IsDefined(typeof(T), value);
        if (success)
        {
            result = (T)Enum.ToObject(typeof(T), value);
        }
        return success;
    }
}

ඔබ 4.0 .NET රාමුව සඳහා සුදානම් නම් , නව Enum.TryParse () ශ්‍රිතයක් ඇත, එය ඉතා ප්‍රයෝජනවත් වන අතර [ධජ] ගුණාංගය සමඟ හොඳින් ක්‍රියා කරයි. ශුද්ධාසනයේ Enum.TryParse ක්රමය (සංගීත, TEnum%)

ඔබට බිට්මාස්ක් ලෙස ක්‍රියා කරන පූර්ණ සංඛ්‍යාවක් තිබේ නම් සහ [කොඩි] ගණනය කිරීමේදී අගයන් එකක් හෝ කිහිපයක් නියෝජනය කළ හැකි නම්, ඔබට මෙම කේතය භාවිතා කර තනි ධජ අගයන් ලැයිස්තුවකට විග්‍රහ කළ හැකිය:

for (var flagIterator = 0; flagIterator < 32; flagIterator++)
{
    // Determine the bit value (1,2,4,...,Int32.MinValue)
    int bitValue = 1 << flagIterator;

    // Check to see if the current flag exists in the bit mask
    if ((intValue & bitValue) != 0)
    {
        // If the current flag exists in the enumeration, then we can add that value to the list
        // if the enumeration has that flag defined
        if (Enum.IsDefined(typeof(MyEnum), bitValue))
            Console.WriteLine((MyEnum)bitValue);
    }
}

මෙය උපකල්පනය කරන්නේ යටින් පවතින වර්ගය enumඅත්සන් කරන ලද 32-බිටු නිඛිලයක් බවයි. එය වෙනස් සංඛ්‍යාත්මක වර්ගයක් නම්, එම වර්ගයේ බිටු පිළිබිඹු කිරීම සඳහා ඔබට දෘ c කේත 32 වෙනස් කළ යුතුය (හෝ ක්‍රමලේඛයෙන් එය භාවිතයෙන් ව්‍යුත්පන්න කරන්න Enum.GetUnderlyingType())

සමහර විට ඔබ MyEnumවර්ගයට වස්තුවක් ඇත . මෙන්

var MyEnumType = typeof(MyEnumType);

ඉන්පසු:

Enum.ToObject(typeof(MyEnum), 3)

මෙය ධජ ගණනය කිරීමේ දැනුවත් ආරක්ෂිත පරිවර්තන ක්‍රමයකි:

public static bool TryConvertToEnum<T>(this int instance, out T result)
  where T: Enum
{
  var enumType = typeof (T);
  var success = Enum.IsDefined(enumType, instance);
  if (success)
  {
    result = (T)Enum.ToObject(enumType, instance);
  }
  else
  {
    result = default(T);
  }
  return success;
}

නූලක් ENUM හෝ int ENUM නියතයට පරිවර්තනය කිරීම සඳහා අපි Enum.Parse ශ්‍රිතය භාවිතා කළ යුතුය. මෙන්න යූ ටියුබ් වීඩියෝවක් https://www.youtube.com/watch?v=4nhx4VwdRDk ඇත්ත වශයෙන්ම එය නූල් සමඟ නිරූපණය කරන අතර එය int සඳහාද අදාළ වේ.

පහත දැක්වෙන පරිදි කේතය යන්නේ “රතු” යනු නූල් වන අතර “MyColors” යනු වර්ණ නියතයන් ඇති ENUM වර්ණයයි.

MyColors EnumColors = (MyColors)Enum.Parse(typeof(MyColors), "Red");

තරමක් දුරින් මුල් ප්රශ්නය ලබා, නමුත් මම සොයා Stack පමාණය ප්රශ්නයට පිළිතුර නිඛිල සිට int අගය ලබා ගන්න ප්රයෝජනවත්. public const intගුණාංග සහිත ස්ථිතික පංතියක් සාදන්න , ඔබට සම්බන්ධිත intනියතයන් රාශියක් පහසුවෙන් එකතු කර ගැනීමට ඉඩ සලසයි , ඉන්පසු ඒවා intභාවිතා කරන විට ඒවා දැමිය යුතු නැත.

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

නිසැකවම, සමහර එනුම් වර්ගයේ ක්‍රියාකාරිත්වය නැති වී යනු ඇත, නමුත් දත්ත සමුදා හැඳුනුම් නියතයන් රාශියක් ගබඩා කිරීම සඳහා එය ඉතා පිළිවෙලට විසඳුමක් සේ පෙනේ.

මෙය තිත්.නෙට් 4.0 හි අර්ධ වශයෙන් ගැලපීම් සහිත ඉලක්කගත එනුම් එකකට පූර්ණ සංඛ්‍යා හෝ නූල් විග්‍රහ කරයි. අසම්පූර්ණ විය හැකි විධාන රේඛා ස්විච් විචල්‍යයන් පරිවර්තනය කිරීම සඳහා මම එය භාවිතා කරමි. එනමුවක් අහෝසි කළ නොහැකි බැවින්, ඔබ තාර්කිකව පෙරනිමි අගයක් ලබා දිය යුතුය. එය මේ ආකාරයට හැඳින්විය හැකිය:

var result = EnumParser<MyEnum>.Parse(valueToParse, MyEnum.FirstValue);

මෙන්න කේතය:

using System;

public class EnumParser<T> where T : struct
{
    public static T Parse(int toParse, T defaultVal)
    {
        return Parse(toParse + "", defaultVal);
    }
    public static T Parse(string toParse, T defaultVal) 
    {
        T enumVal = defaultVal;
        if (defaultVal is Enum && !String.IsNullOrEmpty(toParse))
        {
            int index;
            if (int.TryParse(toParse, out index))
            {
                Enum.TryParse(index + "", out enumVal);
            }
            else
            {
                if (!Enum.TryParse<T>(toParse + "", true, out enumVal))
                {
                    MatchPartialName(toParse, ref enumVal);
                }
            }
        }
        return enumVal;
    }

    public static void MatchPartialName(string toParse, ref T enumVal)
    {
        foreach (string member in enumVal.GetType().GetEnumNames())
        {
            if (member.ToLower().Contains(toParse.ToLower()))
            {
                if (Enum.TryParse<T>(member + "", out enumVal))
                {
                    break;
                }
            }
        }
    }
}

FYI: ප්‍රශ්නය වූයේ පූර්ණ සංඛ්‍යා පිළිබඳව වන අතර කිසිවෙකු සඳහන් නොකළ පරිදි Enum.TryParse ()

නූලකින්: (Enum.Parse යල්පැන ඇත, Enum.TryParse භාවිතා කරන්න)

enum Importance
{}

Importance importance;

if (Enum.TryParse(value, out importance))
{
}

පහත දැක්වෙන්නේ තරමක් හොඳ දිගු කිරීමේ ක්‍රමයකි

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

මගේ නඩුවේදී, මට WCF සේවාවෙන් එනූම් ආපසු ලබා දීමට අවශ්‍ය විය. මට enum පමණක් නොව මිත්‍රශීලී නමක්ද අවශ්‍ය විය. ToString ().

මෙන්න මගේ WCF පන්තිය.

[DataContract]
public class EnumMember
{
    [DataMember]
    public string Description { get; set; }

    [DataMember]
    public int Value { get; set; }

    public static List<EnumMember> ConvertToList<T>()
    {
        Type type = typeof(T);

        if (!type.IsEnum)
        {
            throw new ArgumentException("T must be of type enumeration.");
        }

        var members = new List<EnumMember>();

        foreach (string item in System.Enum.GetNames(type))
        {
            var enumType = System.Enum.Parse(type, item);

            members.Add(
                new EnumMember() { Description = enumType.GetDescriptionValue(), Value = ((IConvertible)enumType).ToInt32(null) });
        }

        return members;
    }
}

එනුම් වෙතින් විස්තරය ලබා ගන්නා දිගු කිරීමේ ක්‍රමය මෙන්න.

    public static string GetDescriptionValue<T>(this T source)
    {
        FieldInfo fileInfo = source.GetType().GetField(source.ToString());
        DescriptionAttribute[] attributes = (DescriptionAttribute[])fileInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);            

        if (attributes != null && attributes.Length > 0)
        {
            return attributes[0].Description;
        }
        else
        {
            return source.ToString();
        }
    }

ක්‍රියාත්මක කිරීම:

return EnumMember.ConvertToList<YourType>();

වෙතට සහ ඉන් පිටතට විවිධ ක්‍රම Enum

enum orientation : byte
{
 north = 1,
 south = 2,
 east = 3,
 west = 4
}

class Program
{
  static void Main(string[] args)
  {
    orientation myDirection = orientation.north;
    Console.WriteLine(“myDirection = {0}”, myDirection); //output myDirection =north
    Console.WriteLine((byte)myDirection); //output 1

    string strDir = Convert.ToString(myDirection);
        Console.WriteLine(strDir); //output north

    string myString = “north”; //to convert string to Enum
    myDirection = (orientation)Enum.Parse(typeof(orientation),myString);


 }
}

මෙම එනුම් දිගුවේ කොටස මට ලැබෙන්නේ කොහෙන්දැයි මම නොදනිමි, නමුත් එය ස්ටක් ඕවර් ප්‍රවාහයෙන් ය. මට මේ ගැන කණගාටුයි! නමුත් මම මෙය ගෙන කොඩි සහිත එනූම් සඳහා වෙනස් කළෙමි. කොඩි සහිත එනූම් සඳහා මම මෙය කළෙමි:

  public static class Enum<T> where T : struct
  {
     private static readonly IEnumerable<T> All = Enum.GetValues(typeof (T)).Cast<T>();
     private static readonly Dictionary<int, T> Values = All.ToDictionary(k => Convert.ToInt32(k));

     public static T? CastOrNull(int value)
     {
        T foundValue;
        if (Values.TryGetValue(value, out foundValue))
        {
           return foundValue;
        }

        // For enums with Flags-Attribut.
        try
        {
           bool isFlag = typeof(T).GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
           if (isFlag)
           {
              int existingIntValue = 0;

              foreach (T t in Enum.GetValues(typeof(T)))
              {
                 if ((value & Convert.ToInt32(t)) > 0)
                 {
                    existingIntValue |= Convert.ToInt32(t);
                 }
              }
              if (existingIntValue == 0)
              {
                 return null;
              }

              return (T)(Enum.Parse(typeof(T), existingIntValue.ToString(), true));
           }
        }
        catch (Exception)
        {
           return null;
        }
        return null;
     }
  }

උදාහරණයක්:

[Flags]
public enum PetType
{
  None = 0, Dog = 1, Cat = 2, Fish = 4, Bird = 8, Reptile = 16, Other = 32
};

integer values 
1=Dog;
13= Dog | Fish | Bird;
96= Other;
128= Null;

මෙහි අතුගා දැමීම බව දීර්ඝ ක්රමය තියෙන්නේ Int32කිරීමට Enum.

හැකි උපරිමයට වඩා අගය වැඩි වූ විට පවා එය බිටු කොඩි වලට ගෞරව කරයි. උදාහරණයක් ලෙස ඔබට 1 , 2 , සහ 4 යන හැකියාවන් සහිත එනැමයක් තිබේ නම් , නමුත් int 9 නම් , එය 8 ක් නොමැති විට 1 ලෙස තේරුම් ගනී . කේත යාවත්කාලීන කිරීම් වලට පෙර දත්ත යාවත්කාලීන කිරීමට මෙය ඔබට ඉඩ දෙයි.

   public static TEnum ToEnum<TEnum>(this int val) where TEnum : struct, IComparable, IFormattable, IConvertible
    {
        if (!typeof(TEnum).IsEnum)
        {
            return default(TEnum);
        }

        if (Enum.IsDefined(typeof(TEnum), val))
        {//if a straightforward single value, return that
            return (TEnum)Enum.ToObject(typeof(TEnum), val);
        }

        var candidates = Enum
            .GetValues(typeof(TEnum))
            .Cast<int>()
            .ToList();

        var isBitwise = candidates
            .Select((n, i) => {
                if (i < 2) return n == 0 || n == 1;
                return n / 2 == candidates[i - 1];
            })
            .All(y => y);

        var maxPossible = candidates.Sum();

        if (
            Enum.TryParse(val.ToString(), out TEnum asEnum)
            && (val <= maxPossible || !isBitwise)
        ){//if it can be parsed as a bitwise enum with multiple flags,
          //or is not bitwise, return the result of TryParse
            return asEnum;
        }

        //If the value is higher than all possible combinations,
        //remove the high imaginary values not accounted for in the enum
        var excess = Enumerable
            .Range(0, 32)
            .Select(n => (int)Math.Pow(2, n))
            .Where(n => n <= val && n > 0 && !candidates.Contains(n))
            .Sum();

        return Enum.TryParse((val - excess).ToString(), out asEnum) ? asEnum : default(TEnum);
    }

වඩා ශක්තිමත් වීමට ඔබ යම් ආකාරයක ගැලපෙන ලිහිල් කිරීමක් ගොඩනගා ගත යුතුය.

public static T ToEnum<T>(dynamic value)
{
    if (value == null)
    {
        // default value of an enum is the object that corresponds to
        // the default value of its underlying type
        // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/default-values-table
        value = Activator.CreateInstance(Enum.GetUnderlyingType(typeof(T)));
    }
    else if (value is string name)
    {
        return (T)Enum.Parse(typeof(T), name);
    }

    return (T)Enum.ToObject(typeof(T),
             Convert.ChangeType(value, Enum.GetUnderlyingType(typeof(T))));
}

පරීක්ෂණ නඩුව

[Flags]
public enum A : uint
{
    None  = 0, 
    X     = 1 < 0,
    Y     = 1 < 1
}

static void Main(string[] args)
{
    var value = EnumHelper.ToEnum<A>(7m);
    var x = value.HasFlag(A.X); // true
    var y = value.HasFlag(A.Y); // true

    var value2 = EnumHelper.ToEnum<A>("X");

    var value3 = EnumHelper.ToEnum<A>(null);

    Console.ReadKey();
}

ඕනෑම ආදාන දත්ත පරිශීලක අපේක්ෂිත enum බවට පරිවර්තනය කිරීමට එය ඔබට උදව් කරයි. පෙරනිමියෙන් int වැනි පහත දැක්වෙන එනුම් එකක් ඔබට ඇතැයි සිතමු . කරුණාකර ඔබේ enum හි මුලදී පෙරනිමි අගයක් එක් කරන්න. ආදාන අගය සමඟ ගැලපීමක් නොමැති විට උපකාරක මැදිරියේදී භාවිතා කරන.

public enum FriendType  
{
    Default,
    Audio,
    Video,
    Image
}

public static class EnumHelper<T>
{
    public static T ConvertToEnum(dynamic value)
    {
        var result = default(T);
        var tempType = 0;

        //see Note below
        if (value != null &&
            int.TryParse(value.ToString(), out  tempType) && 
            Enum.IsDefined(typeof(T), tempType))
        {
            result = (T)Enum.ToObject(typeof(T), tempType); 
        }
        return result;
    }
}

සැ.යු: මෙන්න මම අගය int ට විග්‍රහ කිරීමට උත්සාහ කරමි, මන්ද enum පෙරනිමියෙන් int වන බැවින් ඔබ බයිට් වර්ගය වන මේ ආකාරයට enum අර්ථ දක්වන්නේ නම් .

public enum MediaType : byte
{
    Default,
    Audio,
    Video,
    Image
} 

ඔබ උදව් ක්‍රමයෙන් විග්‍රහ කිරීම වෙනස් කළ යුතුය

int.TryParse(value.ToString(), out  tempType)

වෙත

byte.TryParse(value.ToString(), out tempType)

යෙදවුම් අනුගමනය කිරීම සඳහා මම මගේ ක්‍රමය පරීක්ෂා කරමි

EnumHelper<FriendType>.ConvertToEnum(null);
EnumHelper<FriendType>.ConvertToEnum("");
EnumHelper<FriendType>.ConvertToEnum("-1");
EnumHelper<FriendType>.ConvertToEnum("6");
EnumHelper<FriendType>.ConvertToEnum("");
EnumHelper<FriendType>.ConvertToEnum("2");
EnumHelper<FriendType>.ConvertToEnum(-1);
EnumHelper<FriendType>.ConvertToEnum(0);
EnumHelper<FriendType>.ConvertToEnum(1);
EnumHelper<FriendType>.ConvertToEnum(9);

මගේ ඉංග්‍රීසි ගැන කණගාටුයි

c # හි enum වෙත int එකක් දැමීම සඳහා පහසු සහ පැහැදිලි ක්‍රමය:

 public class Program
    {
        public enum Color : int
        {
            Blue = 0,
            Black = 1,
            Green = 2,
            Gray = 3,
            Yellow =4
        }

        public static void Main(string[] args)
        {
            //from string
            Console.WriteLine((Color) Enum.Parse(typeof(Color), "Green"));

            //from int
            Console.WriteLine((Color)2);

            //From number you can also
            Console.WriteLine((Color)Enum.ToObject(typeof(Color) ,2));
        }
    }

ඔබ හුදෙක් පැහැදිලි පරිවර්තනයක් භාවිතා කරන්නේ එන්ටම් සිට එනුම් දක්වා හෝ එන්ටම් සිට ඉන්ටම් දක්වා ය

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine((int)Number.three); //Output=3

        Console.WriteLine((Number)3);// Outout three
        Console.Read();
    }

    public enum Number
    {
        Zero = 0,
        One = 1,
        Two = 2,
        three = 3
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

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

        public static void Main(string[] args)
        {
            //from string
            Console.WriteLine((Suit) Enum.Parse(typeof(Suit), "Clubs"));

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

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

ඔබ පහත පරිදි කරන්න:

int intToCast = 1;
TargetEnum f = (TargetEnum) intToCast ;

ඔබ නිවැරදි අගයන් පමණක් දැමූ බවත් වෙනත් ආකාරයකින් ව්‍යතිරේකයක් විසි කළ හැකි බවත් සහතික කර ගැනීම සඳහා:

int intToCast = 1;
if (Enum.IsDefined(typeof(TargetEnum), intToCast ))
{
    TargetEnum target = (TargetEnum)intToCast ;
}
else
{
   // Throw your exception.
}

IsDefined භාවිතා කිරීම මිල අධික වන අතර එය වාත්තු කිරීමට වඩා වැඩි ය, එබැවින් එය භාවිතා කිරීමට හෝ නොකිරීමට තීරණය කිරීම ඔබේ ක්‍රියාත්මක කිරීම මත රඳා පවතී.

ඔබට දිගු කිරීමේ ක්‍රමය භාවිතා කළ හැකිය.

public static class Extensions
{

    public static T ToEnum<T>(this string data) where T : struct
    {
        if (!Enum.TryParse(data, true, out T enumVariable))
        {
            if (Enum.IsDefined(typeof(T), enumVariable))
            {
                return enumVariable;
            }
        }

        return default;
    }

    public static T ToEnum<T>(this int data) where T : struct
    {
        return (T)Enum.ToObject(typeof(T), data);
    }
}

බෙලෝ කේතය වැනි භාවිතා කරන්න

enum:

public enum DaysOfWeeks
{
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6,
    Sunday = 7,
}

භාවිතය :

 string Monday = "Mon";
 int Wednesday = 3;
 var Mon = Monday.ToEnum<DaysOfWeeks>();
 var Wed = Wednesday.ToEnum<DaysOfWeeks>();

සරල ඔබ වීසි කළ හැකි int කිරීමට නිඛිල

 int i=(DaysOfWeeks)5;