සී # හි එනූම් බවට නූලක් පරිවර්තනය කරන්න

C # හි ගණන් කිරීමේ අගයකට නූලක් පරිවර්තනය කිරීමට හොඳම ක්‍රමය කුමක්ද?

ගණනය කිරීමක අගයන් අඩංගු HTML තේරීමේ ටැගයක් මා සතුව ඇත. පිටුව පළ කරන විට, මට අවශ්‍ය වන්නේ අගය (එය නූලක ස්වරූපයෙන් වනු ඇත) සහ එය අනුරූප ගණනය කිරීමේ අගයට පරිවර්තනය කිරීමයි.

පරමාදර්ශී ලෝකයක, මට මේ වගේ දෙයක් කළ හැකිය:

StatusEnum MyStatus = StatusEnum.Parse("Active");

නමුත් එය වලංගු කේතයක් නොවේ.

.NET Core සහ .NET> 4 හි සාමාන්‍ය විග්‍රහ ක්‍රමයක් ඇත :

Enum.TryParse("Active", out StatusEnum myStatus);

මෙයට C # 7 හි නව පේළි outවිචල්‍යයන් ද ඇතුළත් වේ , එබැවින් මෙය උත්සාහ කිරීම-විග්‍රහ කිරීම, පැහැදිලි එනූම් වර්ගයට පරිවර්තනය කිරීම සහ ආරම්භක + myStatusවිචල්‍යය ජනනය කරයි .

ඔබට C # 7 සහ නවතම .NET වෙත ප්‍රවේශය ඇත්නම් මෙය හොඳම ක්‍රමයයි.

මුල් පිළිතුර

.NET හි එය තරමක් කැතයි (4 හෝ ඊට වැඩි):

StatusEnum MyStatus = (StatusEnum) Enum.Parse(typeof(StatusEnum), "Active", true);

මම මෙය සරල කිරීමට නැඹුරු වෙමි:

public static T ParseEnum<T>(string value)
{
    return (T) Enum.Parse(typeof(T), value, true);
}

එවිට මට කළ හැකිය:

StatusEnum MyStatus = EnumUtil.ParseEnum<StatusEnum>("Active");

අදහස් දැක්වීමේදී යෝජනා කර ඇති එක් විකල්පයක් වන්නේ දිගුවක් එක් කිරීමයි, එය ප්‍රමාණවත් තරම් සරල ය:

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

StatusEnum MyStatus = "Active".ToEnum<StatusEnum>();

අවසාන වශයෙන්, නූල විග්‍රහ කළ නොහැකි නම් භාවිතා කිරීමට පෙරනිමි සංඛ්‍යාවක් ලබා ගැනීමට ඔබට අවශ්‍ය විය හැකිය:

public static T ToEnum<T>(this string value, T defaultValue) 
{
    if (string.IsNullOrEmpty(value))
    {
        return defaultValue;
    }

    T result;
    return Enum.TryParse<T>(value, true, out result) ? result : defaultValue;
}

මෙය ඇමතුම ලබා දෙන්නේ:

StatusEnum MyStatus = "Active".ToEnum(StatusEnum.None);

කෙසේ වෙතත්, මම මෙවැනි දීර් extension ක්‍රමයක් එකතු කිරීමට ප්‍රවේශම් වන්නෙමි string(නාම අවකාශ පාලනයක් නොමැතිව) එය stringඑනුම් එකක් තිබේද නැද්ද යන්න පිළිබඳ සෑම අවස්ථාවකම එය දිස්වනු ඇත ( 1234.ToString().ToEnum(StatusEnum.None)එය වලංගු නමුත් විකාරයකි). මයික්‍රොසොෆ්ට් හි මූලික පංති අතිරේක ක්‍රමවේදයන් සමඟ පැටලීමෙන් වැළකී සිටීම වඩාත් සුදුසු වන්නේ විශේෂිත සන්දර්භයන් තුළ පමණක් අදාළ වන අතර එම දීර් ensions කිරීම් මොනවාද යන්න පිළිබඳව ඔබේ සමස්ත සංවර්ධන කණ්ඩායමට මනා අවබෝධයක් නොමැති නම් පමණි.

භාවිතය Enum.TryParse<T>(String, T)(≥ .NET 4.0):

StatusEnum myStatus;
Enum.TryParse("Active", out myStatus);

C # 7.0 හි පරාමිති වර්ගයේ ඉන්ලයින් සමඟ එය තවත් සරල කළ හැකිය :

Enum.TryParse("Active", out StatusEnum myStatus);

