c# सी#में[ध्वज] एनम विशेषता का क्या अर्थ है?




enums flags (8)

आप यह भी कर सकते हैं

[Flags]
public enum MyEnum
{
    None   = 0,
    First  = 1 << 0,
    Second = 1 << 1,
    Third  = 1 << 2,
    Fourth = 1 << 3
}

मुझे 4,8,16,32 टाइप करने से थोड़ा सा स्थानांतरण आसान लगता है। इसका आपके कोड पर कोई प्रभाव नहीं पड़ता क्योंकि यह सब संकलन समय पर किया जाता है

समय-समय पर मैं निम्नलिखित की तरह एक enum देखते हैं:

[Flags]
public enum Options 
{
    None    = 0,
    Option1 = 1,
    Option2 = 2,
    Option3 = 4,
    Option4 = 8
}

मुझे समझ में नहीं आता कि वास्तव में [Flags] -ट्रिब्यूट क्या करता है।

किसी के पास एक अच्छा स्पष्टीकरण या उदाहरण है जो वे पोस्ट कर सकते हैं?


if ((x & y) == y)... बारे में मुझे कुछ अधिक वर्बोज़ है if ((x & y) == y)... निर्माण, विशेष रूप से यदि x और y दोनों झंडे के कंपाउंड सेट हैं और आप केवल यह जानना चाहते हैं कि कोई ओवरलैप है या नहीं।

इस मामले में, आपको वास्तव में यह जानने की ज़रूरत है कि यदि आपके पास बिटमास्क किए जाने के बाद गैर-शून्य मान है [1]

[1] जैम की टिप्पणी देखें। अगर हम प्रामाणिक रूप से बिटमैस्किंग कर रहे थे, तो हमें केवल यह जांचना होगा कि परिणाम सकारात्मक था। लेकिन चूंकि enum s नकारात्मक हो सकता है, यहां तक ​​कि अजीब बात है, जब msdn के साथ संयुक्त हो, तो यह != 0 बजाय कोड के लिए रक्षात्मक है != 0

@ एंडिल के सेटअप का निर्माण ...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BitFlagPlay
{
    class Program
    {
        [Flags]
        public enum MyColor
        {
            Yellow = 0x01,
            Green = 0x02,
            Red = 0x04,
            Blue = 0x08
        }

        static void Main(string[] args)
        {
            var myColor = MyColor.Yellow | MyColor.Blue;
            var acceptableColors = MyColor.Yellow | MyColor.Red;

            Console.WriteLine((myColor & MyColor.Blue) != 0);     // True
            Console.WriteLine((myColor & MyColor.Red) != 0);      // False                
            Console.WriteLine((myColor & acceptableColors) != 0); // True
            // ... though only Yellow is shared.

            Console.WriteLine((myColor & MyColor.Green) != 0);    // Wait a minute... ;^D

            Console.Read();
        }
    }
}

@Nidonocu

मानों के मौजूदा सेट में एक और ध्वज जोड़ने के लिए, या असाइनमेंट ऑपरेटर का उपयोग करें।

Mode = Mode.Read;
//Add Mode.Write
Mode |= Mode.Write;
Assert.True(((Mode & Mode.Write) == Mode.Write)
  && ((Mode & Mode.Read) == Mode.Read)));

उत्तरों का संयोजन https://.com/a/8462/1037948 (बिट-स्थानांतरण के माध्यम से घोषणा) और https://.com/a/9117/1037948 (घोषणा में संयोजनों का उपयोग करके) आप पिछले मानों को थोड़ा-सा स्थानांतरित कर सकते हैं संख्याओं का उपयोग करने से। जरूरी नहीं कि यह सिफारिश कर रहा है, लेकिन सिर्फ यह बता रहा है कि आप कर सकते हैं।

बजाय:

[Flags]
public enum Options : byte
{
    None    = 0,
    One     = 1 << 0,   // 1
    Two     = 1 << 1,   // 2
    Three   = 1 << 2,   // 4
    Four    = 1 << 3,   // 8

    // combinations
    OneAndTwo = One | Two,
    OneTwoAndThree = One | Two | Three,
}

आप घोषित कर सकते हैं

[Flags]
public enum Options : byte
{
    None    = 0,
    One     = 1 << 0,       // 1
    // now that value 1 is available, start shifting from there
    Two     = One << 1,     // 2
    Three   = Two << 1,     // 4
    Four    = Three << 1,   // 8

    // same combinations
    OneAndTwo = One | Two,
    OneTwoAndThree = One | Two | Three,
}

लिंककैड के साथ पुष्टि:

foreach(var e in Enum.GetValues(typeof(Options))) {
    string.Format("{0} = {1}", e.ToString(), (byte)e).Dump();
}

का परिणाम:

None = 0
One = 1
Two = 2
OneAndTwo = 3
Three = 4
OneTwoAndThree = 7
Four = 8

Mode.Write जोड़ने के लिए। Mode.Write :

Mode = Mode | Mode.Write;

कृपया उदाहरण के लिए निम्नलिखित देखें जो घोषणा और संभावित उपयोग दिखाता है:

namespace Flags
{
    class Program
    {
        [Flags]
        public enum MyFlags : short
        {
            Foo = 0x1,
            Bar = 0x2,
            Baz = 0x4
        }

        static void Main(string[] args)
        {
            MyFlags fooBar = MyFlags.Foo | MyFlags.Bar;

            if ((fooBar & MyFlags.Foo) == MyFlags.Foo)
            {
                Console.WriteLine("Item has Foo flag set");
            }
        }
    }
}

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

[Flags]
public enum DashboardItemPresentationProperties : long
{
    None = 0,
    HideCollapse = 1,
    HideDelete = 2,
    HideEdit = 4,
    HideOpenInNewWindow = 8,
    HideResetSource = 16,
    HideMenu = 32
}

स्वीकार्य उत्तर के विस्तार में, सी # 7 में बाइनरी अक्षरों का उपयोग करके enum झंडे लिखे जा सकते हैं:

[Flags]
public enum MyColors
{
    None   = 0b0000,
    Yellow = 0b0001,
    Green  = 0b0010,
    Red    = 0b0100,
    Blue   = 0b1000
}

मुझे लगता है कि यह प्रतिनिधित्व यह स्पष्ट करता है कि झंडे कवर के नीचे कैसे काम करते हैं







flags