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




enums flags (7)

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

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

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

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


@Nidonocu

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

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

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

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

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


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

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
}

मैंने हाल ही में कुछ इसी तरह के बारे में पूछा

यदि आप झंडे का उपयोग करते हैं तो आप निहित झंडे को आसान बनाने के लिए enums के लिए एक एक्सटेंशन विधि जोड़ सकते हैं (विस्तार के लिए पोस्ट देखें)

यह आपको करने की अनुमति देता है:

[Flags]
public enum PossibleOptions : byte
{
    None = 0,
    OptionOne = 1,
    OptionTwo = 2,
    OptionThree = 4,
    OptionFour = 8,

    //combinations can be in the enum too
    OptionOneAndTwo = OptionOne | OptionTwo,
    OptionOneTwoAndThree = OptionOne | OptionTwo | OptionThree,
    ...
}

फिर आप कर सकते हैं:

PossibleOptions opt = PossibleOptions.OptionOneTwoAndThree 

if( opt.IsSet( PossibleOptions.OptionOne ) ) {
    //optionOne is one of those set
}

मुझे शामिल झंडे की जांच के सबसे तरीकों से पढ़ने के लिए यह आसान लगता है।


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

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

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


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




flags