C # में enum से int मान प्राप्त करें

Question

मेरा एक वर्ग है जिसे Questions(बहुवचन) कहा जाता है । इस वर्ग में एक एनुम Question(एकवचन) कहा जाता है जो इस तरह दिखता है।

public enum Question
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

में Questionsकक्षा मैं एक है get(int foo)समारोह है कि एक रिटर्न Questionsउस के लिए वस्तु foo। क्या एनम से पूर्णांक मान प्राप्त करने का एक आसान तरीका है ताकि मैं ऐसा कुछ कर सकूं Questions.Get(Question.Role)?

Comments

आसपास के दूसरे तरीके के लिए: कास्ट-इंट-टू-एनम-इन-सी-शार्प ।

— नवफाल

मुझे पता है कि मुझे पार्टी में देरी हो रही है, लेकिन अपनी पद्धति को परिभाषित करने के बजाय जैसे ही get(int foo)आप इसे परिभाषित कर सकते हैं, get(Question foo)तब अपनी कास्टिंग विधि के अंदर करें, आप अपनी विधि को कॉल कर सकते हैंQuestions.Get(Question.Role)

— जो

Answer 1

बस एनम डाली, उदा

int something = (int) Question.Role;

ऊपर आप जंगली में देखे जाने वाले विशाल मात्रा में एनम के लिए डिफ़ॉल्ट अंतर्निहित प्रकार के लिए काम करेंगे int।

हालांकि, जैसा कि सेसिलफिलिप बताता है, एनम के विभिन्न अंतर्निहित प्रकार हो सकते हैं। यदि एक एनुम को ए uint, longया के रूप में घोषित किया जाता है ulong, तो उसे एन्नम के प्रकार पर डाला जाना चाहिए; उदाहरण के लिए

enum StarsInMilkyWay:long {Sun = 1, V645Centauri = 2 .. Wolf424B = 2147483649};

आपको उपयोग करना चाहिए

long something = (long)StarsInMilkyWay.Wolf424B;

Comments

@ यह सच नहीं है। आप कास्टिंग के बिना एन्यूमरेशन बना सकते हैं, इसकी आवश्यकता नहीं है। और मैं केवल विशेष मामलों में नंबर असाइन करता हूं, ज्यादातर समय, मैं इसे डिफ़ॉल्ट मान के रूप में छोड़ देता हूं। लेकिन आप कर सकते हैं enum Test { Item = 1 }और देख सकते हैं कि 1 == (int)Test.Itemबराबर है।

— २०:४

@ जैदर (int)Test.Itemयह एक कास्ट है! () स्पष्ट कास्ट ऑपरेटर है।

— सिंथिया वी

@ सिन्थिया वी ने कहा कि आप इसे बिना कास्टिंग के बना सकते हैं , जो सही है

— पॉल रिडग्वे

यदि अंतर्निहित प्रकार enum Questionनहीं था, intलेकिन longयह कलाकारों के Roleअभिन्न मूल्य को छोटा कर देगा !

— क्वालाल

