C# Language
enum

परिचय

वाक्य - विन्यास

• enum Colors {लाल, हरा, नीला} // Enum घोषणा
• enum Colors: बाइट {लाल, हरा, नीला} // विशिष्ट प्रकार के साथ घोषणा
• enum Colors {Red = 23, Green = 45, Blue = 12} // परिभाषित मूल्यों के साथ घोषणा
• Colors.Red // एक Enum के एक तत्व तक पहुँचें
• int value = (int) Colors.Red // एक एनम तत्व का अंतर मान प्राप्त करें
• रंगों का रंग = (रंग) intValue // इंट से तत्व प्राप्त करें

टिप्पणियों

एक enum के सभी सदस्यों के मान प्राप्त करें

enum MyEnum
{
    One,
    Two,
    Three
}

foreach(MyEnum e in Enum.GetValues(typeof(MyEnum)))
    Console.WriteLine(e);

यह प्रिंट करेगा:

One
Two
Three

झंडे के रूप में Enum

FlagsAttribute को Enum की प्रकृति से मेल खाने के लिए ToString() के व्यवहार को बदलते हुए एक FlagsAttribute लागू किया जा सकता है:

[Flags]
enum MyEnum
{
    //None = 0, can be used but not combined in bitwise operations
    FlagA = 1,
    FlagB = 2,
    FlagC = 4,
    FlagD = 8  
    //you must use powers of two or combinations of powers of two 
    //for bitwise operations to work
}

var twoFlags = MyEnum.FlagA | MyEnum.FlagB;

// This will enumerate all the flags in the variable: "FlagA, FlagB".
Console.WriteLine(twoFlags);

क्योंकि FlagsAttribute गणना दो स्थिरांक (या उनके संयोजन) की शक्तियां होने के लिए गणना पर निर्भर करता है और enum मान अंततः संख्यात्मक मान हैं, आप अंतर्निहित संख्यात्मक प्रकार के आकार द्वारा सीमित हैं। सबसे बड़ा उपलब्ध संख्यात्मक प्रकार जो आप उपयोग कर सकते हैं वह UInt64 , जो आपको 64 अलग (गैर-संयुक्त) ध्वज UInt64 निर्दिष्ट करने की अनुमति देता है। enum कीवर्ड अंतर्निहित प्रकार int को डिफॉल्ट करता है, जो कि Int32 । कंपाइलर 32 बिट से अधिक व्यापक मूल्यों की घोषणा की अनुमति देगा। वे एक चेतावनी के बिना चारों ओर लपेटेंगे और एक ही मूल्य के दो या अधिक enum सदस्यों में परिणाम करेंगे। इसलिए, यदि एक एनुम का मतलब 32 से अधिक झंडे वाले बिटसेट को शामिल करना है, तो आपको एक बड़े प्रकार की खोज को निर्दिष्ट करने की आवश्यकता है:

public enum BigEnum : ulong
{
    BigValue = 1 << 63
}

हालांकि झंडे अक्सर एक ही बिट होते हैं, उन्हें आसान उपयोग के लिए "सेट" नाम से जोड़ा जा सकता है।

[Flags]
enum FlagsEnum
{
    None = 0,
    Option1 = 1,
    Option2 = 2,
    Option3 = 4,
       
    Default = Option1 | Option3,
    All = Option1 | Option2 | Option3,
}

दो की शक्तियों के दशमलव मानों की स्पेलिंग से बचने के लिए, वाम-पारी संचालक (<<) का उपयोग समान एनम को घोषित करने के लिए भी किया जा सकता है

[Flags]
enum FlagsEnum
{
    None = 0,
    Option1 = 1 << 0,
    Option2 = 1 << 1,
    Option3 = 1 << 2,
       
    Default = Option1 | Option3,
    All = Option1 | Option2 | Option3,
}

C # 7.0 के साथ शुरू होने पर, बाइनरी शाब्दिक का भी उपयोग किया जा सकता है।

यह जांचने के लिए कि क्या HasFlag चर का मान एक निश्चित ध्वज सेट है, HasFlag विधि का उपयोग किया जा सकता है। मान लीजिए कि हमारे पास है

