C # में एन्यूमरेशन वैल्यू में स्ट्रिंग को कन्वर्ट करने का सबसे अच्छा तरीका क्या है?
मेरे पास एक HTML चुनिंदा टैग है जिसमें एक एन्यूमरेशन का मान है। जब पृष्ठ पोस्ट किया जाता है, तो मैं मूल्य (जो एक स्ट्रिंग के रूप में होगा) को चुनना चाहता हूं और इसे एन्हांसमेंट मान में परिवर्तित करता हूं।
एक आदर्श दुनिया में, मैं कुछ ऐसा कर सकता था:
StatusEnum MyStatus = StatusEnum.Parse("Active");लेकिन यह एक वैध कोड नहीं है।
जवाबों:
.NET कोर और .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);हालाँकि, मैं इस तरह से string(बिना नाम पते के नियंत्रण के) के रूप में एक विस्तार विधि जोड़ने में सावधान रहूंगा, यह सभी उदाहरणों पर दिखाई देगा stringकि क्या वे एक एनम पकड़ते हैं या नहीं (इसलिए 1234.ToString().ToEnum(StatusEnum.None)यह मान्य लेकिन निरर्थक होगा)। Microsoft के मुख्य वर्गों को अतिरिक्त तरीकों से अव्यवस्थित करने से बचने के लिए अक्सर सबसे अच्छा होता है जो केवल बहुत विशिष्ट संदर्भों में लागू होते हैं जब तक कि आपके संपूर्ण विकास दल को उन एक्सटेंशनों की बहुत अच्छी समझ न हो।
उपयोग Enum.TryParse<T>(String, T)(≥ .NET 4.0):
StatusEnum myStatus;
Enum.TryParse("Active", out myStatus);
इसे C # 7.0 के पैरामीटर टाइप इनलाइनिंग के साथ और भी सरल बनाया जा सकता है :
Enum.TryParse("Active", out StatusEnum myStatus);Parseरूपांतरण के साथ जो कुछ गलत हुआ, उसके लिए व्याख्यात्मक अपवाद फेंकता है (मान nullखाली था , या कोई समान एनम स्थिरांक), जो कि TryParse's बूलियन रिटर्न वैल्यू (जो ठोस त्रुटि को
var result = Enum.TryParse<System.DayOfWeek>("55", out var parsedEnum);
ध्यान दें कि प्रदर्शन 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>();सावधान:
enum Example
{
One = 1,
Two = 2,
Three = 3
}Enum.(Try)Parse() एकाधिक, अल्पविराम से अलग किए गए तर्कों को स्वीकार करता है, और उन्हें बाइनरी या 'के साथ जोड़ता है| । आप इसे अक्षम नहीं कर सकते और मेरी राय में आप इसे कभी नहीं चाहते।
var x = Enum.Parse("One,Two"); // x is now Threeयहां तक कि अगर Threeपरिभाषित नहीं किया गया था, xतब भी उन्हें अंतर मूल्य मिलेगा 3। यह और भी बुरा है: Enum.Parse () आपको एक मान दे सकता है जो कि एनम के लिए भी परिभाषित नहीं है!
मैं स्वेच्छा से या अनिच्छा से, इस व्यवहार को ट्रिगर करते हुए, उपयोगकर्ताओं के परिणामों का अनुभव नहीं करना चाहता।
इसके अतिरिक्त, जैसा कि दूसरों ने उल्लेख किया है, प्रदर्शन बड़ी संख्याओं के लिए आदर्श से कम है, अर्थात् संभावित मूल्यों की संख्या में रैखिक।
मैं निम्नलिखित सुझाव देता हूं:
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.(Try)Parse accepts multiple, comma-separated arguments, and combines them with binary 'or'। इसका मतलब है कि आप अपने एनम मूल्यों को 2 की शक्तियों के रूप में स्थापित कर सकते हैं और आपके पास कई बूलियन झंडे, उदाहरण के लिए पार्स करने का एक बहुत आसान तरीका है। "UseSSL, NoRetries, समन्वयन"। वास्तव में यह शायद यही है कि इसके लिए डिज़ाइन किया गया था।
Enum.Parse आपका दोस्त है:
StatusEnum MyStatus = (StatusEnum)Enum.Parse(typeof(StatusEnum), "Active");अपवादों से बचने के लिए आप डिफ़ॉल्ट मान के साथ स्वीकृत उत्तर का विस्तार कर सकते हैं:
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);यदि डिफ़ॉल्ट मान Enum नहीं है तो Enum.TryParse विफल हो जाएगा और एक अपवाद फेंक देगा जो पकड़ा गया है।
कई स्थानों पर हमारे कोड में इस फ़ंक्शन का उपयोग करने के वर्षों के बाद, शायद यह जानकारी जोड़ना अच्छा है कि इस ऑपरेशन में प्रदर्शन की लागत है!
defaultValueऔर विधि वापसी प्रकार दोनों प्रकार के हैं T। यदि प्रकार भिन्न हैं, तो आपको एक संकलन समय त्रुटि प्राप्त होगी: "ConsoleApp1.Size 'से' ConsoleApp1.Color 'में परिवर्तित नहीं किया जा सकता है" या आपके जो भी प्रकार हैं।
// 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;
}TryParse का उपयोग करके सुपर सरल कोड:
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
}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.मैंने क्लास (दृढ़ता से टाइप किए गए संस्करण और पार्सिंग और प्रदर्शन में सुधार के साथ Enum) का उपयोग किया। मुझे यह GitHub पर मिला, और इसे .NET 3.5 के लिए भी काम करना चाहिए। यह कुछ स्मृति उपरि है क्योंकि यह एक शब्दकोश बफ़र करता है।
StatusEnum MyStatus = Enum<StatusEnum>.Parse("Active");ब्लॉगपोस्ट Enums है - बेहतर सिंटैक्स, बेहतर प्रदर्शन और NET 3.5 में TryParse ।
और कोड: 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 का उपयोग करके किया जा सकता है। कृपया निम्नलिखित स्निपेट पर एक नज़र डालें
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प्रकार के रूप में वापस करें ।
newModelप्रत्येक पंक्ति पर ओवरराइट कर रहे हैं , इसलिए यदि इसमें डैश हैं, तो इसे प्रतिस्थापित नहीं किया जाएगा। इसके अलावा, आपको यह जांचने की ज़रूरत नहीं है कि क्या स्ट्रिंग में कुछ भी है, आप बस Replaceवैसे भी कॉल कर सकते हैं :var newModel = model.Replace("-", "").Replace(" ", "");
निश्चित नहीं है कि यह कब जोड़ा गया था, लेकिन एनम वर्ग पर अब ए है
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;
}यदि संपत्ति का नाम उस चीज़ से अलग है जिसे आप इसे (यानी भाषा अंतर) कहना चाहते हैं, तो आप ऐसा कर सकते हैं:
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
}
}