जब आप Enumएक पैरामीटर के रूप में स्वीकार करते हैं , तो आप जानते हैं कि आपके द्वारा प्राप्त किए जाने वाले संभावित अभिन्न मूल्यों की एक निश्चित संख्या है। दूसरी ओर, यदि आप बस एक लेते हैं int, तो आपको मान्य करना होगा यदि वह intस्वीकृत मानों के भीतर है। इस प्रकार कोड को जटिल करना। आप हमेशा अपने हस्ताक्षरों को ओवरराइड कर सकते हैं जैसे `` सार्वजनिक शून्य MyMethod (int x) {// x के साथ कुछ करें} सार्वजनिक शून्य MyMethod (Enum x) {this.MyMethod ((int) x); } `` ``

— percebus

Answer 2

चूंकि Enums किसी भी अभिन्न प्रकार हो सकता है ( byte, int, short, आदि), enum के अंतर्निहित अभिन्न मूल्य प्राप्त करने के एक और अधिक मजबूत तरीका का उपयोग करने के लिए होगा GetTypeCodeके साथ संयोजन के रूप में विधि Convertवर्ग:

enum Sides {
    Left, Right, Top, Bottom
}
Sides side = Sides.Bottom;

object val = Convert.ChangeType(side, side.GetTypeCode());
Console.WriteLine(val);

यह अंतर्निहित अभिन्न प्रकार की परवाह किए बिना काम करना चाहिए।

Comments

इस तकनीक ने एक सामान्य प्रकार के साथ काम करते समय मेरे लिए इसके लायक साबित किया जहां टी: एनम (वास्तव में टी: संरचना, IConvertible लेकिन यह एक अलग कहानी है)।

— aboy021

हेक्साडेसिमल मान के प्रिंट आउट के लिए आप इसे कैसे संशोधित करेंगे? यह उदाहरण दशमलव मान दर्शाता है। समस्या यह है कि varयह प्रकार का है object, इसलिए आपको इसे अनबॉक्स करने की आवश्यकता है और यह जितना मुझे पसंद आएगा उससे अधिक गड़बड़ हो जाएगा।

— मार्क लकाटा

मुझे लगता है कि आप के लिए उदाहरण बदलना चाहिए अपने उदाहरण में हमेशा रहेंगे । object val = Convert...etcvarobject

— मेश

@TimAbell सभी मैं वास्तव में कह सकता हूं कि हमने पाया है कि गतिशील रूप से संकलित एस्पेक्स पेज (जहां आपको लाइव सर्वर पर .cs फ़ाइलों को तैनात करना है) पूर्णांक को प्रत्येक मान पर अलग-अलग असाइन कर रहे थे। इसका मतलब यह था कि क्रमबद्ध वस्तुएं एक एक मशीन, एक अलग मशीन पर विभिन्न मूल्यों के साथ deserializing थीं और प्रभावी रूप से दूषित हो रही थीं ( भ्रम के घंटे के कारण )। हमने इसे एमएस के साथ उठाया था और मुझे याद है कि उन्होंने कहा था कि ऑटोगेन्जेनेटेड पूर्णांकों को समान फ्रेमवर्क संस्करणों में निर्मित होने की गारंटी नहीं थी।

— NickG

@TimAbell एक अलग अवसर पर, एक डेवलपर ने एक अप्रचलित / अप्रयुक्त Enum मान को हटा दिया, जिसके कारण अनुक्रम में अन्य सभी मान एक से बाहर हो गए। जैसे, हमारे कोडिंग मानकों के लिए अब यह आवश्यक है कि आईडी को हमेशा स्पष्ट रूप से निर्दिष्ट किया जाए, अन्यथा कोड जोड़ना / हटाना या यहां तक ​​कि ऑटो-फ़ॉर्मेटिंग (जैसे वर्णानुक्रम में सॉर्ट करना) डेटा भ्रष्टाचार के कारण सभी मानों को बदल देगा। मैं स्पष्ट रूप से सभी Enum पूर्णांकों को स्पष्ट रूप से निर्दिष्ट करने के लिए किसी को भी सलाह दूंगा। यह अति-महत्वपूर्ण है यदि वे बाह्य रूप से (डेटाबेस) संग्रहीत मूल्यों से संबंधित हैं।

— NickG

Answer 3

सार्वजनिक स्थिरांक वाले एक स्थिर वर्ग के रूप में घोषित करें:

public static class Question
{
    public const int Role = 2;
    public const int ProjectFunding = 3;
    public const int TotalEmployee = 4;
    public const int NumberOfServers = 5;
    public const int TopBusinessConcern = 6;
}

और फिर आप इसे इस रूप में संदर्भित कर सकते हैं Question.Role, और यह हमेशा एक intया जो भी आप इसे परिभाषित करते हैं, उसका मूल्यांकन करता है।

Comments

मैं उपयोग करूँगा static readonly intक्योंकि स्थिरांक उनके कठिन मूल्यों में संकलित हैं। देखें stackoverflow.com/a/755693/492

— सीएडी

यह समाधान वास्तव में दृढ़ता से टाइप किए गए एनमों का वास्तविक लाभ प्रदान नहीं करता है। यदि मैं केवल उदाहरण के लिए एक विशिष्ट विधि के लिए एक GameState-enum- पैरामीटर को पारित करना चाहता था, तो संकलक मुझे किसी भी अंतर-चर को पैरामीटर के रूप में पारित करने की अनुमति नहीं देनी चाहिए।

— thgc

@CADBloke जो ठीक है कि आप क्यों उपयोग करेंगे constऔर static readonlyइसलिए नहीं कि हर बार जब आप तुलना static readonlyकरते हैं तो आप वैरिएबल का मान प्राप्त करने के लिए एक विधि कॉल constकर रहे हैं जबकि आप सीधे दो मान प्रकारों की तुलना कर रहे हैं।

— ब्लॉकऑलॉप

@ brettof86 हां, एक कांस्ट तेजी से होगा, अगर संकलन की सीमा कभी भी समस्या नहीं होगी, तो यह सब अच्छा है।

— सीएडी

@Zack मैंने यह अच्छी तरह से नहीं समझाया, compilation limitationमेरा मतलब है कि जब आप इसे संकलित करते हैं, तो मूल्य कठिन-कोडित होता है, इसलिए उस मूल्य में कोई भी परिवर्तन की आवश्यकता होती है, जिसका उपयोग करके सभी असेंबली को फिर से तैयार करने की आवश्यकता होती है । मैं उपयोग के बारे में आपसे सहमत होने के लिए इच्छुक हूं क्योंकि मूल्यों को बदलने के दूरगामी प्रभाव होंगे।

— सीएडी

Answer 4

Question question = Question.Role;
int value = (int) question;

में परिणाम होगा value == 2।

Comments

अस्थायी परिवर्तनशील प्रश्न अनावश्यक है।

— गिषु

इस Questions.Get की तरह कुछ (Convert.ToInt16 (Question.Applications)) तो

— जिम

आप बस किसी भी दिशा में डाल सकते हैं; घड़ी के लिए केवल एक चीज है कि enums कुछ भी लागू नहीं है (enum मूल्य 288 हो सकता है, भले ही कोई प्रश्न है कि संख्या के साथ मौजूद है)

— मार्क Gravell

@ जिम: नहीं, सिर्फ मूल्य डालें: प्रश्न। प्रश्न ((इंट) प्रश्न. आवेदन);

— गुफा

@ गिशु आप कह सकते हैं ... यह संदिग्ध है। ;)