[Flags]
enum MyEnum
{
    One = 1,
    Two = 2,
    Three = 4
}

और एक value

var value = MyEnum.One | MyEnum.Two;

HasFlag हम यह जांच सकते हैं कि कोई झंडे सेट है या नहीं

if(value.HasFlag(MyEnum.One))
    Console.WriteLine("Enum has One");

if(value.HasFlag(MyEnum.Two))
    Console.WriteLine("Enum has Two");

if(value.HasFlag(MyEnum.Three))
    Console.WriteLine("Enum has Three");

इसके अलावा, हम सभी झंडे सेट करने के लिए enum के सभी मूल्यों के माध्यम से पुनरावृति कर सकते हैं

var type = typeof(MyEnum);
var names = Enum.GetNames(type);

foreach (var name in names)
{
    var item = (MyEnum)Enum.Parse(type, name);

    if (value.HasFlag(item))
        Console.WriteLine("Enum has " + name);
}

या

foreach(MyEnum flagToCheck in Enum.GetValues(typeof(MyEnum)))
{
    if(value.HasFlag(flagToCheck))
    {
         Console.WriteLine("Enum has " + flagToCheck);
    }
}

सभी तीन उदाहरण मुद्रित होंगे:

Enum has One
Enum has Two

बिट्स लॉजिक के साथ टेस्ट फ्लैग-स्टाइल एनम वैल्यूज

झंडे-शैली के एनम मूल्य को बिटवाइज़ लॉजिक के साथ जांचने की आवश्यकता है क्योंकि यह किसी एकल मूल्य से मेल नहीं खा सकता है।

[Flags]
enum FlagsEnum
{
    Option1 = 1,
    Option2 = 2,
    Option3 = 4,
    Option2And3 = Option2 | Option3;

    Default = Option1 | Option3,
}

Default मान वास्तव में दो अन्य का एक संयोजन है जो एक बिटवाइज़ या मर्ज के साथ विलय होता है। इसलिए एक ध्वज की उपस्थिति के लिए परीक्षण करने के लिए हमें बिटवाइज़ और का उपयोग करने की आवश्यकता है।

var value = FlagsEnum.Default;

bool isOption2And3Set = (value & FlagsEnum.Option2And3) == FlagsEnum.Option2And3;

Assert.True(isOption2And3Set);

स्ट्रिंग और वापस करने के लिए Enum

public enum DayOfWeek
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
}

    
// Enum to string
string thursday = DayOfWeek.Thursday.ToString(); // "Thursday"

string seventhDay = Enum.GetName(typeof(DayOfWeek), 6); // "Saturday"

string monday = Enum.GetName(typeof(DayOfWeek), DayOfWeek.Monday); // "Monday"


// String to enum (.NET 4.0+ only - see below for alternative syntax for earlier .NET versions)
DayOfWeek tuesday;
Enum.TryParse("Tuesday", out tuesday); // DayOfWeek.Tuesday

DayOfWeek sunday;
bool matchFound1 = Enum.TryParse("SUNDAY", out sunday); // Returns false (case-sensitive match)

DayOfWeek wednesday;
bool matchFound2 = Enum.TryParse("WEDNESDAY", true, out wednesday); // Returns true; DayOfWeek.Wednesday (case-insensitive match)


// String to enum (all .NET versions)
DayOfWeek friday = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), "Friday"); // DayOfWeek.Friday

DayOfWeek caturday = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), "Caturady"); // Thows ArgumentException

// All names of an enum type as strings
string[] weekdays = Enum.GetNames(typeof(DayOfWeek));

Enum == शून्य के लिए डिफ़ॉल्ट मान

एक एनम के लिए डिफ़ॉल्ट मान शून्य है । यदि कोई एनम किसी आइटम को शून्य के मान से परिभाषित नहीं करता है, तो इसका डिफ़ॉल्ट मान शून्य होगा।

public class Program
{        
    enum EnumExample
    {
        one = 1,
        two = 2
    }
    
