C # හි [ධජ] එනූම් ගුණාංගය අදහස් කරන්නේ කුමක්ද?

වරින් වර මම පහත දැක්වෙන ආකාරයේ එනැමයක් දකිමි:

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

[Flags]ගුණාංගය හරියටම කරන්නේ කුමක්දැයි මට තේරෙන්නේ නැත .

ඕනෑම කෙනෙකුට පළ කළ හැකි හොඳ පැහැදිලි කිරීමක් හෝ උදාහරණයක් තිබේද?

ගණන් [Flags]කළ හැකි අගය එක් අගයකට වඩා හැකි අගයන් එකතුවක් නිරූපණය කරන සෑම අවස්ථාවකම ගුණාංගය භාවිතා කළ යුතුය. එවැනි එකතු කිරීම් බොහෝ විට බිට්වේස් ක්‍රියාකරුවන් සමඟ භාවිතා කරයි, උදාහරණයක් ලෙස:

var allowedColors = MyColor.Red | MyColor.Green | MyColor.Blue;

[Flags]ගුණාංගය මෙය තනිවම සක්‍රීය නොකරන බව සලකන්න - එය කරන්නේ ක්‍රමවේදය අනුව හොඳ නිරූපණයකට ඉඩ දීම පමණි .ToString():

enum Suits { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }
[Flags] enum SuitsFlags { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }

...

var str1 = (Suits.Spades | Suits.Diamonds).ToString();
           // "5"
var str2 = (SuitsFlags.Spades | SuitsFlags.Diamonds).ToString();
           // "Spades, Diamonds"

එනුම් අගයන් දෙකක බලයන් ස්වයංක්‍රීයව සිදු [Flags] නොවන බව සැලකිල්ලට ගැනීම වැදගත්ය . ඔබ සංඛ්‍යාත්මක අගයන් මඟ හැරියහොත්, බිටුස් මෙහෙයුම් වලදී අපේක්ෂා කළ හැකි පරිදි එනුම් ක්‍රියා නොකරනු ඇත, මන්ද පෙරනිමියෙන් අගයන් 0 සහ වර්ධක වලින් ආරම්භ වේ.

වැරදි ප්‍රකාශය:

[Flags]
public enum MyColors
{
    Yellow,  // 0
    Green,   // 1
    Red,     // 2
    Blue     // 3
}

අගයන්, මේ ආකාරයෙන් ප්‍රකාශයට පත් කළහොත්, කහ = 0, කොළ = 1, රතු = 2, නිල් = 3. මෙය කොඩි ලෙස නිෂ් less ල වනු ඇත.

නිවැරදි ප්‍රකාශයක උදාහරණයක් මෙන්න:

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

ඔබේ දේපලෙහි ඇති සුවිශේෂී අගයන් ලබා ගැනීමට කෙනෙකුට මෙය කළ හැකිය:

if (myProperties.AllowedColors.HasFlag(MyColor.Yellow))
{
    // Yellow is allowed...
}

හෝ .NET 4 ට පෙර:

if((myProperties.AllowedColors & MyColor.Yellow) == MyColor.Yellow)
{
    // Yellow is allowed...
}

if((myProperties.AllowedColors & MyColor.Green) == MyColor.Green)
{
    // Green is allowed...
}    

ආවරණ යටතේ

මෙය ක්‍රියාත්මක වන්නේ ඔබ ගණනය කිරීමේදී දෙදෙනෙකුගේ බලතල භාවිතා කළ බැවිනි. ආවරණ යටතේ, ඔබේ ගණන් කිරීමේ අගයන් ද්විමය හා ශුන්‍ය වලින් පෙනේ:

 Yellow: 00000001
 Green:  00000010
 Red:    00000100
 Blue:   00001000

ඒ හා සමානව, ඔබ ද්විමය බිට්වේස් හෝ ක්‍රියාකරු භාවිතා කර ඔබේ දේපල අවසර ලත් රතු, කොළ සහ නිල් ලෙස සකසා ගත් පසු |, අවසර ලත් වර්ණ මේ ආකාරයෙන් පෙනේ:

myProperties.AllowedColors: 00001110

එබැවින් ඔබ අගය නැවත ලබා ගන්නා විට ඔබ සැබවින්ම කරන්නේ බිට්වේස් සහ &අගයන් මත ය:

myProperties.AllowedColors: 00001110
             MyColor.Green: 00000010
             -----------------------
                            00000010 // Hey, this is the same as MyColor.Green!

කිසිවක් නැත = 0 අගය

0එම්එස්ඩීඑන් වෙතින් උපුටා දක්වමින් ඔබේ ගණන් බැලීමේදී භාවිතා කිරීම සම්බන්ධයෙන් :

[Flags]
public enum MyColors
{
    None = 0,
    ....
}

ධජය ගණනය කළ නියතයේ අගය ලෙස ශුන්‍ය වන කිසිවක් භාවිතා නොකරන්න. ධජය සඳහා පරීක්ෂා කිරීම සඳහා ඔබට කිසිවක් ගණනය කළ නියතය බිට්වේස් සහ මෙහෙයුමක භාවිතා කළ නොහැක, මන්ද ප්‍රති result ලය සැමවිටම ශුන්‍ය වේ. කෙසේ වෙතත්, සංඛ්‍යාත්මක අගයේ කිසියම් බිටු සකසා තිබේද යන්න තීරණය කිරීම සඳහා සංඛ්‍යාත්මක අගය සහ කිසිවක් ගණනය කළ නියතය අතර සැසඳීමක් ඔබට තර්කානුකූලව කළ හැකිය.