— फेलिक्स डी।

Answer 5

संबंधित नोट पर, यदि आप intसे मूल्य प्राप्त करना चाहते हैं System.Enum, तो eयहां दिया गया है:

Enum e = Question.Role;

आप उपयोग कर सकते हैं:

int i = Convert.ToInt32(e);
int i = (int)(object)e;
int i = (int)Enum.Parse(e.GetType(), e.ToString());
int i = (int)Enum.ToObject(e.GetType(), e);

अंतिम दो सादे बदसूरत हैं। मैं पहले वाले को पसंद करता हूं।

Comments

हालांकि दूसरा सबसे तेज है।

— जोहान बी

जैसा कि किसी को Minecraft मॉडिंग में मिक्सिन्स का उपयोग करने के लिए उपयोग किया जाता है, दूसरा स्पष्ट विजेता की तरह लगता है।

— सिल्लास

Answer 6

आपके विचार से यह आसान है - एक एनम पहले से ही एक इंट है। यह सिर्फ याद दिलाने की जरूरत है:

int y = (int)Question.Role;
Console.WriteLine(y); // Prints 2

Comments

नाइटपिक: यह एनम पहले से ही एक इंट है। अन्य enums अलग प्रकार के हो सकते हैं - "enum SmallEnum: byte {A, B, C}"

— mqp

बिल्कुल सच। C # संदर्भ: "प्रत्येक गणन प्रकार में एक अंतर्निहित प्रकार होता है, जो चार को छोड़कर कोई भी अभिन्न प्रकार हो सकता है।"

— माइकल पेट्रोत्ता

Answer 7

उदाहरण:

public Enum EmpNo
{
    Raj = 1,
    Rahul,
    Priyanka
}

और Enum मान प्राप्त करने के लिए पीछे के कोड में:

int setempNo = (int)EmpNo.Raj; // This will give setempNo = 1

या

int setempNo = (int)EmpNo.Rahul; // This will give setempNo = 2

एनम 1 से वृद्धि करेंगे, और आप प्रारंभ मूल्य निर्धारित कर सकते हैं। यदि आप प्रारंभ मूल्य निर्धारित नहीं करते हैं तो इसे शुरुआत में 0 के रूप में सौंपा जाएगा।

Comments

क्या यह वास्तव में संकलन है?

— पीटर मोर्टेंसन

क्या जो राज है वह राहुल या प्रियंका भी हो सकता है? आपका मान संघर्ष और अद्वितीय होना चाहिए, जैसे 0, 1, 2, 4, 8, आदि। यह मेरी मूल चिंता है।

— टिमोथी गोंजालेज

@TimothyGonzalez वास्तव में enums केवल 1 को गिनता है यदि आप स्पष्ट रूप से उनके मूल्य को निर्दिष्ट नहीं करते हैं;)

— derHugo

@derHugo यह निर्भर करता है कि क्या आप संख्यात्मक मानों को आधार 10 या आधार 2 मानते हैं

— टिमोथी गोंजालेज

