स्ट्रिंग या इंट द्वारा एनम मूल्य कैसे प्राप्त करें

Question 1

अगर मेरे पास एनम स्ट्रिंग या एनम इंट वैल्यू है तो मैं एनम वैल्यू कैसे प्राप्त कर सकता हूं। उदाहरण: यदि मेरे पास एक एनम निम्नानुसार है:

public enum TestEnum
{
    Value1 = 1,
    Value2 = 2,
    Value3 = 3
}

और कुछ स्ट्रिंग वैरिएबल में मेरा मान "value1" इस प्रकार है:

string str = "Value1"

या कुछ इंट वैरिएबल में मेरा मूल्य 2 जैसा है

int a = 2;

मैं enum का उदाहरण कैसे प्राप्त कर सकता हूं? मैं एक सामान्य विधि चाहता हूं जहां मैं एनम उदाहरण के लिए एनम और मेरे इनपुट स्ट्रिंग या इंट वैल्यू प्रदान कर सकता हूं।

Question 2

नहीं, आप एक सामान्य विधि नहीं चाहते हैं। यह बहुत आसान है:

MyEnum myEnum = (MyEnum)myInt;

MyEnum myEnum = (MyEnum)Enum.Parse(typeof(MyEnum), myString);

मुझे लगता है कि यह भी तेज होगा।

Question 3

ऐसा करने के कई तरीके हैं, लेकिन यदि आप एक सरल उदाहरण चाहते हैं, तो यह होगा। इसे बस प्रकार की सुरक्षा और अमान्य पार्सिंग इत्यादि की जांच के लिए आवश्यक रक्षात्मक कोडिंग के साथ बढ़ाया जाना चाहिए।

    /// <summary>
    /// Extension method to return an enum value of type T for the given string.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <returns></returns>
    public static T ToEnum<T>(this string value)
    {
        return (T) Enum.Parse(typeof(T), value, true);
    }

    /// <summary>
    /// Extension method to return an enum value of type T for the given int.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <returns></returns>
    public static T ToEnum<T>(this int value)
    {
        var name = Enum.GetName(typeof(T), value);
        return name.ToEnum<T>();
    }

Question 4

अगर आप का उपयोग बहुत सरल हो सकता है TryParseया Parseऔर ToObjectतरीकों।

public static class EnumHelper
{
    public static  T GetEnumValue<T>(string str) where T : struct, IConvertible
    {
        Type enumType = typeof(T);
        if (!enumType.IsEnum)
        {
            throw new Exception("T must be an Enumeration type.");
        }
        T val;
        return Enum.TryParse<T>(str, true, out val) ? val : default(T);
    }

    public static T GetEnumValue<T>(int intValue) where T : struct, IConvertible
    {
        Type enumType = typeof(T);
        if (!enumType.IsEnum)
        {
            throw new Exception("T must be an Enumeration type.");
        }

        return (T)Enum.ToObject(enumType, intValue);
    }
}

जैसा कि टिप्पणियों में @chrfin द्वारा उल्लेख किया गया है, आप इसे thisपैरामीटर प्रकार से पहले जोड़कर बहुत आसानी से एक विस्तार विधि बना सकते हैं जो कि काम में आ सकती है।

Question 5

स्ट्रिंग द्वारा enum मान प्राप्त करने के लिए C # में विधि है

///
/// Method to get enumeration value from string value.
///
///
///

public T GetEnumValue<T>(string str) where T : struct, IConvertible
{
    if (!typeof(T).IsEnum)
    {
        throw new Exception("T must be an Enumeration type.");
    }
    T val = ((T[])Enum.GetValues(typeof(T)))[0];
    if (!string.IsNullOrEmpty(str))
    {
        foreach (T enumValue in (T[])Enum.GetValues(typeof(T)))
        {
            if (enumValue.ToString().ToUpper().Equals(str.ToUpper()))
            {
                val = enumValue;
                break;
            }
        }
    }

    return val;
}

निम्नलिखित सी # में विधि है जो int द्वारा enum मान प्राप्त करने के लिए है।

///
/// Method to get enumeration value from int value.
///
///
///