කොඩි ගුණාංගය සහ එහි භාවිතය පිළිබඳ වැඩි විස්තර msdn හි සහ msdn හි කොඩි සැලසුම් කිරීම පිළිබඳ වැඩි විස්තර ඔබට සොයාගත හැකිය

ඔබට මෙයද කළ හැකිය

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

4,8,16,32 ටයිප් කිරීමට වඩා බිට් මාරුව පහසු බව මට පෙනේ. එය ඔබගේ කේතයට කිසිදු බලපෑමක් ඇති නොකරයි

පිළිතුරු ඒකාබද්ධ කිරීම https://stackoverflow.com/a/8462/1037948 (බිට් මාරුව හරහා ප්‍රකාශනය) සහ https://stackoverflow.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();
}

ප්‍රති Results ල:

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

ප්‍රකාශය සහ විභව භාවිතය පෙන්වන උදාහරණයක් සඳහා කරුණාකර පහත සඳහන් දෑ බලන්න:

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

පිළිගත් පිළිතුරට දීර් extension වශයෙන්, සී # 7 හි එනුම් ධජ ද්විමය වචනාර්ථයෙන් ලිවිය හැකිය:

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

ආවරණ යටතේ කොඩි ක්‍රියා කරන ආකාරය මෙම නිරූපණයෙන් පැහැදිලි වන බව මම සිතමි .

ඒ හා සමාන දෙයක් ගැන මම මෑතකදී ඇසුවෙමි .

ඔබ කොඩි භාවිතා කරන්නේ නම්, අඩංගු කොඩි පරීක්ෂා කිරීම පහසු කිරීම සඳහා ඔබට දිගුවන් ක්‍රමයක් එකතු කළ හැකිය (විස්තර සඳහා ලිපිය බලන්න)

මෙය ඔබට කිරීමට ඉඩ දෙයි:

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

ඇතුළත් කළ කොඩි පරීක්ෂා කිරීමේ බොහෝ ක්‍රමවලට වඩා මෙය කියවීමට පහසු බව මට පෙනේ.

IdNidonocu

පවතින අගයන් සමූහයකට තවත් ධජයක් එක් කිරීමට, හෝ පැවරුම් ක්‍රියාකරු භාවිතා කරන්න.

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

එකතු කිරීමට Mode.Write:

Mode = Mode | Mode.Write;

කොඩි සමඟ වැඩ කරන විට මම බොහෝ විට අතිරේක කිසිවක් සහ සියලුම අයිතම ප්‍රකාශ නොකරමි. සියලුම ධජ සකසා තිබේද නැතහොත් කොඩියක් සකසා නොමැතිදැයි පරීක්ෂා කිරීමට මේවා උපකාරී වේ.

[Flags] 
enum SuitsFlags { 

    None =     0,

    Spades =   1 << 0, 
    Clubs =    1 << 1, 
    Diamonds = 1 << 2, 
    Hearts =   1 << 3,

    All =      ~(~0 << 4)

}

භාවිතය:

Spades | Clubs | Diamonds | Hearts == All  // true
Spades & Clubs == None  // true

 
යාවත්කාලීන කිරීම 2019-10:

C # 7.0 සිට ඔබට ද්විමය සාක්ෂරතා භාවිතා කළ හැකිය, ඒවා කියවීමට වඩා බුද්ධිමත් විය හැකිය:

[Flags] 
enum SuitsFlags { 

    None =     0b0000,

    Spades =   0b0001, 
    Clubs =    0b0010, 
    Diamonds = 0b0100, 
    Hearts =   0b1000,

    All =      0b1111

}

if ((x & y) == y)...ඉදිකිරීම් ගැන මට ඕනෑවට වඩා වාචිකව යමක් තිබේ , විශේෂයෙන් xසහ yදෙකම ධජ සංයුක්ත කට්ටල නම් සහ ඔබට දැන ගැනීමට අවශ්‍ය වන්නේ අතිච්ඡාදනය තිබේද යන්නයි.

මෙම අවස්ථාවේ දී, ඔබ සැබවින්ම දැනගත යුතු වන්නේ ඔබ බිට්මාස්ක් කිරීමෙන් පසු ශුන්‍ය නොවන අගයක් [1] තිබේ නම් පමණි .

[1] ජයිම්ගේ අදහස බලන්න. අප අව්‍යාජව බිට්මාස්ක් කරන්නේ නම් , අපට අවශ්‍ය වන්නේ ප්‍රති result ලය ධනාත්මක දැයි පරීක්ෂා කිරීම පමණි. නමුත් enums negative ණාත්මක විය හැකි බැවින්, අමුතු ලෙස, ගුණාංගය සමඟ සංයෝජනය වන විට[Flags] , එය කේතයට != 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]
public enum DashboardItemPresentationProperties : long
{
    None = 0,
    HideCollapse = 1,
    HideDelete = 2,
    HideEdit = 4,
    HideOpenInNewWindow = 8,
    HideResetSource = 16,
    HideMenu = 32
}

යමෙකු දැනටමත් මෙම තත්වය දැක තිබේ නම් සමාව ඉල්ලන්න. පරාවර්තනයෙන් අපට දැකිය හැකි ධජ පිළිබඳ කදිම නිදසුනකි. ඔව් බන්ධන කොඩි ENUM. https://docs.microsoft.com/en-us/dotnet/api/system.reflection.bindingflags?view=netframework-4.8

[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum BindingFlags

භාවිතය

             // BindingFlags.InvokeMethod
            // Call a static method.
            Type t = typeof (TestClass);

            Console.WriteLine();
            Console.WriteLine("Invoking a static method.");
            Console.WriteLine("-------------------------");
            t.InvokeMember ("SayHello", BindingFlags.InvokeMethod | BindingFlags.Public | 
                BindingFlags.Static, null, null, new object [] {});