c# - सी#में enum करने के लिए int कास्ट




enums casting (14)

एक स्ट्रिंग से: (Enum.Parse तिथि से बाहर है, Enum.TryParse का उपयोग करें)

enum Importance
{}

Importance importance;

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

सी # में एक enum लिए एक int कैसे डाला जा सकता है?


एक स्ट्रिंग से:

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

एक int से:

YourEnum foo = (YourEnum)yourInt;

अद्यतन करें:

संख्या से आप भी कर सकते हैं

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

थोड़ा सा मूल प्रश्न से दूर हो रहा है, लेकिन मुझे स्टैक ओवरफ़्लो प्रश्न का उत्तर मिला, एनम उपयोगी से 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;
}

जाहिर है, कुछ enum प्रकार की कार्यक्षमता खो जाएगी, लेकिन डेटाबेस आईडी स्थिरांक का एक गुच्छा भंडारण के लिए, यह एक सुंदर साफ समाधान की तरह लगता है।


निम्नलिखित उदाहरण लें:

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

नीचे Enums के लिए एक अच्छी उपयोगिता वर्ग है

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

बस इसे कास्ट करें:

MyEnum e = (MyEnum)3;

आप जांच सकते हैं कि यह Enum.IsDefined का उपयोग कर सीमा में है Enum.IsDefined :

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

मेरे मामले में, मुझे डब्ल्यूसीएफ सेवा से enum वापस करने की जरूरत है। मुझे एक दोस्ताना नाम भी चाहिए, न कि enum.ToString ()।

यहां मेरी डब्ल्यूसीएफ कक्षा है।

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

यहां एक्सटेंशन विधि है जो Enum से विवरण प्राप्त करती है।

    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 में int डालने के लिए कोड के इस टुकड़े का उपयोग कर रहा हूँ:

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

मुझे यह सबसे अच्छा समाधान मिल रहा है।


यदि आप 4.0 .NET Framework के लिए तैयार हैं, तो एक नया Enum.TryParse () फ़ंक्शन है जो बहुत उपयोगी है और [ध्वज] विशेषता के साथ अच्छी तरह से खेलता है। Enum.TryParse विधि देखें (स्ट्रिंग, TENum%)


यदि आपके पास एक पूर्णांक है जो बिटमैस्क के रूप में कार्य करता है और [ध्वज] गणना में एक या अधिक मानों का प्रतिनिधित्व कर सकता है, तो आप व्यक्तिगत ध्वज मानों को एक सूची में पार्स करने के लिए इस कोड का उपयोग कर सकते हैं:

for (var flagIterator = 0x1; flagIterator <= 0x80000000; flagIterator <<= 1)
{
    // Check to see if the current flag exists in the bit mask
    if ((intValue & flagIterator) != 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), flagIterator))
            ListOfEnumValues.Add((MyEnum)flagIterator);
    }
}

यह उपरोक्त तवानी की उपयोगिता कक्षा जैसे जेनरिकों का उपयोग करते हुए dot.NET 4.0 में आंशिक मिलान के साथ एक लक्ष्य enum के लिए पूर्णांक या स्ट्रिंग को पार करता है। मैं इसे कमांड लाइन स्विच वैरिएबल को कन्वर्ट करने के लिए उपयोग कर रहा हूं जो अपूर्ण हो सकता है। चूंकि एक enum शून्य नहीं हो सकता है, आपको तार्किक रूप से एक डिफ़ॉल्ट मान प्रदान करना चाहिए। इसे इस तरह कहा जा सकता है:

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

एफवाईआई: प्रश्न पूर्णांक के बारे में था, जिसका कोई भी उल्लेख नहीं किया गया है, यह भी Enum.TryParse () में स्पष्ट रूप से परिवर्तित होगा


यह एक झंडे की गणना जागरूक सुरक्षित कनवर्ट विधि है:

public static bool TryConvertToEnum<T>(this int instance, out T result)
  where T: struct
{
  var enumType = typeof (T);
  if (!enumType.IsEnum)
  {
    throw new ArgumentException("The generic type must be an enum.");
  }
  var success = Enum.IsDefined(enumType, instance);
  if (success)
  {
    result = (T)Enum.ToObject(enumType, instance);
  }
  else
  {
    result = default(T);
  }
  return success;
}

संख्यात्मक मूल्यों के लिए, यह सुरक्षित है क्योंकि यह किसी ऑब्जेक्ट को वापस करेगा चाहे इससे कोई फर्क नहीं पड़ता:

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

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


 }
}




casting