[झंडे] विशेषता के साथ सी # Enums को परिभाषित करने के कई तरीके?

Question

मैं समझता हूँ कि कैसे Enums सी # में काम करते हैं, और मैं क्या झंडे विशेषता तालिका में लाता है मिलता है।

मैं, here इस सवाल को देखा। जो पहले स्वाद की सिफारिश करता है, लेकिन इसके लिए कोई कारण/औचित्य प्रदान नहीं करता है।

वहाँ जिस तरह इन दोनों परिभाषित कर रहे हैं में एक फर्क है, एक दूसरे से बेहतर है? दूसरे के बजाय पहले सिंकैक्स का उपयोग करने के क्या फायदे हैं? फ्लैग टाइप एनम्स को परिभाषित करते समय मैंने हमेशा दूसरे स्वाद का उपयोग किया है ... क्या मैं इस बार गलत कर रहा हूं?

[Serializable] 
[Flags] 
public enum SiteRoles 
{ 
    User = 1 << 0, 
    Admin = 1 << 1, 
    Helpdesk = 1 << 2 
} 

है कि नहीं एक ही

[Serializable] 
[Flags] 
public enum SiteRoles 
{ 
    User = 1, 
    Admin = 2, 
    Helpdesk = 4 
} 

Answer 1

पहले एक साथ मुख्य लाभ यह है कि आप प्रत्येक ध्वज के लिए सही मूल्यों की गणना करने के बाद से संकलक यह तुम्हारे लिए क्या होगा की आवश्यकता नहीं है। इसके अलावा वे वही हैं।

Answer 2

के रूप में अपनी AFAIK एक पठनीयता बहस। कुछ लोग कहते हैं कि पहला अधिक पठनीय है क्योंकि आपके पास '< <' के दाईं ओर ध्वज की वास्तविक अनुक्रमणिका है।

Answer 3

अधिक जटिल नमूने पर विचार करें:

[Flags] 
public enum SiteRoles 
{ 
    User = 1 << 12, 
    Admin = 1 << 13, 
    Helpdesk = 1 << 15, 
    AdvancedUser = User | Helpdesk, //or (1<<12)|(1<<13) 
} 

[Flags] 
public enum SiteRoles 
{ 
    User = 4096, //not so obvious! 
    Admin = 8192, 
    Helpdesk = 16384, 
    AdvancedUser = 12288, //! 
} 

[Flags] 
public enum SiteRoles 
{ 
    User = 0x1000, //we can use hexademical digits 
    Admin = 0x2000, 
    Helpdesk = 0x4000, 
    AdvancedUser = 0x3000, //it much simpler calculate binary operator OR with hexademicals 
} 

इस नमूने से पता चलता इस मामले पहले संस्करण में बहुत अधिक पठनीय है। दशमलव शाब्दिक ध्वज स्थिरांक का प्रतिनिधित्व करने का सबसे अच्छा तरीका नहीं है। और बिटवाईड ऑपरेशंस के बारे में अधिक जानकारी के लिए (जिसे ध्वज स्थिरांक का प्रतिनिधित्व करने के लिए भी इस्तेमाल किया जा सकता है) देखें http://en.wikipedia.org/wiki/Bitwise_operation

Answer 4

ऐसा करने का एक और तरीका है जो इसे सुरुचिपूर्ण है और इसलिए मैंने सोचा कि मैं हाल ही में कुछ साझा करता हूं। इसका बहुत कम गणित की आवश्यकता है और इसलिए मुझे लगता है कि यह कम त्रुटि प्रवण है। यह बहुत पठनीय है, आईएमएचओ।

[Flags][Serializable] 
public enum ScopeType : int 
{ 
    Unknown = 0, 
    Global = 1, 
    Namespace = Global << 1, 
    Class = Namespace << 1, 
    Struct = Class << 1, 
    Interface = Struct << 1, 
    Enum = Interface << 1, 
    Function = Enum << 1, 
    Property = Function << 1, 
    PropertyGetter = Property << 1, 
    PropertySetter = PropertyGetter << 1, 
    Using = PropertySetter << 1, 
    If = Using << 1, 
    ElseIf = If << 1, 
    Else = ElseIf << 1, 
    Switch = Else << 1, 
    Case = Switch << 1, 
    For = Case << 1, 
    While = For << 1, 
    DoWhile = While << 1, 
    Lambda = DoWhile << 1, 
    Try = Lambda << 1, 
    Catch = Try << 1, 
    Finally = Catch << 1, 
    Initializer = Finally << 1, 
    Checked = Initializer << 1, 
    Unchecked = Checked << 1, 
    Unsafe = Unchecked << 1, 
    Lock = Unsafe << 1, 
    Fixed = Lock << 1, 

    // I can also group flags together using bitwise-OR. 
    PropertyAccessor = PropertyGetter | PropertySetter, 
    TypeDefinition = Class | Struct | Interface | Enum, 
    TryCatchFinally = Try | Catch | Finally, 
    Conditional = If | ElseIf | Else, 
    Branch = Conditional | Case | TryCatchFinally, 
    Loop = For | While | DoWhile 
} 

नोट: के बाद से गणन System.Int32 से विरासत, मैं केवल 32 झंडे परिभाषित कर सकते हैं। आप अधिक की जरूरत है तुम सिर्फ बूलियन मूल्यों का एक समूह के साथ एक वर्ग बनाने के एक बड़े पूर्णांक (System.Int64) का उपयोग करने, एक से अधिक गणन बनाने और उन्हें एक साथ श्रृंखला होगा, या।