এনুম মানটির জন্য কীভাবে ট্রাইপার্স করবেন?

Question 1

আমি একটি ফাংশন লিখতে চাই যা একটি এর সম্ভাব্য মানের বিপরীতে প্রদত্ত মানকে (স্ট্রিং হিসাবে পাস করা) বৈধতা দিতে পারে enum। ম্যাচের ক্ষেত্রে, এটি এনাম উদাহরণটি ফিরিয়ে আনতে হবে; অন্যথায়, এটি একটি ডিফল্ট মান প্রদান করা উচিত।

ফাংশনটি অভ্যন্তরীণভাবে try/ ব্যবহার করতে পারে না catch, যা ব্যবহার বাদ দেয় Enum.Parseযা কোনও অবৈধ যুক্তি দেওয়া হলে ব্যতিক্রম ছুঁড়ে দেয়।

এটি TryParseবাস্তবায়নের জন্য আমি কোনও ফাংশনের লাইনে কিছু ব্যবহার করতে চাই :

public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue)
{
   object enumValue;
   if (!TryParse (typeof (TEnum), strEnumValue, out enumValue))
   {
       return defaultValue;
   }
   return (TEnum) enumValue;
}

Question 2

অন্যরা যেমন বলেছে, আপনাকে নিজের প্রয়োগ করতে হবে TryParse। সাইমন মাউরিয়ার একটি সম্পূর্ণ বাস্তবায়ন সরবরাহ করছে যা সবকিছুর যত্ন নেয়।

আপনি যদি বিটফিল্ড এনামগুলি (অর্থাত্ পতাকাগুলি) ব্যবহার করছেন তবে আপনাকে এমন দুটি স্ট্র্যামও পরিচালনা করতে হবে "MyEnum.Val1|MyEnum.Val2"যা দুটি এনাম মানগুলির সংমিশ্রণ। আপনি যদি কেবল Enum.IsDefinedএই স্ট্রিং দিয়ে কল করেন তবে Enum.Parseএটি সঠিকভাবে পরিচালনা করলেও এটি মিথ্যা ফিরে আসবে ।

হালনাগাদ

মন্তব্যগুলিতে লিসা এবং খ্রিস্টান দ্বারা উল্লিখিত হিসাবে, Enum.TryParseএখন নেট # 4 এবং আরও জন্য সি # তে উপলব্ধ।

এমএসডিএন ডক্স

Question 3

এনাম.আইএসডিফাইনড জিনিসগুলি সম্পন্ন করবে। এটি ট্রাই পার্সির মতো দক্ষ নাও হতে পারে, তবে এটি ব্যতিক্রম পরিচালনা না করে কাজ করবে।

public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue)
{
    if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
        return defaultValue;

    return (TEnum)Enum.Parse(typeof(TEnum), strEnumValue);
}

মূল্যবান লক্ষ্য করা যায়: TryParse.NET 4.0 এ একটি পদ্ধতি যুক্ত করা হয়েছিল।

Question 4