@TimothyGonzalez अच्छी तरह से यह मानने के लिए बहुत कुछ नहीं है ... मैंने अभी बताया है कि डिफ़ॉल्ट रूप से वे सिर्फ गिनते हैं 1, intसिवाय इसके कि आप स्पष्ट रूप से परिभाषित करें अन्यथा

— derHugo

Answer 8

मैंने हाल ही में संरक्षित रचनाकारों और पूर्वनिर्धारित स्थैतिक उदाहरणों के साथ कक्षाओं का उपयोग करने के बजाय अपने कोड में एनमों का उपयोग करने से दूर कर दिया है ( Roelof के लिए धन्यवाद - C # सुनिश्चित करें वैध Enum मान - Futureproof विधि )।

उस के प्रकाश में, नीचे मैं अब इस मुद्दे पर कैसे पहुंचूंगा (सहित / से अंतर्निहित रूपांतरण int)।

public class Question
{
    // Attributes
    protected int index;
    protected string name;
    // Go with a dictionary to enforce unique index
    //protected static readonly ICollection<Question> values = new Collection<Question>();
    protected static readonly IDictionary<int,Question> values = new Dictionary<int,Question>();

    // Define the "enum" values
    public static readonly Question Role = new Question(2,"Role");
    public static readonly Question ProjectFunding = new Question(3, "Project Funding");
    public static readonly Question TotalEmployee = new Question(4, "Total Employee");
    public static readonly Question NumberOfServers = new Question(5, "Number of Servers");
    public static readonly Question TopBusinessConcern = new Question(6, "Top Business Concern");

    // Constructors
    protected Question(int index, string name)
    {
        this.index = index;
        this.name = name;
        values.Add(index, this);
    }

    // Easy int conversion
    public static implicit operator int(Question question) =>
        question.index; //nb: if question is null this will return a null pointer exception

    public static implicit operator Question(int index) =>        
        values.TryGetValue(index, out var question) ? question : null;

    // Easy string conversion (also update ToString for the same effect)
    public override string ToString() =>
        this.name;

    public static implicit operator string(Question question) =>
        question?.ToString();

    public static implicit operator Question(string name) =>
        name == null ? null : values.Values.FirstOrDefault(item => name.Equals(item.name, StringComparison.CurrentCultureIgnoreCase));


    // If you specifically want a Get(int x) function (though not required given the implicit converstion)
    public Question Get(int foo) =>
        foo; //(implicit conversion will take care of the conversion for you)
}

इस दृष्टिकोण का लाभ आपको वह सब कुछ है जो आपको एनम से प्राप्त होगा, लेकिन आपका कोड अब और अधिक लचीला है, इसलिए आपको इसके मूल्य के आधार पर विभिन्न कार्यों को करने की आवश्यकता है Question, आप अपने आप में तर्क डाल सकते हैं Question(अर्थात पसंदीदा ओओ में) फैशन) प्रत्येक परिदृश्य से निपटने के लिए आपके कोड में बहुत सारे केस स्टेटमेंट डालने का विरोध किया गया।

---

एनबी: उत्तर # 2018-04-27 सी # 6 सुविधाओं का उपयोग करने के लिए; यानी घोषणा भाव और लंबोदर अभिव्यक्ति शरीर परिभाषा। मूल कोड के लिए संशोधन इतिहास देखें । इससे परिभाषा को थोड़ा कम करने की क्रिया का लाभ है; जो इस उत्तर के दृष्टिकोण के बारे में मुख्य शिकायतों में से एक था।

Comments

मुझे लगता है कि यह स्पष्ट कलाकारों और कोड के बीच का व्यापार है जिसे आपको इसे दरकिनार करना है। अभी भी कार्यान्वयन से प्यार है बस इच्छा है कि यह इतना लंबा नहीं था। +1

— लंकिमार्ट

मैंने इसके समान संरचित कई अलग-अलग वर्गों का उपयोग किया है। मुझे लगता है कि वे चमत्कार का काम करते हैं जब "बाद में मुझे बेवकूफ न बनने दें" पद्धति का पालन करने की कोशिश करते हैं।

— जेम्स हग

Answer 9

यदि आप वैरिएबल में संग्रहित एनम वैल्यू के लिए एक पूर्णांक प्राप्त करना चाहते हैं, जिसके लिए एक प्रकार होगा Question, उदाहरण के लिए एक विधि में उपयोग करने के लिए, आप बस इसे कर सकते हैं जो मैंने इस उदाहरण में लिखा है:

enum Talen
{
    Engels = 1, Italiaans = 2, Portugees = 3, Nederlands = 4, Duits = 5, Dens = 6
}