public T GetEnumValue<T>(int intValue) where T : struct, IConvertible
{
    if (!typeof(T).IsEnum)
    {
        throw new Exception("T must be an Enumeration type.");
    }
    T val = ((T[])Enum.GetValues(typeof(T)))[0];

    foreach (T enumValue in (T[])Enum.GetValues(typeof(T)))
    {
        if (Convert.ToInt32(enumValue).Equals(intValue))
        {
            val = enumValue;
            break;
        }             
    }
    return val;
}

यदि मेरे पास एक एनम निम्नानुसार है:

public enum TestEnum
{
    Value1 = 1,
    Value2 = 2,
    Value3 = 3
}

तो मैं उपरोक्त विधियों का उपयोग कर सकता हूं

TestEnum reqValue = GetEnumValue<TestEnum>("Value1");  // Output: Value1
TestEnum reqValue2 = GetEnumValue<TestEnum>(2);        // OutPut: Value2

आशा है कि यह मदद करेगा।

Question 6

मुझे लगता है कि आप सामान्य प्रकार की परिभाषा भूल गए:

public T GetEnumValue<T>(int intValue) where T : struct, IConvertible // <T> added

और आप इसे बेहतर कर सकते हैं जैसे कि यह सबसे अधिक विश्वसनीय है:

public static T ToEnum<T>(this string enumValue) : where T : struct, IConvertible
{
    return (T)Enum.Parse(typeof(T), enumValue);
}

तो आप कर सकते हैं:

TestEnum reqValue = "Value1".ToEnum<TestEnum>();

Question 7

कुछ इस तरह की कोशिश करो

  public static TestEnum GetMyEnum(this string title)
        {    
            EnumBookType st;
            Enum.TryParse(title, out st);
            return st;          
         }

तो आप कर सकते हैं

TestEnum en = "Value1".GetMyEnum();

Question 8

SQL डेटाबेस से enum प्राप्त करें जैसे:

SqlDataReader dr = selectCmd.ExecuteReader();
while (dr.Read()) {
   EnumType et = (EnumType)Enum.Parse(typeof(EnumType), dr.GetString(0));
   ....         
}

Question 9

बस यह कोशिश करो

यह एक और तरीका है

public enum CaseOriginCode
{
    Web = 0,
    Email = 1,
    Telefoon = 2
}

public void setCaseOriginCode(string CaseOriginCode)
{
    int caseOriginCode = (int)(CaseOriginCode)Enum.Parse(typeof(CaseOriginCode), CaseOriginCode);
}

Question 10

यहाँ स्ट्रिंग / मान प्राप्त करने के लिए एक उदाहरण है

    public enum Suit
    {
        Spades = 0x10,
        Hearts = 0x11,
        Clubs = 0x12,
        Diamonds = 0x13
    }

    private void print_suit()
    {
        foreach (var _suit in Enum.GetValues(typeof(Suit)))
        {
            int suitValue = (byte)(Suit)Enum.Parse(typeof(Suit), _suit.ToString());
            MessageBox.Show(_suit.ToString() + " value is 0x" + suitValue.ToString("X2"));
        }
    }

    Result of Message Boxes
    Spade value is 0x10
    Hearts value is 0x11
    Clubs value is 0x12
    Diamonds value is 0x13

Question 11

आप ऐसा करने के लिए निम्नलिखित विधि का उपयोग कर सकते हैं:

public static Output GetEnumItem<Output, Input>(Input input)
    {
        //Output type checking...
        if (typeof(Output).BaseType != typeof(Enum))
            throw new Exception("Exception message...");

        //Input type checking: string type
        if (typeof(Input) == typeof(string))
            return (Output)Enum.Parse(typeof(Output), (dynamic)input);

        //Input type checking: Integer type
        if (typeof(Input) == typeof(Int16) ||
            typeof(Input) == typeof(Int32) ||
            typeof(Input) == typeof(Int64))

            return (Output)(dynamic)input;

        throw new Exception("Exception message...");
    }

नोट: यह विधि केवल एक नमूना है और आप इसे सुधार सकते हैं।