Enum.Parse()පරාවර්තනය හරහා එය ක්‍රියාත්මක වන නිසා එහි ක්‍රියාකාරිත්වය භයානක බව සලකන්න . ( Enum.ToStringඅනෙක් පැත්තට යන කාරණය සම්බන්ධයෙන් ද එය එසේම වේ.)

කාර්ය සාධනය-සංවේදී කේතයකින් ඔබට එන්ම්ස් වෙත නූල් පරිවර්තනය කිරීමට අවශ්‍ය නම්, ඔබේ හොඳම ඔට්ටුව වන්නේ Dictionary<String,YourEnum>ආරම්භයේදීම නිර්මාණය කර ඔබේ පරිවර්තනයන් සඳහා එය භාවිතා කිරීමයි.

ඔබ සොයන්නේ Enum.Parse .

SomeEnum enum = (SomeEnum)Enum.Parse(typeof(SomeEnum), "EnumValue");

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

public static T ToEnum<T>(this string value, bool ignoreCase = true)
{
    return (T) Enum.Parse(typeof (T), value, ignoreCase);
}

පහත කේතය මඟින් ඔබට ඒවා ඇමතිය හැකිය (මෙන්න, FilterTypeඑනුම් වර්ගයකි):

FilterType filterType = type.ToEnum<FilterType>();

object Enum.Parse(System.Type enumType, string value, bool ignoreCase);

එබැවින් ඔබට මනෝභාවයක් නම් එනුම් එකක් තිබේ නම් එය මෙසේ පෙනේ:

   enum Mood
   {
      Angry,
      Happy,
      Sad
   } 

   // ...
   Mood m = (Mood) Enum.Parse(typeof(Mood), "Happy", true);
   Console.WriteLine("My mood is: {0}", m.ToString());

පරෙස්සම් වන්න:

enum Example
{
    One = 1,
    Two = 2,
    Three = 3
}

Enum.(Try)Parse() බහුවිධ, කොමා මඟින් වෙන් කරන ලද තර්ක පිළිගෙන ඒවා ද්විමය 'හෝ' සමඟ ඒකාබද්ධ කරයි| . ඔබට මෙය අක්‍රිය කළ නොහැකි අතර මගේ මතය අනුව ඔබට එය කිසි විටෙකත් අවශ්‍ය නොවේ.

var x = Enum.Parse("One,Two"); // x is now Three

පවා නම් Threeඅර්ථ නැත, xතවමත් int අගය ලබා ගත හැකි බව 3. එය ඊටත් වඩා භයානක ය: Enum.Parse () මඟින් ඔබට enum සඳහා පවා අර්ථ දක්වා නැති අගයක් ලබා දිය හැකිය!

මෙම හැසිරීම අවුලුවාලමින්, කැමැත්තෙන් හෝ අකමැත්තෙන් පරිශීලකයින්ගේ ප්‍රතිවිපාක අත්විඳීමට මට අවශ්‍ය නැත.

මීට අමතරව, අනෙක් අය සඳහන් කළ පරිදි, කාර්ය සාධනය විශාල එනූම් සඳහා පරමාදර්ශයට වඩා අඩුය, එනම් හැකි අගයන් සංඛ්‍යාවේ රේඛීය වේ.

මම පහත සඳහන් දේ යෝජනා කරමි.

    public static bool TryParse<T>(string value, out T result)
        where T : struct
    {
        var cacheKey = "Enum_" + typeof(T).FullName;

        // [Use MemoryCache to retrieve or create&store a dictionary for this enum, permanently or temporarily.
        // [Implementation off-topic.]
        var enumDictionary = CacheHelper.GetCacheItem(cacheKey, CreateEnumDictionary<T>, EnumCacheExpiration);

        return enumDictionary.TryGetValue(value.Trim(), out result);
    }

    private static Dictionary<string, T> CreateEnumDictionary<T>()
    {
        return Enum.GetValues(typeof(T))
            .Cast<T>()
            .ToDictionary(value => value.ToString(), value => value, StringComparer.OrdinalIgnoreCase);
    }

Enum.Parse ඔබේ මිතුරා:

StatusEnum MyStatus = (StatusEnum)Enum.Parse(typeof(StatusEnum), "Active");

ව්‍යතිරේකයන් වළක්වා ගැනීම සඳහා පිළිගත් පිළිතුර පෙරනිමි අගයකින් දීර් extend කළ හැකිය:

public static T ParseEnum<T>(string value, T defaultValue) where T : struct
{
    try
    {
        T enumValue;
        if (!Enum.TryParse(value, true, out enumValue))
        {
            return defaultValue;
        }
        return enumValue;
    }
    catch (Exception)
    {
        return defaultValue;
    }
}

එවිට ඔබ එය අමතන්නේ:

StatusEnum MyStatus = EnumUtil.ParseEnum("Active", StatusEnum.None);

පෙරනිමි අගය එනූම් එකක් නොවේ නම්, එනුම්.

වසර ගණනාවකට පසු අපගේ කේතයේ බොහෝ ස්ථානවල මෙම ශ්‍රිතය භාවිතා කිරීමෙන් සමහර විට මෙම ක්‍රියාව සඳහා කාර්ය සාධනය වැය වන තොරතුරු එක් කිරීම හොඳය!

අපට පරිපූර්ණ වලංගු ආදානයක් උපකල්පනය කළ නොහැකි අතර, @ කීත්ගේ පිළිතුරේ මෙම විචලනය සමඟ ගියේය:

public static TEnum ParseEnum<TEnum>(string value) where TEnum : struct
{
    TEnum tmp; 
    if (!Enum.TryParse<TEnum>(value, true, out tmp))
    {
        tmp = new TEnum();
    }
    return tmp;
}

// str.ToEnum<EnumType>()
T static ToEnum<T>(this string str) 
{ 
    return (T) Enum.Parse(typeof(T), str);
}

.NET 4.5 සිට උත්සාහ නොකර / අල්ලා නොගෙන ට්‍රයිපාර්ස් () ක්‍රමයක් නොමැතිව ටෙනම් වෙත විග්‍රහ කරයි

/// <summary>
/// Parses string to TEnum without try/catch and .NET 4.5 TryParse()
/// </summary>
public static bool TryParseToEnum<TEnum>(string probablyEnumAsString_, out TEnum enumValue_) where TEnum : struct
{
    enumValue_ = (TEnum)Enum.GetValues(typeof(TEnum)).GetValue(0);
    if(!Enum.IsDefined(typeof(TEnum), probablyEnumAsString_))
        return false;

    enumValue_ = (TEnum) Enum.Parse(typeof(TEnum), probablyEnumAsString_);
    return true;
}

ට්‍රයිපාර්ස් භාවිතා කරන සුපිරි සරල කේතය:

var value = "Active";

StatusEnum status;
if (!Enum.TryParse<StatusEnum>(value, out status))
    status = StatusEnum.Unknown;

මම දිගු කිරීමේ ක්‍රම විසඳුමට කැමතියි ..

namespace System
{
    public static class StringExtensions
    {

        public static bool TryParseAsEnum<T>(this string value, out T output) where T : struct
        {
            T result;

            var isEnum = Enum.TryParse(value, out result);

            output = isEnum ? result : default(T);

            return isEnum;
        }
    }
}

පරීක්ෂණ සමඟ මගේ ක්‍රියාත්මක කිරීම පහතින්.

using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
using static System.Console;

private enum Countries
    {
        NorthAmerica,
        Europe,
        Rusia,
        Brasil,
        China,
        Asia,
        Australia
    }

   [TestMethod]
        public void StringExtensions_On_TryParseAsEnum()
        {
            var countryName = "Rusia";

            Countries country;
            var isCountry = countryName.TryParseAsEnum(out country);

            WriteLine(country);

            IsTrue(isCountry);
            AreEqual(Countries.Rusia, country);

            countryName = "Don't exist";

            isCountry = countryName.TryParseAsEnum(out country);

            WriteLine(country);

            IsFalse(isCountry);
            AreEqual(Countries.NorthAmerica, country); // the 1rst one in the enumeration
        }

මෙය එකතු කළේ කවදාදැයි නිශ්චිතවම කිව නොහැකි නමුත් එනුම් පන්තියේ දැන් a

Parse<TEnum>(stringValue)

ප්‍රශ්නයේ උදාහරණය සමඟ එසේ භාවිතා කරයි:

var MyStatus = Enum.Parse<StatusEnum >("Active")

හෝ ආවරණ නොසලකා හැරීම:

var MyStatus = Enum.Parse<StatusEnum >("active", true)

මෙය භාවිතා කරන දිරාපත් වූ ක්‍රම මෙන්න:

    [NullableContext(0)]
    public static TEnum Parse<TEnum>([Nullable(1)] string value) where TEnum : struct
    {
      return Enum.Parse<TEnum>(value, false);
    }

    [NullableContext(0)]
    public static TEnum Parse<TEnum>([Nullable(1)] string value, bool ignoreCase) where TEnum : struct
    {
      TEnum result;
      Enum.TryParse<TEnum>(value, ignoreCase, true, out result);
      return result;
    }