Talen Geselecteerd;    

public void Form1()
{
    InitializeComponent()
    Geselecteerd = Talen.Nederlands;
}

// You can use the Enum type as a parameter, so any enumeration from any enumerator can be used as parameter
void VeranderenTitel(Enum e)
{
    this.Text = Convert.ToInt32(e).ToString();
}

यह विंडो शीर्षक को 4 में बदल देगा, क्योंकि चर Geselecteerdहै Talen.Nederlands। यदि मैं इसे Talen.Portugeesविधि में परिवर्तित करता हूं और फिर से कॉल करता हूं , तो पाठ 3 में बदल जाएगा।

Comments

डच में कोडिंग। हरे बाबा।

— वाइजस्ट्रॉबेरी 14

दुर्भाग्य से, यह दृष्टिकोण खराब प्रदर्शन देता है जितना अधिक आप इसका उपयोग करते हैं। मैंने इसे अपने कुछ कोड में आज़माया, और जैसे-जैसे समय बीतता गया, मेरे आवेदन में धीमी और धीमी सीपीयू का उपयोग होने लगा। इसका तात्पर्य यह है कि थ्रेड्स किसी चीज़ पर प्रतीक्षा कर रहे थे - मैं कुछ प्रकार का कचरा संग्रह मान रहा हूँ, संभवतः Toumnt32 () में बॉक्सिंग एनुम पैरामीटर के कारण। एक साधारण int.Parse () पर स्विच करके, मैं इस खराब प्रदर्शन को पूरी तरह से समाप्त करने में सक्षम था, और प्रदर्शन में कोई फर्क नहीं पड़ता कि कोड कितने समय तक चला।

— ग्रेग

Answer 10

यह सुनिश्चित करने के लिए कि एनम मूल्य मौजूद है और फिर इसे पार्स करें, आप निम्न कार्य भी कर सकते हैं।

// Fake Day of Week
string strDOWFake = "SuperDay";

// Real Day of Week
string strDOWReal = "Friday";

// Will hold which ever is the real DOW.
DayOfWeek enmDOW;

// See if fake DOW is defined in the DayOfWeek enumeration.
if (Enum.IsDefined(typeof(DayOfWeek), strDOWFake))
{
    // This will never be reached since "SuperDay"
    // doesn't exist in the DayOfWeek enumeration.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWFake);
}
// See if real DOW is defined in the DayOfWeek enumeration.
else if (Enum.IsDefined(typeof(DayOfWeek), strDOWReal))
{
    // This will parse the string into it's corresponding DOW enum object.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWReal);
}

// Can now use the DOW enum object.
Console.Write("Today is " + enmDOW.ToString() + ".");

Answer 11

शायद मैं इसे याद किया, लेकिन क्या किसी ने एक सामान्य सामान्य विस्तार विधि की कोशिश की है?

यह मेरे लिए बहुत अच्छा काम करता है। आप इस तरह से अपने एपीआई में टाइप कास्ट से बच सकते हैं लेकिन अंत में इसका परिणाम एक प्रकार का ऑपरेशन होता है। रोसलिन को प्रोग्रामिंग करने के लिए यह एक अच्छा मामला है कि कंपाइलर आपके लिए GetValue <T> मेथड बनाए।

    public static void Main()
    {
        int test = MyCSharpWrapperMethod(TestEnum.Test1);

        Debug.Assert(test == 1);
    }

    public static int MyCSharpWrapperMethod(TestEnum customFlag)
    {
        return MyCPlusPlusMethod(customFlag.GetValue<int>());
    }

    public static int MyCPlusPlusMethod(int customFlag)
    {
        // Pretend you made a PInvoke or COM+ call to C++ method that require an integer
        return customFlag;
    }

    public enum TestEnum
    {
        Test1 = 1,
        Test2 = 2,
        Test3 = 3
    }
}

public static class EnumExtensions
{
    public static T GetValue<T>(this Enum enumeration)
    {
        T result = default(T);

        try
        {
            result = (T)Convert.ChangeType(enumeration, typeof(T));
        }
        catch (Exception ex)
        {
            Debug.Assert(false);
            Debug.WriteLine(ex);
        }

        return result;
    }
}

Comments

संभवतः क्योंकि (int) customFlag चारों ओर कम टाइप कर रहा है और कमोबेश यही काम करता है?

— टिम किटिंग