    public void Main()
    {              
        var e = default(EnumExample);
        
        if (e == EnumExample.one)
            Console.WriteLine("defaults to one");
        else
            Console.WriteLine("Unknown");    
    }    
}

उदाहरण: https://dotnetfiddle.net/l5Rwie

मूल बातें

MSDN से :

एन्यूमरेशन प्रकार (जिसे एन्यूमरेशन या एनम भी कहा जाता है) एक अभिन्न अंग नाम के एक सेट को परिभाषित करने के लिए एक कुशल तरीका प्रदान करता है जिसे एक चर को सौंपा जा सकता है।

अनिवार्य रूप से, एक एनम एक प्रकार है जो केवल परिमित विकल्पों के एक सेट की अनुमति देता है, और प्रत्येक विकल्प एक संख्या से मेल खाता है। डिफ़ॉल्ट रूप से, शून्य से शुरू होने वाले मूल्यों की घोषणा के क्रम में वे संख्या बढ़ रही है। उदाहरण के लिए, कोई सप्ताह के दिनों के लिए एक घोषणा कर सकता है:

public enum Day
{
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
}

वह एनम इस तरह इस्तेमाल किया जा सकता है:

// Define variables with values corresponding to specific days
Day myFavoriteDay = Day.Friday;
Day myLeastFavoriteDay = Day.Monday;

// Get the int that corresponds to myFavoriteDay
// Friday is number 4
int myFavoriteDayIndex = (int)myFavoriteDay;

// Get the day that represents number 5
Day dayFive = (Day)5;

डिफ़ॉल्ट रूप से प्रत्येक तत्व के अंतर्निहित प्रकार enum है int , लेकिन byte , sbyte , short , ushort , uint , long और ulong साथ ही इस्तेमाल किया जा सकता। यदि आप int अलावा किसी अन्य प्रकार का उपयोग करते हैं, तो आपको एनम नाम के बाद एक कोलन का उपयोग करके प्रकार निर्दिष्ट करना होगा:

public enum Day : byte 
{
    // same as before 
}

नाम के बाद की संख्या अब पूर्णांक के बजाय बाइट्स है। आप निम्न प्रकार से एनम के अंतर्निहित प्रकार प्राप्त कर सकते हैं:

Enum.GetUnderlyingType(typeof(Days)));

आउटपुट:

System.Byte

डेमो: .NET fiddle

एनम का उपयोग करके बिटवाइज मैनीपुलेशन

जब भी प्रगणक झंडे के एक संग्रह का प्रतिनिधित्व करता है, तो एकल मूल्य के बजाय, फ्लैगएट्रिब्यूट का उपयोग किया जाना चाहिए। प्रत्येक एनुम मान को असाइन किया गया संख्यात्मक मान बिटवाइज़ ऑपरेटरों का उपयोग करते हुए एनमोज़ को हेरफेर करने में मदद करता है।

उदाहरण 1: [झंडे] के साथ

[Flags]
enum Colors
{
    Red=1,
    Blue=2,
    Green=4,
    Yellow=8
}

var color = Colors.Red | Colors.Blue;
Console.WriteLine(color.ToString());

प्रिंट लाल, नीला

उदाहरण 2: बिना [झंडे]

enum Colors
{
    Red=1,
    Blue=2,
    Green=4,
    Yellow=8
}
var color = Colors.Red | Colors.Blue;
Console.WriteLine(color.ToString());

प्रिंट 3

का प्रयोग << झंडे के लिए संकेतन

लेफ्ट-शिफ्ट ऑपरेटर ( << ) का उपयोग ध्वज एनुम घोषणाओं में किया जा सकता है ताकि यह सुनिश्चित हो सके कि प्रत्येक ध्वज में बाइनरी प्रतिनिधित्व में ठीक एक 1 है, जैसा कि ध्वज को होना चाहिए।

यह भी उन में बहुत सारे झंडे के साथ बड़े enums की पठनीयता में सुधार करने में मदद करता है।

[Flags]
public enum MyEnum 
{
    None  = 0,
    Flag1 = 1 << 0,
    Flag2 = 1 << 1,
    Flag3 = 1 << 2,
    Flag4 = 1 << 3,
    Flag5 = 1 << 4,
    ...
    Flag31 = 1 << 30
}

