Sử dụng mặt nạ bit trong C #

Giả sử tôi có những thứ sau

int susan = 2; //0010
int bob = 4; //0100
int karen = 8; //1000

và tôi chuyển 10 (8 + 2) làm tham số cho một phương thức và tôi muốn giải mã điều này có nghĩa là susan và karen

Tôi biết rằng 10 là 1010

nhưng làm thế nào tôi có thể thực hiện một số logic để xem liệu một bit cụ thể có được kiểm tra như trong

if (condition_for_karen) // How to quickly check whether effective karen bit is 1

Ngay bây giờ, tất cả những gì tôi có thể nghĩ là kiểm tra xem số tôi đã vượt qua là

14 // 1110
12 // 1100
10 // 1010
8 //  1000

Khi tôi có số lượng bit thực lớn hơn trong kịch bản thế giới thực của mình, điều này có vẻ không thực tế, cách tốt hơn là sử dụng mặt nạ để kiểm tra xem liệu tôi có đáp ứng điều kiện chỉ karen hay không?

Tôi có thể nghĩ đến việc chuyển sang trái rồi quay lại sau đó chuyển sang phải rồi quay lại các bit rõ ràng khác với các bit mà tôi quan tâm, nhưng điều này cũng có vẻ quá phức tạp.

Cách truyền thống để làm điều này là sử dụng Flagsthuộc tính trên enum:

[Flags]
public enum Names
{
    None = 0,
    Susan = 1,
    Bob = 2,
    Karen = 4
}

Sau đó, bạn kiểm tra một tên cụ thể như sau:

Names names = Names.Susan | Names.Bob;

// evaluates to true
bool susanIsIncluded = (names & Names.Susan) != Names.None;

// evaluates to false
bool karenIsIncluded = (names & Names.Karen) != Names.None;

Các kết hợp theo từng bit logic có thể khó nhớ, vì vậy tôi tự làm cho cuộc sống trở nên dễ dàng hơn với một FlagsHelperlớp học *:

// The casts to object in the below code are an unfortunate necessity due to
// C#'s restriction against a where T : Enum constraint. (There are ways around
// this, but they're outside the scope of this simple illustration.)
public static class FlagsHelper
{
    public static bool IsSet<T>(T flags, T flag) where T : struct
    {
        int flagsValue = (int)(object)flags;
        int flagValue = (int)(object)flag;

        return (flagsValue & flagValue) != 0;
    }

    public static void Set<T>(ref T flags, T flag) where T : struct
    {
        int flagsValue = (int)(object)flags;
        int flagValue = (int)(object)flag;

        flags = (T)(object)(flagsValue | flagValue);
    }

    public static void Unset<T>(ref T flags, T flag) where T : struct
    {
        int flagsValue = (int)(object)flags;
        int flagValue = (int)(object)flag;

        flags = (T)(object)(flagsValue & (~flagValue));
    }
}

Điều này sẽ cho phép tôi viết lại đoạn mã trên dưới dạng:

Names names = Names.Susan | Names.Bob;

bool susanIsIncluded = FlagsHelper.IsSet(names, Names.Susan);

bool karenIsIncluded = FlagsHelper.IsSet(names, Names.Karen);

Lưu ý rằng tôi cũng có thể thêm Karenvào tập hợp bằng cách thực hiện điều này:

FlagsHelper.Set(ref names, Names.Karen);

Và tôi có thể xóa Susantheo cách tương tự:

FlagsHelper.Unset(ref names, Names.Susan);

_{* Như Porges chỉ ra, tương đương với các IsSetphương pháp trên đã tồn tại trong .NET 4.0: Enum.HasFlag. Tuy nhiên Set, Unsetcác phương thức và phương thức dường như không tương đương nhau; vì vậy tôi vẫn muốn nói rằng lớp này có một số điểm đáng khen.}

Lưu ý: Sử dụng enums chỉ là cách thông thường để giải quyết vấn đề này. Bạn hoàn toàn có thể dịch tất cả mã trên để sử dụng int thay thế và nó sẽ hoạt động tốt.

