Thuộc tính [Cờ] Enum có nghĩa là gì trong C #?

Thỉnh thoảng tôi thấy một enum như sau:

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

Tôi không hiểu chính xác những gì [Flags]thuộc tính làm.

Bất cứ ai có một lời giải thích tốt hoặc ví dụ họ có thể đăng?

Các [Flags]thuộc tính nên được sử dụng bất cứ khi nào đếm được đại diện cho một tập hợp các giá trị có thể, chứ không phải là một giá trị duy nhất. Các bộ sưu tập như vậy thường được sử dụng với các toán tử bitwise, ví dụ:

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

Lưu ý rằng [Flags]thuộc tính không tự kích hoạt tính năng này - tất cả những gì nó làm là cho phép biểu diễn đẹp theo .ToString()phương thức:

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"

Cũng cần lưu ý rằng [Flags] không tự động tạo ra sức mạnh giá trị enum của hai. Nếu bạn bỏ qua các giá trị số, enum sẽ không hoạt động như người ta có thể mong đợi trong các hoạt động theo bit, bởi vì theo mặc định, các giá trị bắt đầu bằng 0 và tăng dần.

Khai báo không chính xác:

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

Các giá trị, nếu được khai báo theo cách này, sẽ là Vàng = 0, Xanh = 1, Đỏ = 2, Xanh = 3. Điều này sẽ khiến nó vô dụng dưới dạng cờ.

Đây là một ví dụ về một tuyên bố chính xác:

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

Để lấy các giá trị riêng biệt trong tài sản của bạn, người ta có thể làm điều này:

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

hoặc trước .NET 4:

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

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

Dưới vỏ bọc

Điều này hoạt động bởi vì bạn đã sử dụng quyền hạn của hai trong bảng liệt kê của bạn. Dưới vỏ bọc, các giá trị liệt kê của bạn trông như thế này trong các số nhị phân và số không:

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

Tương tự như vậy, sau khi bạn đã đặt thuộc tính của mình làCoolors thành màu đỏ, xanh lục và xanh lam bằng cách sử dụng toán |tử nhị phân OR theo bit , cho phépCoolors trông như sau:

myProperties.AllowedColors: 00001110

Vì vậy, khi bạn truy xuất giá trị, bạn thực sự đang thực hiện bitwise VÀ &trên các giá trị:

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

Giá trị Không = 0

Và liên quan đến việc sử dụng 0trong bảng liệt kê của bạn, trích dẫn từ MSDN:

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

Sử dụng Không làm tên của hằng số liệt kê cờ có giá trị bằng không. Bạn không thể sử dụng hằng số liệt kê Không có trong thao tác bitwise để kiểm tra cờ vì kết quả luôn bằng không. Tuy nhiên, bạn có thể thực hiện so sánh logic, không theo bit, giữa giá trị số và hằng số liệt kê Không để xác định xem có bất kỳ bit nào trong giá trị số được đặt hay không.

Bạn có thể tìm thêm thông tin về thuộc tính cờ và cách sử dụng tại msdn và thiết kế cờ tại msdn

Bạn cũng có thể làm điều này

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

Tôi thấy việc dịch chuyển bit dễ dàng hơn so với việc gõ 4,8,16,32, v.v. Nó không ảnh hưởng đến mã của bạn vì tất cả đều được thực hiện vào thời gian biên dịch

Kết hợp các câu trả lời https://stackoverflow.com/a/8462/1037948 (khai báo qua dịch chuyển bit) và https://stackoverflow.com/a/9117/1037948 (sử dụng kết hợp trong khai báo), bạn có thể thay đổi các giá trị trước đó hơn là sử dụng số. Không nhất thiết phải giới thiệu nó, nhưng chỉ cần chỉ ra bạn có thể.

Thay vì:

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

Bạn có thể tuyên bố

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

Xác nhận với LinqPad:

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

Kết quả trong:

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

Vui lòng xem phần sau đây để biết ví dụ cho thấy khai báo và cách sử dụng tiềm năng:

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

Để mở rộng câu trả lời được chấp nhận, trong C # 7, cờ enum có thể được viết bằng chữ nhị phân:

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

Tôi nghĩ rằng đại diện này làm cho nó rõ ràng làm thế nào các cờ hoạt động dưới vỏ bọc .

Tôi hỏi gần đây về một cái gì đó tương tự.

Nếu bạn sử dụng cờ, bạn có thể thêm phương thức mở rộng vào enum để giúp kiểm tra các cờ được chứa dễ dàng hơn (xem bài để biết chi tiết)

Điều này cho phép bạn làm:

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

Sau đó, bạn có thể làm:

PossibleOptions opt = PossibleOptions.OptionOneTwoAndThree 

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

Tôi thấy điều này dễ đọc hơn hầu hết các cách kiểm tra các cờ được bao gồm.

@Nidonocu

Để thêm một cờ khác vào một tập hợp các giá trị hiện có, hãy sử dụng toán tử gán OR.

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

Khi làm việc với cờ tôi thường khai báo thêm Không và Tất cả các mục. Đây là hữu ích để kiểm tra xem tất cả các cờ được đặt hay không có cờ nào được đặt.

[Flags] 
enum SuitsFlags { 

    None =     0,

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

    All =      ~(~0 << 4)

}

Sử dụng:

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

 
Cập nhật 2019-10:

Vì C # 7.0, bạn có thể sử dụng các chữ nhị phân, có thể trực quan hơn để đọc:

[Flags] 
enum SuitsFlags { 

    None =     0b0000,

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

    All =      0b1111

}

Để thêm Mode.Write:

Mode = Mode | Mode.Write;

Có điều gì đó quá dài dòng đối với tôi về if ((x & y) == y)...cấu trúc, đặc biệt nếu xAND ylà cả hai bộ cờ ghép và bạn chỉ muốn biết nếu có bất kỳ sự chồng chéo .

Trong trường hợp này, tất cả những gì bạn thực sự cần biết là nếu có một giá trị khác không [1] sau khi bạn bitmasked .

[1] Xem bình luận của Jaime. Nếu chúng tôi xác thực bitmasking , chúng tôi chỉ cần kiểm tra xem kết quả có khả quan không. Nhưng kể từ enums có thể là tiêu cực, thậm chí, kỳ lạ, khi kết hợp với các [Flags] thuộc tính , đó là phòng thủ để mã cho != 0hơn > 0.

Xây dựng thiết lập của @ andnil ...

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

Cờ cho phép bạn sử dụng bitmasking bên trong bảng liệt kê của bạn. Điều này cho phép bạn kết hợp các giá trị liệt kê, trong khi vẫn giữ lại các giá trị được chỉ định.

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

Xin lỗi nếu ai đó đã nhận thấy kịch bản này. Một ví dụ hoàn hảo về cờ chúng ta có thể thấy trong sự phản chiếu. Có Binding Flag 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

Sử dụng

             // 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 [] {});