अब यह स्पष्ट है कि MyEnum में केवल उचित झंडे हैं और फ्लैग Flag30 = 1073741822 (या बाइनरी में 11111111111111111111111111111110) जैसा कोई भी गन्दा सामान नहीं है जो अनुचित है।

एक एनम मान के लिए अतिरिक्त विवरण जानकारी जोड़ना

कुछ मामलों में आप एक एनुम मान के लिए एक अतिरिक्त विवरण जोड़ना चाह सकते हैं, उदाहरण के लिए जब एनम मूल्य खुद को उपयोगकर्ता के लिए प्रदर्शित करना चाहते हैं की तुलना में कम पठनीय है। ऐसे मामलों में आप System.ComponentModel.DescriptionAttribute वर्ग का उपयोग कर सकते हैं।

उदाहरण के लिए:

public enum PossibleResults
{
    [Description("Success")]
    OK = 1,
    [Description("File not found")]
    FileNotFound = 2,
    [Description("Access denied")]
    AccessDenied = 3
}

अब, यदि आप एक विशिष्ट एनम मूल्य का विवरण वापस करना चाहते हैं, तो आप निम्न कार्य कर सकते हैं:

public static string GetDescriptionAttribute(PossibleResults result)
{
        return ((DescriptionAttribute)Attribute.GetCustomAttribute((result.GetType().GetField(result.ToString())), typeof(DescriptionAttribute))).Description;
}

static void Main(string[] args)
{
    PossibleResults result = PossibleResults.FileNotFound;
    Console.WriteLine(result); // Prints "FileNotFound"
    Console.WriteLine(GetDescriptionAttribute(result)); // Prints "File not found"
}

यह भी आसानी से सभी enums के लिए एक विस्तार विधि में तब्दील किया जा सकता है:

static class EnumExtensions
{
    public static string GetDescription(this Enum enumValue)
    {
        return ((DescriptionAttribute)Attribute.GetCustomAttribute((enumValue.GetType().GetField(enumValue.ToString())), typeof(DescriptionAttribute))).Description;
    }
}

और फिर इस तरह आसानी से उपयोग किया जाता है: Console.WriteLine(result.GetDescription());

ध्वजांकित एनम से मान जोड़ें और निकालें

यह कोड ध्वजांकित एनम-उदाहरण से मान जोड़ने और हटाने का है:

[Flags]
public enum MyEnum
{
    Flag1 = 1 << 0,
    Flag2 = 1 << 1,
    Flag3 = 1 << 2
}

var value = MyEnum.Flag1;

// set additional value
value |= MyEnum.Flag2;  //value is now Flag1, Flag2
value |= MyEnum.Flag3;  //value is now Flag1, Flag2, Flag3

// remove flag
value &= ~MyEnum.Flag2; //value is now Flag1, Flag3    

Enums में अप्रत्याशित मूल्य हो सकते हैं

चूंकि एक एनुम को अपने अंतर्निहित अभिन्न प्रकार से डाला जा सकता है, मान एनुम प्रकार की परिभाषा में दिए गए मानों की सीमा से बाहर हो सकता है।

हालांकि नीचे enum प्रकार DaysOfWeek केवल 7 परिभाषित मान होते हैं, यह अभी भी किसी भी धारण कर सकते हैं int मूल्य।

public enum DaysOfWeek
{
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6,
    Sunday = 7
}

DaysOfWeek d = (DaysOfWeek)31;
Console.WriteLine(d); // prints 31

DaysOFWeek s = DaysOfWeek.Sunday;
s++; // No error

वर्तमान में एक एनम को परिभाषित करने का कोई तरीका नहीं है जिसमें यह व्यवहार नहीं है।

हालाँकि, अपरिभाषित Enum मानों Enum.IsDefined विधि का उपयोग करके पता लगाया जा सकता है। उदाहरण के लिए,

DaysOfWeek d = (DaysOfWeek)31;
Console.WriteLine(Enum.IsDefined(typeof(DaysOfWeek),d)); // prints False