if ( ( param & karen ) == karen )
{
  // Do stuff
}

Bitwise 'và' sẽ che khuất mọi thứ ngoại trừ bit "đại diện" cho Karen. Miễn là mỗi người được đại diện bởi một vị trí bit, bạn có thể kiểm tra nhiều người bằng cách đơn giản:

if ( ( param & karen ) == karen )
{
  // Do Karen's stuff
}
if ( ( param & bob ) == bob )
  // Do Bob's stuff
}

Tôi đã bao gồm một ví dụ ở đây minh họa cách bạn có thể lưu trữ mặt nạ trong cột cơ sở dữ liệu dưới dạng số nguyên và cách bạn sẽ khôi phục mặt nạ sau này:

public enum DaysBitMask { Mon=0, Tues=1, Wed=2, Thu = 4, Fri = 8, Sat = 16, Sun = 32 }


DaysBitMask mask = DaysBitMask.Sat | DaysBitMask.Thu;
bool test;
if ((mask & DaysBitMask.Sat) == DaysBitMask.Sat)
    test = true;
if ((mask & DaysBitMask.Thu) == DaysBitMask.Thu)
    test = true;
if ((mask & DaysBitMask.Wed) != DaysBitMask.Wed)
    test = true;

// Store the value
int storedVal = (int)mask;

// Reinstate the mask and re-test
DaysBitMask reHydratedMask = (DaysBitMask)storedVal;

if ((reHydratedMask & DaysBitMask.Sat) == DaysBitMask.Sat)
    test = true;
if ((reHydratedMask & DaysBitMask.Thu) == DaysBitMask.Thu)
    test = true;
if ((reHydratedMask & DaysBitMask.Wed) != DaysBitMask.Wed)
    test = true;

Để kết hợp các mặt nạ bit, bạn muốn sử dụng bitwise- hoặc . Trong trường hợp nhỏ mà mỗi giá trị bạn kết hợp có chính xác 1 bit trên (như ví dụ của bạn), điều đó tương đương với việc thêm chúng. Tuy nhiên, nếu bạn có các bit chồng chéo hoặc 'nhập chúng sẽ xử lý trường hợp một cách duyên dáng.

Để giải mã các mặt nạ bit, bạn và giá trị của bạn bằng một mặt nạ, như sau:

if(val & (1<<1)) SusanIsOn();
if(val & (1<<2)) BobIsOn();
if(val & (1<<3)) KarenIsOn();

Cách dễ dàng:

[Flags]
public enum MyFlags {
    None = 0,
    Susan = 1,
    Alice = 2,
    Bob = 4,
    Eve = 8
}

Để đặt cờ, hãy sử dụng toán tử logic "hoặc" |:

MyFlags f = new MyFlags();
f = MyFlags.Alice | MyFlags.Bob;

Và để kiểm tra xem cờ có được bao gồm hay không, hãy sử dụng HasFlag:

if(f.HasFlag(MyFlags.Alice)) { /* true */}
if(f.HasFlag(MyFlags.Eve)) { /* false */}

Một lý do thực sự tốt khác để sử dụng bitmask so với bools cá nhân là với tư cách là nhà phát triển web, khi tích hợp trang web này với trang web khác, chúng tôi thường xuyên cần gửi các tham số hoặc cờ trong chuỗi truy vấn. Miễn là tất cả các cờ của bạn là nhị phân, thì việc sử dụng một giá trị duy nhất làm mặt nạ bit đơn giản hơn nhiều so với việc gửi nhiều giá trị dưới dạng bools. Tôi biết có những cách khác để gửi dữ liệu (GET, POST, v.v.), nhưng một tham số đơn giản trên chuỗi truy vấn hầu hết là đủ cho các mục không nhạy cảm. Cố gắng gửi 128 giá trị bool trên một chuỗi truy vấn để giao tiếp với một trang web bên ngoài. Điều này cũng cung cấp thêm khả năng không đẩy giới hạn trên các chuỗi truy vấn url trong trình duyệt