এখানে একটি কাস্টম বাস্তবায়ন EnumTryParse । অন্যান্য সাধারণ বাস্তবায়নের বিপরীতে, এটি Flagsগুণকে চিহ্নিত করা এনুমকেও সমর্থন করে ।

    /// <summary>
    /// Converts the string representation of an enum to its Enum equivalent value. A return value indicates whether the operation succeeded.
    /// This method does not rely on Enum.Parse and therefore will never raise any first or second chance exception.
    /// </summary>
    /// <param name="type">The enum target type. May not be null.</param>
    /// <param name="input">The input text. May be null.</param>
    /// <param name="value">When this method returns, contains Enum equivalent value to the enum contained in input, if the conversion succeeded.</param>
    /// <returns>
    /// true if s was converted successfully; otherwise, false.
    /// </returns>
    public static bool EnumTryParse(Type type, string input, out object value)
    {
        if (type == null)
            throw new ArgumentNullException("type");

        if (!type.IsEnum)
            throw new ArgumentException(null, "type");

        if (input == null)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        input = input.Trim();
        if (input.Length == 0)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        string[] names = Enum.GetNames(type);
        if (names.Length == 0)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        Type underlyingType = Enum.GetUnderlyingType(type);
        Array values = Enum.GetValues(type);
        // some enums like System.CodeDom.MemberAttributes *are* flags but are not declared with Flags...
        if ((!type.IsDefined(typeof(FlagsAttribute), true)) && (input.IndexOfAny(_enumSeperators) < 0))
            return EnumToObject(type, underlyingType, names, values, input, out value);

        // multi value enum
        string[] tokens = input.Split(_enumSeperators, StringSplitOptions.RemoveEmptyEntries);
        if (tokens.Length == 0)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        ulong ul = 0;
        foreach (string tok in tokens)
        {
            string token = tok.Trim(); // NOTE: we don't consider empty tokens as errors
            if (token.Length == 0)
                continue;

            object tokenValue;
            if (!EnumToObject(type, underlyingType, names, values, token, out tokenValue))
            {
                value = Activator.CreateInstance(type);
                return false;
            }

            ulong tokenUl;
            switch (Convert.GetTypeCode(tokenValue))
            {
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.SByte:
                    tokenUl = (ulong)Convert.ToInt64(tokenValue, CultureInfo.InvariantCulture);
                    break;

                //case TypeCode.Byte:
                //case TypeCode.UInt16:
                //case TypeCode.UInt32:
                //case TypeCode.UInt64:
                default:
                    tokenUl = Convert.ToUInt64(tokenValue, CultureInfo.InvariantCulture);
                    break;
            }

            ul |= tokenUl;
        }
        value = Enum.ToObject(type, ul);
        return true;
    }

    private static char[] _enumSeperators = new char[] { ',', ';', '+', '|', ' ' };

    private static object EnumToObject(Type underlyingType, string input)
    {
        if (underlyingType == typeof(int))
        {
            int s;
            if (int.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(uint))
        {
            uint s;
            if (uint.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(ulong))
        {
            ulong s;
            if (ulong.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(long))
        {
            long s;
            if (long.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(short))
        {
            short s;
            if (short.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(ushort))
        {
            ushort s;
            if (ushort.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(byte))
        {
            byte s;
            if (byte.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(sbyte))
        {
            sbyte s;
            if (sbyte.TryParse(input, out s))
                return s;
        }

        return null;
    }

    private static bool EnumToObject(Type type, Type underlyingType, string[] names, Array values, string input, out object value)
    {
        for (int i = 0; i < names.Length; i++)
        {
            if (string.Compare(names[i], input, StringComparison.OrdinalIgnoreCase) == 0)
            {
                value = values.GetValue(i);
                return true;
            }
        }

        if ((char.IsDigit(input[0]) || (input[0] == '-')) || (input[0] == '+'))
        {
            object obj = EnumToObject(underlyingType, input);
            if (obj == null)
            {
                value = Activator.CreateInstance(type);
                return false;
            }
            value = obj;
            return true;
        }

        value = Activator.CreateInstance(type);
        return false;
    }

Question 5

শেষ অবধি আপনাকে এটিকে চারপাশে বাস্তবায়ন করতে হবে Enum.GetNames:

public bool TryParseEnum<T>(string str, bool caseSensitive, out T value) where T : struct {
    // Can't make this a type constraint...
    if (!typeof(T).IsEnum) {
        throw new ArgumentException("Type parameter must be an enum");
    }
    var names = Enum.GetNames(typeof(T));
    value = (Enum.GetValues(typeof(T)) as T[])[0];  // For want of a better default
    foreach (var name in names) {
        if (String.Equals(name, str, caseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase)) {
            value = (T)Enum.Parse(typeof(T), name);
            return true;
        }
    }
    return false;
}

অতিরিক্ত নোট:

Enum.TryParse। নেট 4 এ অন্তর্ভুক্ত করা হয়েছে এখানে দেখুন http://msdn.microsoft.com/library/dd991876(VS.100).aspx
আর একটি পদ্ধতি Enum.Parseহ'ল ব্যর্থ হলে নিক্ষেপ করা ব্যতিক্রমটি সরাসরি মুড়ে ফেলা হবে। কোনও ম্যাচ পাওয়া গেলে এটি আরও দ্রুত হতে পারে তবে এটি যদি না হয় তবে ধীর গতির হতে পারে। আপনি যে ডেটা প্রক্রিয়া করছেন তার উপর নির্ভর করে নেট উন্নতি হতে পারে বা নাও হতে পারে।

সম্পাদনা করুন: শুধু এই একটি ভালভাবে কার্যকর, যা প্রয়োজনীয় তথ্য ক্যাশে দেখা গেছে: http://damieng.com/blog/2010/10/17/enums-better-syntax-improved-performance-and-tryparse-in-net- 3-5

Question 6

.NET 4.5 এর ভিত্তিতে

নীচে নমুনা কোড

using System;

enum Importance
{
    None,
    Low,
    Medium,
    Critical
}

class Program
{
    static void Main()
    {
    // The input value.
    string value = "Medium";

    // An unitialized variable.
    Importance importance;

    // Call Enum.TryParse method.
    if (Enum.TryParse(value, out importance))
    {
        // We now have an enum type.
        Console.WriteLine(importance == Importance.Medium);
    }
    }
}

তথ্যসূত্র: http://www.dotnetperls.com/enum-parse

Question 7

আমার একটি অপ্টিমাইজড বাস্তবায়ন রয়েছে যা আপনি আনকন্সট্রেন্ডডমেলোডি ব্যবহার করতে পারেন । কার্যকরভাবে এটি কেবল নামের তালিকাই ক্যাশে করছে তবে এটি দুর্দান্ত, দৃ strongly়ভাবে টাইপ করা, সাধারণভাবে সীমাবদ্ধ উপায়ে এটি করছে :)

Question 8

enum EnumStatus
{
    NAO_INFORMADO = 0,
    ENCONTRADO = 1,
    BLOQUEADA_PELO_ENTREGADOR = 2,
    DISPOSITIVO_DESABILITADO = 3,
    ERRO_INTERNO = 4,
    AGARDANDO = 5
}

...

if (Enum.TryParse<EnumStatus>(item.status, out status)) {

}

Question 9

Enum.TryParse বাক্সটির বাইরে এখন নেই। এটি কানেক্টে অনুরোধ করা হয়েছে ( এখনও কোনও এনাম। ট্রাইপার্স নয় ) এবং নেট নেট ৩.৫ এর পরে পরবর্তী কাঠামোর মধ্যে সম্ভাব্য অন্তর্ভুক্তির ইঙ্গিত দিয়ে একটি প্রতিক্রিয়া পেয়েছে। আপনাকে আপাতত প্রস্তাবিত কাজের ক্ষেত্রগুলি প্রয়োগ করতে হবে।

Question 10

ব্যতিক্রম হ্যান্ডলিং এড়ানোর একমাত্র উপায় হ'ল নামকরণ () পদ্ধতিটি ব্যবহার করা এবং আমরা সকলেই জানি যে সাধারণ প্রয়োগের যুক্তির জন্য ব্যতিক্রমগুলি অপব্যবহার করা উচিত নয় :)

Question 11

গতিশীলভাবে উত্পন্ন ফাংশন / অভিধানের ক্যাচিং কি অনুমোদিত?

যেহেতু আপনি সময়ের আগে এনামের ধরণটি জানেন না (প্রদর্শিত হবে), তাই প্রথম মৃত্যুদন্ড কার্যকররূপে পরবর্তী মৃত্যুদণ্ড কার্যকর করতে পারে এমন কিছু তৈরি করতে পারে।

আপনি এমনকি এনাম.গেটনামের ফলাফলকে ক্যাশে করতে পারেন ()

আপনি কি সিপিইউ বা মেমোরির জন্য অনুকূলিতকরণের চেষ্টা করছেন? আপনার কি সত্যিই দরকার?

Question 12

যেমন অন্যরা ইতিমধ্যে বলেছে, আপনি চেষ্টা ও ক্যাচ ব্যবহার না করেন, আপনার আইসডিফাইন্ড বা গেটনাম ব্যবহার করা দরকার ... এখানে কয়েকটি নমুনা দেওয়া হয়েছে ... সেগুলি মূলত সমস্ত একই, প্রথমটি নালযোগ্য এনামগুলি পরিচালনা করে। আমি দ্বিতীয়টিকে পছন্দ করি কারণ এটি স্ট্রিংগুলিতে এক্সটেনশন, এনামস নয় ... তবে আপনি নিজের ইচ্ছে মতো মিশাতে পারেন!

www.objectreferences.net/post/Enum-TryParse- এক্সটেনশন- মেথড.এএসপিএক্স
ফ্ল্যাটলাইনারডো.স্পেসেস.লাইভ.com/blog/cns !17124D03A9A052B0!605.entry
মিরোনাব্রামসন / ব্লগ / পোস্ট / ২০০৮/০৩/২০১n- অন্যান্য-রূপান্তর- এর জন্য - মিসিং -মোথড- এনিম ট্রাই পার্স.এএসপিএক্স
lazyloading.blogspot.com/2008/04/enumtryparse-with-net-35-existance.html

Question 13

ট্রাইপার্স নেই কারণ এনামের ধরণ রানটাইম পর্যন্ত জানা যায়নি। একটি ট্রিপ পার্স যা একই পদ্ধতি অনুসরণ করে যেমন তারিখ বলে ry

আমি এই জাতীয় কিছু করার পরামর্শ দিচ্ছি:

//1 line call to get value
MyEnums enumValue = (Sections)EnumValue(typeof(Sections), myEnumTextValue, MyEnums.SomeEnumDefault);

//Put this somewhere where you can reuse
public static object EnumValue(System.Type enumType, string value, object NotDefinedReplacement)
{
    if (Enum.IsDefined(enumType, value)) {
        return Enum.Parse(enumType, value);
    } else {
        return Enum.Parse(enumType, NotDefinedReplacement);
    }
}

Question 14

এনাম ক্লাস (স্ট্রাক্ট?) নিজেই দেখুন। এটিতে একটি পার্স পদ্ধতি আছে তবে আমি ট্রাইপার্স সম্পর্কে নিশ্চিত নই।

Question 15

এই পদ্ধতিটি এক ধরণের এনামকে রূপান্তর করবে:

  public static TEnum ToEnum<TEnum>(object EnumValue, TEnum defaultValue)
    {
        if (!Enum.IsDefined(typeof(TEnum), EnumValue))
        {
            Type enumType = Enum.GetUnderlyingType(typeof(TEnum));
            if ( EnumValue.GetType() == enumType )
            {
                string name = Enum.GetName(typeof(HLink.ViewModels.ClaimHeaderViewModel.ClaimStatus), EnumValue);
                if( name != null)
                    return (TEnum)Enum.Parse(typeof(TEnum), name);
                return defaultValue;
            }
        }
        return (TEnum)Enum.Parse(typeof(TEnum), EnumValue.ToString());
    }

এটি অন্তর্নিহিত প্রকারটি পরীক্ষা করে এবং পার্স করার জন্য এর বিরুদ্ধে নামটি পায়। যদি সবকিছু ব্যর্থ হয় তবে এটি ডিফল্ট মান ফিরে আসবে।