public static T ParseEnum<T>(string value)            //function declaration  
{
    return (T) Enum.Parse(typeof(T), value);
}

Importance imp = EnumUtil.ParseEnum<Importance>("Active");   //function call

================== සම්පූර්ණ වැඩසටහනක් =================

using System;

class Program
{
    enum PetType
    {
    None,
    Cat = 1,
    Dog = 2
    }

    static void Main()
    {

    // Possible user input:
    string value = "Dog";

    // Try to convert the string to an enum:
    PetType pet = (PetType)Enum.Parse(typeof(PetType), value);

    // See if the conversion succeeded:
    if (pet == PetType.Dog)
    {
        Console.WriteLine("Equals dog.");
    }
    }
}
-------------
Output

Equals dog.

මම පංතිය භාවිතා කළෙමි (විග්‍රහ කිරීම සහ කාර්ය සාධනය වැඩි දියුණු කිරීම් සමඟ තදින් ටයිප් කළ එනුම් සංස්කරණය). මම එය GitHub හි සොයා ගත් අතර එය .NET 3.5 සඳහාද ක්‍රියා කළ යුතුය. එය ශබ්ද කෝෂයක් බෆර් කරන බැවින් එයට යම් මතක ප්‍රමාණයක් ඇත.

StatusEnum MyStatus = Enum<StatusEnum>.Parse("Active");

බ්ලොග් පෝස්ට් යනු එනුම්ස් - වඩා හොඳ සින්ටැක්ස්, වැඩිදියුණු කළ ක්‍රියාකාරිත්වය සහ නෙට් 3.5 හි ට්‍රයිපාර්ස් ය .

සහ කේතය: https://github.com/damieng/DamienGKit/blob/master/CSharp/DamienG.Library/System/EnumT.cs

කාර්ය සාධනය සඳහා මෙය උදව් විය හැකිය:

    private static Dictionary<Type, Dictionary<string, object>> dicEnum = new Dictionary<Type, Dictionary<string, object>>();
    public static T ToEnum<T>(this string value, T defaultValue)
    {
        var t = typeof(T);
        Dictionary<string, object> dic;
        if (!dicEnum.ContainsKey(t))
        {
            dic = new Dictionary<string, object>();
            dicEnum.Add(t, dic);
            foreach (var en in Enum.GetValues(t))
                dic.Add(en.ToString(), en);
        }
        else
            dic = dicEnum[t];
        if (!dic.ContainsKey(value))
            return defaultValue;
        else
            return (T)dic[value];
    }

මෙහි දී EnumMember වටිනාකමක් ඇති enum අගයන් පිළිබඳ නඩුව නොසලකන බව මට පෙනී ගියේය. ඉතින් මෙන්න අපි යමු:

using System.Runtime.Serialization;

public static TEnum ToEnum<TEnum>(this string value, TEnum defaultValue) where TEnum : struct
{
    if (string.IsNullOrEmpty(value))
    {
        return defaultValue;
    }

    TEnum result;
    var enumType = typeof(TEnum);
    foreach (var enumName in Enum.GetNames(enumType))
    {
        var fieldInfo = enumType.GetField(enumName);
        var enumMemberAttribute = ((EnumMemberAttribute[]) fieldInfo.GetCustomAttributes(typeof(EnumMemberAttribute), true)).FirstOrDefault();
        if (enumMemberAttribute?.Value == value)
        {
            return Enum.TryParse(enumName, true, out result) ? result : defaultValue;
        }
    }

    return Enum.TryParse(value, true, out result) ? result : defaultValue;
}

සහ එම එනුම් සඳහා උදාහරණය:

public enum OracleInstanceStatus
{
    Unknown = -1,
    Started = 1,
    Mounted = 2,
    Open = 3,
    [EnumMember(Value = "OPEN MIGRATE")]
    OpenMigrate = 4
}

Enum වෙතින් වස්තු අගය ලබා ගැනීම සඳහා ඔබ Enum.Parse භාවිතා කළ යුතුය, ඉන්පසු ඔබට වස්තු අගය නිශ්චිත enum අගයට වෙනස් කළ යුතුය. Convert.ChangeType භාවිතා කිරීමෙන් enum වටිනාකමට වාත්තු කිරීම කළ හැකිය. කරුණාකර පහත කේත ස්නිපටය දෙස බලන්න