पुन: "हो सकता है कि मैं इससे चूक गया था, लेकिन क्या किसी ने एक सामान्य सामान्य विस्तार विधि की कोशिश की है ?" : सिक्सोथ्री ने कहा " इसके बजाय एक एक्सटेंशन विधि का उपयोग करें " और ब्रोनक ने कहा "आप अपने परिभाषित एनम प्रकार के लिए एक एक्सटेंशन विधि लागू करके ऐसा कर सकते हैं " ।

— पीटर मोर्टेंसन

Answer 12

इसे करने का एक और तरीका:

Console.WriteLine("Name: {0}, Value: {0:D}", Question.Role);

यह परिणाम होगा:

Name: Role, Value: 2

Answer 13

public enum QuestionType
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

... एक अच्छी घोषणा है।

आपको रिजल्ट को इस तरह डालना होगा:

int Question = (int)QuestionType.Role

अन्यथा, प्रकार अभी भी है QuestionType।

इस स्तर की सख्ती C # तरीका है।

इसके बजाय एक वर्ग घोषणा का उपयोग करने के लिए एक विकल्प है:

public class QuestionType
{
    public static int Role = 2,
    public static int ProjectFunding = 3,
    public static int TotalEmployee = 4,
    public static int NumberOfServers = 5,
    public static int TopBusinessConcern = 6
}

यह घोषित करने के लिए कम सुरुचिपूर्ण है, लेकिन आपको इसे कोड में डालने की आवश्यकता नहीं है:

int Question = QuestionType.Role

वैकल्पिक रूप से, आप विजुअल बेसिक के साथ अधिक सहज महसूस कर सकते हैं, जो कई क्षेत्रों में इस प्रकार की अपेक्षा को पूरा करता है।

Answer 14

int number = Question.Role.GetHashCode();

numberमान होना चाहिए 2।

Comments

— GetHashCode

ध्यान दें कि यह केवल "कानूनी" है bool*, byte, ushort, int, और uint**। अन्य प्रकार के लिए GetHashCode मान को संशोधित करता है, उदाहरण के लिए कुछ बिटशिफ्ट और एक्सर्स करता है। (* 1/0, ** बेशक कोर्स के लिए डाली)। लेकिन यह सब सिर्फ तब तक नहीं होता जब तक कि यह आपका अपना निजी कोड न हो।

— anorZaken

Answer 15

आप अपने परिभाषित एनम प्रकार के लिए एक एक्सटेंशन विधि लागू करके ऐसा कर सकते हैं :

public static class MyExtensions
{
    public static int getNumberValue(this Question questionThis)
    {
        return (int)questionThis;
    }
}

यह वर्तमान एनुम मान का अंतर मान प्राप्त करने को सरल बनाता है:

Question question = Question.Role;
int value = question.getNumberValue();

या

int value = Question.Role.getNumberValue();

Comments

ब्रोनक, आपने जो किया वह एक (नॉन जेनेरिक btw) एक्सटेंशन विधि के माध्यम से अनइनफॉर्मेटिव सिंटैक्स है जो वास्तव में लिखने में अधिक समय लेता है। मैं यह देखने में विफल रहता हूं कि यह टेट्रानुट्रॉन द्वारा मूल समाधान से बेहतर कैसे है। चलिए हम इसे एक चैट में नहीं बनाते हैं, स्टैकओवरफ़्लो में मदद का हमेशा स्वागत है और यहाँ हर कोई मदद करने के लिए है। कृपया मेरी टिप्पणी को रचनात्मक आलोचना के रूप में लें।

— बेंजामिन ग्रुएनबाम

बेंजामिन, सबसे पहले, आपने मेरी टिप्पणी को क्यों हटाया? मैं आपके निर्णयों को नहीं समझता-हो सकता है कि समुदाय के माध्यम से कोई और व्यक्ति मेरी टिप्पणी से सहमत हो। निश्चित रूप से, मेरा समाधान Tetraneutron के एक को लपेटता है और सटीक रूप से यह आसान और कम लेखन है क्योंकि विस्तार विधि IntelliSense द्वारा सुझाई गई है। मुझे लगता है कि आपका निर्णय निष्पक्ष और प्रतिनिधि नहीं है। मैं ढेर पर इसी तरह के जवाब दे रहा हूं और यह ठीक है। वैसे मैं अपने समाधान का उपयोग करता हूं और शायद कुछ लोग भविष्य में मेरे समाधान का चयन करेंगे, लेकिन इन नकारात्मक बिंदुओं को ढूंढना कठिन हो जाता है। अधिकांश यह सही है और प्रतिलिपि नहीं है।

— ब्रोंक

