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.")
}
एक इंट से:
YourEnum foo = (YourEnum)yourInt;अपडेट करें:
नंबर से भी आप कर सकते हैं
YourEnum foo = (YourEnum)Enum.ToObject(typeof(YourEnum) , yourInt);var result = Enum.TryParse(yourString, out yourEnum)आजकल का उपयोग करना चाहिए (और यदि रूपांतरण विफल हो गया है, तो यह निर्धारित करने के लिए परिणाम की जांच करें)।
Enum.Parseएक trueपैरामीटर मान जोड़कर केस-असंवेदनशील होना भी संभव है :YourEnum foo = (YourEnum) Enum.Parse(typeof(YourEnum), yourString, true);
बस इसे डालें:
MyEnum e = (MyEnum)3;यदि आप Enum.IsDefined का उपयोग कर रहे हैं, तो आप यह देख सकते हैं :
if (Enum.IsDefined(typeof(MyEnum), 3)) { ... }IsDefinedइनपुट मानों की जाँच करने के लिए, आप अपने आप को बाद में नए enum मानों को जोड़ने लोग जो एक से होकर गुजरेगा के प्रति असुरक्षित हो IsDefinedनए के बाद से चेक ( मूल्य नए कोड में मौजूद है), लेकिन जो आपके द्वारा लिखे गए मूल कोड के साथ काम नहीं कर सकता है। इसलिए यह आपके कोड को संभालने में सक्षम होने वाले एनम मूल्यों को स्पष्ट रूप से निर्दिष्ट करने के लिए सुरक्षित है।
वैकल्पिक रूप से, एक-लाइनर के बजाय एक एक्सटेंशन विधि का उपयोग करें:
public static T ToEnum<T>(this string enumString)
{
return (T) Enum.Parse(typeof (T), enumString);
}उपयोग:
Color colorEnum = "Red".ToEnum<Color>();या
string color = "Red";
var colorEnum = color.ToEnum<Color>();System.Stringनामस्थान प्रदूषण की तरह प्रतीत होती है
मुझे लगता है कि एक पूर्ण उत्तर प्राप्त करने के लिए, लोगों को यह जानना होगा कि एनईएम .NET में आंतरिक रूप से कैसे काम करता है।
कितना रद्दी निर्माण कार्य है
.NET में एनम एक ऐसी संरचना है जो मानों (फ़ील्ड्स) के एक सेट को मूल प्रकार (डिफ़ॉल्ट है int) को मैप करती है । हालाँकि, आप वास्तव में अभिन्न प्रकार का चयन कर सकते हैं जो आपके एनम मैप करता है:
public enum Foo : shortइस मामले में एनम को shortडेटा प्रकार में मैप किया जाता है , जिसका अर्थ है कि इसे एक संक्षिप्त रूप में मेमोरी में संग्रहीत किया जाएगा और जब आप इसे डालते हैं और इसका उपयोग करते हैं तो शॉर्ट के रूप में व्यवहार करेंगे।
यदि आप इसे IL के दृष्टिकोण से देखते हैं, तो (सामान्य, int) एनम इस तरह दिखता है:
.class public auto ansi serializable sealed BarFlag extends System.Enum
{
.custom instance void System.FlagsAttribute::.ctor()
.custom instance void ComVisibleAttribute::.ctor(bool) = { bool(true) }
.field public static literal valuetype BarFlag AllFlags = int32(0x3fff)
.field public static literal valuetype BarFlag Foo1 = int32(1)
.field public static literal valuetype BarFlag Foo2 = int32(0x2000)
// and so on for all flags or enum values
.field public specialname rtspecialname int32 value__
}यहां आपका ध्यान क्या जाना चाहिए कि value__एनम मूल्यों से अलग संग्रहीत है। Fooऊपर के एनम के मामले में , का प्रकार value__int16 है। इसका मूल रूप से मतलब है कि आप एक एनम में जो भी स्टोर कर सकते हैं, जब तक कि प्रकार मैच नहीं करते हैं ।
इस बिंदु पर मैं यह बताना चाहता हूं कि System.Enumयह एक मूल्य प्रकार है, जिसका मूल अर्थ है कि BarFlagस्मृति में 4 बाइट्स Fooहोंगे और 2 तक ले जाएंगे - जैसे अंतर्निहित प्रकार का आकार (यह वास्तव में उससे अधिक जटिल है, लेकिन हे ...)।
उत्तर
इसलिए, यदि आपके पास एक पूर्णांक है जिसे आप एक एनम में मैप करना चाहते हैं, तो रनटाइम को केवल 2 चीजें करनी हैं: 4 बाइट्स कॉपी करें और इसे कुछ और नाम दें (एनम का नाम)। प्रतिलिपि बनाना निहित है क्योंकि डेटा को मूल्य प्रकार के रूप में संग्रहीत किया जाता है - इसका मूल रूप से अर्थ है कि यदि आप अप्रबंधित कोड का उपयोग करते हैं, तो आप डेटा की प्रतिलिपि किए बिना केवल एनम और पूर्णांक को इंटरचेंज कर सकते हैं।
इसे सुरक्षित बनाने के लिए, मुझे लगता है कि यह जानना सबसे अच्छा अभ्यास है कि अंतर्निहित प्रकार समान या अंतर्निहित रूप से परिवर्तनीय हैं और यह सुनिश्चित करने के लिए कि Enum मान मौजूद हैं (वे डिफ़ॉल्ट रूप से जाँच नहीं किए जाते हैं!)।
यह देखने के लिए कि यह कैसे काम करता है, निम्न कोड आज़माएं:
public enum MyEnum : int
{
Foo = 1,
Bar = 2,
Mek = 5
}
static void Main(string[] args)
{
var e1 = (MyEnum)5;
var e2 = (MyEnum)6;
Console.WriteLine("{0} {1}", e1, e2);
Console.ReadLine();
}ध्यान दें कि कास्टिंग e2भी काम करता है! ऊपर संकलक दृष्टिकोण से यह समझ में आता है: value__क्षेत्र केवल 5 या 6 से भरा हुआ है और जब Console.WriteLineकॉल किया जाता है ToString(), तो नाम का e1समाधान किया जाता है जबकि नाम e2नहीं है।
यदि आप ऐसा नहीं चाहते हैं, Enum.IsDefined(typeof(MyEnum), 6)तो यह जांचने के लिए उपयोग करें कि क्या आप किसी परिभाषित एनम के लिए नक्शे कास्टिंग कर रहे हैं।
यह भी ध्यान दें कि मैं एनम के अंतर्निहित प्रकार के बारे में स्पष्ट हूं, भले ही संकलक वास्तव में यह जांचता है। मैं यह सुनिश्चित करने के लिए ऐसा कर रहा हूं कि मैं सड़क के नीचे किसी भी आश्चर्य में न दौड़ूं। कार्रवाई में इन आश्चर्य को देखने के लिए, आप निम्नलिखित कोड का उपयोग कर सकते हैं (वास्तव में मैंने देखा है कि यह डेटाबेस कोड में बहुत कुछ होता है):
public enum MyEnum : short
{
Mek = 5
}
static void Main(string[] args)
{
var e1 = (MyEnum)32769; // will not compile, out of bounds for a short
object o = 5;
var e2 = (MyEnum)o; // will throw at runtime, because o is of type int
Console.WriteLine("{0} {1}", e1, e2);
Console.ReadLine();
}int! = short, यह फेंक देगा (अनबॉक्सिंग विफल हो जाता है)। यदि आप करते हैं object o = (short)5;, तो यह काम करेगा, क्योंकि तब प्रकार मेल खाएंगे। यह सीमा के बारे में नहीं है, यह वास्तव में प्रकार के बारे में है।
निम्नलिखित उदाहरण लें:
int one = 1;
MyEnum e = (MyEnum)one;मैं कोड के इस टुकड़े का उपयोग अपने enum में int डालने के लिए कर रहा हूँ:
if (typeof(YourEnum).IsEnumDefined(valueToCast)) return (YourEnum)valueToCast;
else { //handle it here, if its not defined }मुझे यह सबसे अच्छा उपाय लगता है।
नीचे 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;
}
}सांख्यिक मानों के लिए, यह अधिक सुरक्षित है क्योंकि यह एक वस्तु को लौटाएगा चाहे वह कोई भी हो:
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;
}
}यदि आप 4.0 .NET फ्रेमवर्क के लिए तैयार हैं , तो एक नया Enum.TryParse () फ़ंक्शन है जो बहुत उपयोगी है और [फ्लैग] विशेषता के साथ अच्छा खेलता है। देखें Enum.TryParse विधि (स्ट्रिंग, TEnum%)
यदि आपके पास एक पूर्णांक है जो एक बिटमास्क के रूप में कार्य करता है और [फ्लैग्स] गणना में एक या अधिक मूल्यों का प्रतिनिधित्व कर सकता है, तो आप इस कोड का उपयोग किसी सूची में व्यक्तिगत ध्वज मानों को पार्स करने के लिए कर सकते हैं:
for (var flagIterator = 0; flagIterator < 32; flagIterator++)
{
// Determine the bit value (1,2,4,...,Int32.MinValue)
int bitValue = 1 << flagIterator;
// Check to see if the current flag exists in the bit mask
if ((intValue & bitValue) != 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), bitValue))
Console.WriteLine((MyEnum)bitValue);
}
}ध्यान दें कि यह मानता है कि अंतर्निहित प्रकार enumएक हस्ताक्षरित 32-बिट पूर्णांक है। यदि यह एक अलग संख्यात्मक प्रकार था, तो आपको बिट्स को उस प्रकार में प्रतिबिंबित करने के लिए हार्डकोड 32 को बदलना होगा (या प्रोग्रामेटिक रूप से इसका उपयोग करके प्राप्त करें Enum.GetUnderlyingType())
यह एक ध्वज गणना है जो सुरक्षित रूप से परिवर्तित विधि है:
public static bool TryConvertToEnum<T>(this int instance, out T result)
where T: Enum
{
var enumType = typeof (T);
var success = Enum.IsDefined(enumType, instance);
if (success)
{
result = (T)Enum.ToObject(enumType, instance);
}
else
{
result = default(T);
}
return success;
}Enumबजाय अब C # 7.3 के साथ सुधार किया जा सकता है struct, जिसका अर्थ है कि हमें रनटाइम चेक पर भरोसा नहीं करना है!
ENUM को एक स्ट्रिंग में बदलने के लिए या ENUM निरंतर करने के लिए int हमें Enum.Parse फ़ंक्शन का उपयोग करने की आवश्यकता है। यहाँ एक youtube वीडियो https://www.youtube.com/watch?v=4nhx4VwdRDk है जो वास्तव में स्ट्रिंग के साथ प्रदर्शित होता है और वही इंट के लिए लागू होता है।
कोड नीचे दिखाया गया है जहां "लाल" स्ट्रिंग है और "MyColors" रंग ENUM है जिसमें रंग स्थिरांक है।
MyColors EnumColors = (MyColors)Enum.Parse(typeof(MyColors), "Red");मूल प्रश्न से थोड़ा हटकर, लेकिन मुझे स्टैक ओवरफ्लो प्रश्न का उत्तर मिला, एनम से उपयोगी मान प्राप्त करें । 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;
}जाहिर है, एनुम प्रकार की कार्यक्षमता में से कुछ खो जाएगा, लेकिन डेटाबेस आईडी स्थिरांक के एक समूह को संग्रहीत करने के लिए, यह एक सुंदर साफ समाधान की तरह लगता है।
यह पूर्णांक या टार्गनी की उपयोगिता के समान जेनेरिक का उपयोग करके डॉट.नेट 4.0 में आंशिक मिलान के साथ एक लक्ष्य एनम को तार देता है। मैं कमांड-लाइन स्विच चर को परिवर्तित करने के लिए इसका उपयोग कर रहा हूं जो अधूरा हो सकता है। चूँकि एक एनम शून्य नहीं हो सकता है, इसलिए आपको तार्किक रूप से एक डिफ़ॉल्ट मान प्रदान करना चाहिए। इसे इस तरह कहा जा सकता है:
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;
}
}
}
}
}FYI करें: सवाल पूर्णांक के बारे में था, जिसका उल्लेख किसी ने भी Enum.TryParse () में स्पष्ट रूप से नहीं किया है
स्ट्रिंग से: (Enum.Parse पुराना है, Enum.TryParse का उपयोग करें)
enum Importance
{}
Importance importance;
if (Enum.TryParse(value, out importance))
{
}निम्नलिखित थोड़ा बेहतर विस्तार विधि है
public static string ToEnumString<TEnum>(this int enumValue)
{
var enumString = enumValue.ToString();
if (Enum.IsDefined(typeof(TEnum), enumValue))
{
enumString = ((TEnum) Enum.ToObject(typeof (TEnum), enumValue)).ToString();
}
return enumString;
}मेरे मामले में, मुझे डब्ल्यूसीएफ सेवा से एनम को वापस करने की आवश्यकता थी। मुझे एक दोस्ताना नाम भी चाहिए था, न कि केवल enum.ToString ()।
यहाँ मेरा WCF क्लास है।
[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>();मुझे नहीं पता कि मुझे इस एनम एक्सटेंशन का हिस्सा कहां से मिला, लेकिन यह स्टैकओवरफ्लो से है। मुझे इसके लिए खेद है! लेकिन मैंने इसे ले लिया और इसे फ्लैग के साथ एनम के लिए संशोधित किया। Flags के साथ enums के लिए मैंने ऐसा किया:
public static class Enum<T> where T : struct
{
private static readonly IEnumerable<T> All = Enum.GetValues(typeof (T)).Cast<T>();
private static readonly Dictionary<int, T> Values = All.ToDictionary(k => Convert.ToInt32(k));
public static T? CastOrNull(int value)
{
T foundValue;
if (Values.TryGetValue(value, out foundValue))
{
return foundValue;
}
// For enums with Flags-Attribut.
try
{
bool isFlag = typeof(T).GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
if (isFlag)
{
int existingIntValue = 0;
foreach (T t in Enum.GetValues(typeof(T)))
{
if ((value & Convert.ToInt32(t)) > 0)
{
existingIntValue |= Convert.ToInt32(t);
}
}
if (existingIntValue == 0)
{
return null;
}
return (T)(Enum.Parse(typeof(T), existingIntValue.ToString(), true));
}
}
catch (Exception)
{
return null;
}
return null;
}
}उदाहरण:
[Flags]
public enum PetType
{
None = 0, Dog = 1, Cat = 2, Fish = 4, Bird = 8, Reptile = 16, Other = 32
};
integer values
1=Dog;
13= Dog | Fish | Bird;
96= Other;
128= Null;आपको अधिक मजबूत होने के लिए कुछ प्रकार के मिलान विश्राम में निर्माण करना चाहिए।
public static T ToEnum<T>(dynamic value)
{
if (value == null)
{
// default value of an enum is the object that corresponds to
// the default value of its underlying type
// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/default-values-table
value = Activator.CreateInstance(Enum.GetUnderlyingType(typeof(T)));
}
else if (value is string name)
{
return (T)Enum.Parse(typeof(T), name);
}
return (T)Enum.ToObject(typeof(T),
Convert.ChangeType(value, Enum.GetUnderlyingType(typeof(T))));
}परीक्षण का मामला
[Flags]
public enum A : uint
{
None = 0,
X = 1 < 0,
Y = 1 < 1
}
static void Main(string[] args)
{
var value = EnumHelper.ToEnum<A>(7m);
var x = value.HasFlag(A.X); // true
var y = value.HasFlag(A.Y); // true
var value2 = EnumHelper.ToEnum<A>("X");
var value3 = EnumHelper.ToEnum<A>(null);
Console.ReadKey();
}करने के लिए और करने के लिए विभिन्न तरीकों से डाली 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);
}
}यह किसी भी इनपुट डेटा को उपयोगकर्ता के वांछित एनम में बदलने में आपकी मदद कर सकता है । मान लीजिए कि आपके पास नीचे की तरह एक एनम है, जो डिफ़ॉल्ट इंट द्वारा । कृपया अपने एनम में सबसे पहले एक डिफ़ॉल्ट मान जोड़ें । इनपुट वैल्यू के साथ कोई मेल नहीं मिलने पर हेल्पर्स मेडथोड में इसका उपयोग किया जाता है।
public enum FriendType
{
Default,
Audio,
Video,
Image
}
public static class EnumHelper<T>
{
public static T ConvertToEnum(dynamic value)
{
var result = default(T);
var tempType = 0;
//see Note below
if (value != null &&
int.TryParse(value.ToString(), out tempType) &&
Enum.IsDefined(typeof(T), tempType))
{
result = (T)Enum.ToObject(typeof(T), tempType);
}
return result;
}
}NB: यहाँ मैं इंट में वैल्यू पार्स करने की कोशिश करता हूँ, क्योंकि एनम डिफ़ॉल्ट रूप से int है। यदि आप एनम को इस तरह परिभाषित करते हैं जो बाइट प्रकार है।
public enum MediaType : byte
{
Default,
Audio,
Video,
Image
} आपको सहायक विधि से पार्सिंग को बदलना होगा
int.TryParse(value.ToString(), out tempType)सेवा
byte.TryParse(value.ToString(), out tempType)
मैं निम्नलिखित इनपुट के लिए अपनी विधि की जांच करता हूं
EnumHelper<FriendType>.ConvertToEnum(null);
EnumHelper<FriendType>.ConvertToEnum("");
EnumHelper<FriendType>.ConvertToEnum("-1");
EnumHelper<FriendType>.ConvertToEnum("6");
EnumHelper<FriendType>.ConvertToEnum("");
EnumHelper<FriendType>.ConvertToEnum("2");
EnumHelper<FriendType>.ConvertToEnum(-1);
EnumHelper<FriendType>.ConvertToEnum(0);
EnumHelper<FriendType>.ConvertToEnum(1);
EnumHelper<FriendType>.ConvertToEnum(9);मेरी अंग्रेजी के लिए खेद है
यहाँ एक विस्तार विधि है जो डाली Int32जाती है Enum।
जब मूल्य अधिकतम संभव से अधिक होता है तब भी यह बिटवाइज झंडे का सम्मान करता है। उदाहरण के लिए यदि आपके पास 1 , 2 और 4 संभावनाओं वाली एक एनम है , लेकिन इंट 9 है , तो यह समझता है कि 8 की अनुपस्थिति में 1 के रूप में । इससे आप कोड अपडेट से पहले डेटा अपडेट कर सकते हैं।
public static TEnum ToEnum<TEnum>(this int val) where TEnum : struct, IComparable, IFormattable, IConvertible
{
if (!typeof(TEnum).IsEnum)
{
return default(TEnum);
}
if (Enum.IsDefined(typeof(TEnum), val))
{//if a straightforward single value, return that
return (TEnum)Enum.ToObject(typeof(TEnum), val);
}
var candidates = Enum
.GetValues(typeof(TEnum))
.Cast<int>()
.ToList();
var isBitwise = candidates
.Select((n, i) => {
if (i < 2) return n == 0 || n == 1;
return n / 2 == candidates[i - 1];
})
.All(y => y);
var maxPossible = candidates.Sum();
if (
Enum.TryParse(val.ToString(), out TEnum asEnum)
&& (val <= maxPossible || !isBitwise)
){//if it can be parsed as a bitwise enum with multiple flags,
//or is not bitwise, return the result of TryParse
return asEnum;
}
//If the value is higher than all possible combinations,
//remove the high imaginary values not accounted for in the enum
var excess = Enumerable
.Range(0, 32)
.Select(n => (int)Math.Pow(2, n))
.Where(n => n <= val && n > 0 && !candidates.Contains(n))
.Sum();
return Enum.TryParse((val - excess).ToString(), out asEnum) ? asEnum : default(TEnum);
}c # में enum करने के लिए एक int कास्टिंग के लिए आसान और स्पष्ट तरीका:
public class Program
{
public enum Color : int
{
Blue = 0,
Black = 1,
Green = 2,
Gray = 3,
Yellow =4
}
public static void Main(string[] args)
{
//from string
Console.WriteLine((Color) Enum.Parse(typeof(Color), "Green"));
//from int
Console.WriteLine((Color)2);
//From number you can also
Console.WriteLine((Color)Enum.ToObject(typeof(Color) ,2));
}
}आप बस एन्टम या एनम टू इंट में स्पष्ट रूपांतरण कास्ट का उपयोग करते हैं
class Program
{
static void Main(string[] args)
{
Console.WriteLine((int)Number.three); //Output=3
Console.WriteLine((Number)3);// Outout three
Console.Read();
}
public enum Number
{
Zero = 0,
One = 1,
Two = 2,
three = 3
}
}using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
namespace SamplePrograme
{
public class Program
{
public enum Suit : int
{
Spades = 0,
Hearts = 1,
Clubs = 2,
Diamonds = 3
}
public static void Main(string[] args)
{
//from string
Console.WriteLine((Suit) Enum.Parse(typeof(Suit), "Clubs"));
//from int
Console.WriteLine((Suit)1);
//From number you can also
Console.WriteLine((Suit)Enum.ToObject(typeof(Suit) ,1));
}
}
}आप बस नीचे पसंद करते हैं:
int intToCast = 1;
TargetEnum f = (TargetEnum) intToCast ;यह सुनिश्चित करने के लिए कि आपने केवल सही मान डाले हैं और आप एक अपवाद को फेंक सकते हैं:
int intToCast = 1;
if (Enum.IsDefined(typeof(TargetEnum), intToCast ))
{
TargetEnum target = (TargetEnum)intToCast ;
}
else
{
// Throw your exception.
}ध्यान दें कि IsDefined का उपयोग करना महज कास्टिंग से भी महंगा है, इसलिए यह आपके कार्यान्वयन पर निर्भर करता है कि वह इसका उपयोग करें या नहीं।
आप एक्सटेंशन विधि का उपयोग कर सकते हैं।
public static class Extensions
{
public static T ToEnum<T>(this string data) where T : struct
{
if (!Enum.TryParse(data, true, out T enumVariable))
{
if (Enum.IsDefined(typeof(T), enumVariable))
{
return enumVariable;
}
}
return default;
}
public static T ToEnum<T>(this int data) where T : struct
{
return (T)Enum.ToObject(typeof(T), data);
}
}बलो कोड की तरह उपयोग करें
एनम:
public enum DaysOfWeeks
{
Monday = 1,
Tuesday = 2,
Wednesday = 3,
Thursday = 4,
Friday = 5,
Saturday = 6,
Sunday = 7,
}उपयोग:
string Monday = "Mon";
int Wednesday = 3;
var Mon = Monday.ToEnum<DaysOfWeeks>();
var Wed = Wednesday.ToEnum<DaysOfWeeks>();
YourEnumगतिशील है और केवल रनटाइम पर ही जाना जाएगा, और जो मैं चाहता हूं उसे कन्वर्ट करना हैEnum?