public T ConvertStringValueToEnum<T>(string valueToParse){
    return Convert.ChangeType(Enum.Parse(typeof(T), valueToParse, true), typeof(T));
}

මෙම නියැදිය උත්සාහ කරන්න:

 public static T GetEnum<T>(string model)
    {
        var newModel = GetStringForEnum(model);

        if (!Enum.IsDefined(typeof(T), newModel))
        {
            return (T)Enum.Parse(typeof(T), "None", true);
        }

        return (T)Enum.Parse(typeof(T), newModel.Result, true);
    }

    private static Task<string> GetStringForEnum(string model)
    {
        return Task.Run(() =>
        {
            Regex rgx = new Regex("[^a-zA-Z0-9 -]");
            var nonAlphanumericData = rgx.Matches(model);
            if (nonAlphanumericData.Count < 1)
            {
                return model;
            }
            foreach (var item in nonAlphanumericData)
            {
                model = model.Replace((string)item, "");
            }
            return model;
        });
    }

මෙම නියැදිය තුළ ඔබට සෑම නූලක්ම යැවිය හැකි අතර ඔබේ ඒවා සකසන්න Enum. ඔබේ නම් Enumවිය දත්ත ඔබ අවශ්ය බව, ඔබගේ ලෙස නැවත Enumවර්ගය.

දේපල නම ඔබට එය හැඳින්වීමට අවශ්‍ය දෙයට වඩා වෙනස් නම් (එනම් භාෂා වෙනස්කම්) ඔබට මේ ආකාරයට කළ හැකිය:

MyType.cs

using System;
using System.Runtime.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

[JsonConverter(typeof(StringEnumConverter))]
public enum MyType
{
    [EnumMember(Value = "person")]
    Person,
    [EnumMember(Value = "annan_deltagare")]
    OtherPerson,
    [EnumMember(Value = "regel")]
    Rule,
}

EnumExtensions.cs

using System;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

public static class EnumExtensions
{
    public static TEnum ToEnum<TEnum>(this string value) where TEnum : Enum
    {
        var jsonString = $"'{value.ToLower()}'";
        return JsonConvert.DeserializeObject<TEnum>(jsonString, new StringEnumConverter());
    }

    public static bool EqualsTo<TEnum>(this string strA, TEnum enumB) where TEnum : Enum
    {
        TEnum enumA;
        try
        {
            enumA = strA.ToEnum<TEnum>();
        }
        catch
        {
            return false;
        }
        return enumA.Equals(enumB);
    }
}

Program.cs

public class Program
{
    static public void Main(String[] args) 
    { 
        var myString = "annan_deltagare";
        var myType = myString.ToEnum<MyType>();
        var isEqual = myString.EqualsTo(MyType.OtherPerson);
        //Output: true
    }     
}

        <Extension()>
    Public Function ToEnum(Of TEnum)(ByVal value As String, ByVal defaultValue As TEnum) As TEnum
        If String.IsNullOrEmpty(value) Then
            Return defaultValue
        End If

        Return [Enum].Parse(GetType(TEnum), value, True)
    End Function

public TEnum ToEnum<TEnum>(this string value, TEnum defaultValue){
if (string.IsNullOrEmpty(value))
    return defaultValue;

return Enum.Parse(typeof(TEnum), value, true);}

ඔබට ශුන්‍ය හෝ හිස් විට පෙරනිමි අගයක් භාවිතා කිරීමට අවශ්‍ය නම් (උදා: වින්‍යාස ගොනුවෙන් ලබා ගැනීමේදී සහ අගය නොපවතින විට) සහ නූල හෝ අංකය කිසිදු එනුම් අගයකට නොගැලපෙන විට ව්‍යතිරේකයක් දමන්න. ටිමෝගේ පිළිතුරෙන් ප්‍රවේශම් වන්න ( https://stackoverflow.com/a/34267134/2454604 ).

    public static T ParseEnum<T>(this string s, T defaultValue, bool ignoreCase = false) 
        where T : struct, IComparable, IConvertible, IFormattable//If C# >=7.3: struct, System.Enum 
    {
        if ((s?.Length ?? 0) == 0)
        {
            return defaultValue;
        }

        var valid = Enum.TryParse<T>(s, ignoreCase, out T res);

        if (!valid || !Enum.IsDefined(typeof(T), res))
        {
            throw new InvalidOperationException(
                $"'{s}' is not a valid value of enum '{typeof(T).FullName}'!");
        }
        return res;
    }