@Bronek यदि आप मुझे पिंग नहीं करते हैं तो मुझे कोई संकेत नहीं मिलता है कि आपने उत्तर दिया है। मैंने आपकी टिप्पणी को नहीं हटाया, मेरे पास क्षमता नहीं है या मैं ऐसा करना चाहता हूं। संभवत: एक मॉड द्वारा आया और इसे हटा दिया गया - मॉडरेटर के ध्यान के लिए इसे फ़्लैग करने के लिए आपका स्वागत है और पूछें कि क्यों या बेहतर है - मेटा स्टाफ़ ओवरफ़्लो पर पूछें । मेरे पास प्रोग्रामिंग स्टैंड पॉइंट से आपके समाधान के बारे में एक राय है जो पूरी तरह से मेरे अधिकार में है - यह वही है जो टिप्पणियों के साथ शुरू करने के लिए है, इसे व्यक्तिगत रूप से लेने की आवश्यकता नहीं है।

— बेंजामिन ग्रुएनबाम

Answer 16

इसके बजाय एक्सटेंशन विधि का उपयोग करें:

public static class ExtensionMethods
{
    public static int IntValue(this Enum argEnum)
    {
        return Convert.ToInt32(argEnum);
    }
}

और उपयोग थोड़ा प्रीतिकर है:

var intValue = Question.Role.IntValue();

Answer 17

public enum Suit : int
{
    Spades = 0,
    Hearts = 1,
    Clubs = 2,
    Diamonds = 3
}

Console.WriteLine((int)(Suit)Enum.Parse(typeof(Suit), "Clubs"));

// From int
Console.WriteLine((Suit)1);

// From a number you can also
Console.WriteLine((Suit)Enum.ToObject(typeof(Suit), 1));

if (typeof(Suit).IsEnumDefined("Spades"))
{
    var res = (int)(Suit)Enum.Parse(typeof(Suit), "Spades");
    Console.Out.WriteLine("{0}", res);
}

Comments

सूट - "10. (कार्ड गेम) रंग और / या विशिष्ट प्रतीक, जैसे हुकुम, दिल, हीरे या पारंपरिक एंग्लो, हिस्पैनिक और फ्रेंच प्लेइंग कार्ड के क्लबों द्वारा प्रतिष्ठित कार्ड के एक सेट के प्रत्येक सेट।"

— पीटर मोर्टेंसन

नमूना कोड का स्पष्टीकरण क्रम में होगा ( आपके उत्तर को संपादित करके , टिप्पणियों में यहां नहीं)।

— पीटर मोर्टेंसन

शून्य आम तौर पर enums में unset / unkown राज्य के लिए आरक्षित होता है, इसे इस तरह परिभाषित करने के लिए असामान्य है

— चाड ग्रांट

Answer 18

उपयोग:

Question question = Question.Role;
int value = question.GetHashCode();

इसका परिणाम होगा value == 2।

यह तभी सही है जब एनम फिट बैठता है a int।

Comments

यह तभी सही है जब एनम intबिल्कुल फिट बैठता है , जैसा कि GetHashCodeएक पूर्णांक देता है।

— आरबी।

Answer 19

चूँकि एनमों को कई आदिम प्रकारों के साथ घोषित किया जा सकता है, किसी भी एनम प्रकार को डालने के लिए एक सामान्य विस्तार विधि उपयोगी हो सकती है।

enum Box
{
    HEIGHT,
    WIDTH,
    DEPTH
}

public static void UseEnum()
{
    int height = Box.HEIGHT.GetEnumValue<int>();
    int width = Box.WIDTH.GetEnumValue<int>();
    int depth = Box.DEPTH.GetEnumValue<int>();
}

public static T GetEnumValue<T>(this object e) => (T)e;

Answer 20

इसके बाद विस्तार विधि है

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;
}

Answer 21

इंट या छोटे एनम के साथ मेरा पसंदीदा हैक:

GetHashCode();

एक एनम के लिए

public enum Test
{
    Min = Int32.MinValue,
    One = 1,
    Max = Int32.MaxValue,
}

इस,

var values = Enum.GetValues(typeof(Test));

foreach (var val in values)
{
    Console.WriteLine(val.GetHashCode());
    Console.WriteLine(((int)val));
    Console.WriteLine(val);
}

आउटपुट

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

अस्वीकरण:

यह लंबे समय के आधार पर एनमों के लिए काम नहीं करता है।

Answer 22

सबसे आसान उपाय जो मैं सोच सकता हूं, वह है Get(int)इस तरह से विधि को ओवरलोड करना :

[modifiers] Questions Get(Question q)
{
    return Get((int)q);
}

जहां [modifiers]आमतौर पर Get(int)विधि के लिए समान हो सकता है । यदि आप Questionsकक्षा को संपादित नहीं कर सकते हैं या किसी कारण से नहीं करना चाहते हैं, तो आप एक्सटेंशन लिखकर विधि को अधिभारित कर सकते हैं:

public static class Extensions
{
    public static Questions Get(this Questions qs, Question q)
    {
        return qs.Get((int)q);
    }
}

Answer 23

उदाहरण मैं "एक एनम से एक 'int' मूल्य प्राप्त करने के लिए" का सुझाव देना चाहूंगा। "

public enum Sample
{
    Book = 1, 
    Pen = 2, 
    Pencil = 3
}

int answer = (int)Sample.Book;

अब जवाब 1 होगा।

Answer 24

उपयोग:

Question question = Question.Role;
int value = Convert.ToInt32(question);

Answer 25

इसे enum में int में बदलने के बजाय इसे आज़माएं:

public static class ReturnType
{
    public static readonly int Success = 1;
    public static readonly int Duplicate = 2;
    public static readonly int Error = -1;        
}

Answer 26

Visual Basic में, यह होना चाहिए:

Public Enum Question
    Role = 2
    ProjectFunding = 3
    TotalEmployee = 4
    NumberOfServers = 5
    TopBusinessConcern = 6
End Enum

Private value As Integer = CInt(Question.Role)

Comments

सवाल # सी के लिए है।

— Ctrl S

शीर्षक कहता है "सी # में एनम से अंतर मूल्य प्राप्त करें" ।

— पीटर मोर्टेंसन

Answer 27

मैं इस विस्तार विधि के साथ आया था जिसमें वर्तमान भाषा सुविधाएँ शामिल हैं। डायनेमिक का उपयोग करके, मुझे इसे एक सामान्य विधि बनाने की आवश्यकता नहीं है और उस प्रकार को निर्दिष्ट करें जो कि आह्वान को सरल और सुसंगत बनाए रखता है:

public static class EnumEx
{
    public static dynamic Value(this Enum e)
    {
        switch (e.GetTypeCode())
        {
            case TypeCode.Byte:
            {
                return (byte) (IConvertible) e;
            }

            case TypeCode.Int16:
            {
                return (short) (IConvertible) e;
            }

            case TypeCode.Int32:
            {
                return (int) (IConvertible) e;
            }

            case TypeCode.Int64:
            {
                return (long) (IConvertible) e;
            }

            case TypeCode.UInt16:
            {
                return (ushort) (IConvertible) e;
            }

            case TypeCode.UInt32:
            {
                return (uint) (IConvertible) e;
            }

            case TypeCode.UInt64:
            {
                return (ulong) (IConvertible) e;
            }

            case TypeCode.SByte:
            {
                return (sbyte) (IConvertible) e;
            }
        }

        return 0;
    }

Comments

कृपया नहीं, आप एक पंक्ति में यह सब कर सकते हैं Convert.Changetype (e, e.GetTypeCode ()) और एक ऑब्जेक्ट वापस प्राप्त करें, डायनेमिक्स या एक्सटेंशन विधि की कोई आवश्यकता नहीं है

— चाड अनुदान

मैं कन्वर्ट का उपयोग करने से असहमत हूं। बस एक कास्ट का उपयोग करना आसान होगा। मेरा इरादा किसी भी का उपयोग किए बिना किसी भी एनम को इसके मूल्य में परिवर्तित करने में सक्षम होना था। यह सभी संबंधित जातियों को बदलने के लिए enum प्रकार wihtout को बदलने की अनुमति देता है - लेकिन ऐसा कब होता है? विस्तार विधि सही ढंग से काम करती है। हालाँकि, मैं इसके साथ एक मुद्दा रख रहा हूं, क्योंकि यह गतिशील है, कंपाइलर (पूरे विवरण के लिए स्पष्ट रूप से) टाइप नहीं कर सकता है, जिसका अर्थ है कि टाइप चेकिंग तब होती है जब कोई अच्छा समाधान नहीं होता है। मुझे लगता है कि मैं जातियों में वापस जाऊंगा।

— जेफ

मैंने यह नहीं कहा कि इसे कलाकारों के ऊपर प्रयोग करें, बस यह कोड निरर्थक है और कुछ भी पूरा नहीं करता है, वास्तव में समस्या को और बदतर बनाता है। मैं इस समाधान को हटाने की सिफारिश करूंगा

— चाड अनुदान