C # nhị phân

Có cách nào để viết các chữ nhị phân trong C #, như tiền tố thập lục phân với 0x không? 0b không hoạt động.

Nếu không, một cách dễ dàng để làm điều đó là gì? Một số loại chuyển đổi chuỗi?

C # 7.0 hỗ trợ chữ nhị phân (và dấu tách chữ số tùy chọn thông qua các ký tự gạch dưới).

Một ví dụ:

int myValue = 0b0010_0110_0000_0011;

Bạn cũng có thể tìm thêm thông tin trên trang Roslyn GitHub .

Cập nhật

C # 7.0 hiện có chữ nhị phân, thật tuyệt vời.

[Flags]
enum Days
{
    None = 0,
    Sunday    = 0b0000001,
    Monday    = 0b0000010,   // 2
    Tuesday   = 0b0000100,   // 4
    Wednesday = 0b0001000,   // 8
    Thursday  = 0b0010000,   // 16
    Friday    = 0b0100000,   // etc.
    Saturday  = 0b1000000,
    Weekend = Saturday | Sunday,
    Weekdays = Monday | Tuesday | Wednesday | Thursday | Friday
}

Bài gốc

Vì chủ đề dường như đã chuyển sang khai báo các giá trị cờ dựa trên bit trong enums, tôi nghĩ rằng sẽ rất đáng để chỉ ra một mẹo hữu ích cho loại điều này. Toán tử shift trái ( <<) sẽ cho phép bạn đẩy một chút đến vị trí nhị phân cụ thể. Kết hợp điều đó với khả năng khai báo các giá trị enum theo các giá trị khác trong cùng một lớp và bạn có một cú pháp khai báo rất dễ đọc cho các enum cờ bit.

[Flags]
enum Days
{
    None        = 0,
    Sunday      = 1,
    Monday      = 1 << 1,   // 2
    Tuesday     = 1 << 2,   // 4
    Wednesday   = 1 << 3,   // 8
    Thursday    = 1 << 4,   // 16
    Friday      = 1 << 5,   // etc.
    Saturday    = 1 << 6,
    Weekend     = Saturday | Sunday,
    Weekdays    = Monday | Tuesday | Wednesday | Thursday | Friday
}

Chỉ có số nguyên và hex trực tiếp, tôi sợ (ECMA 334v4):

9.4.4.2 Chữ số nguyên Chữ nguyên được sử dụng để viết các giá trị của các kiểu int, uint, long và ulong. Chữ nguyên có hai dạng có thể: thập phân và thập lục phân.

Để phân tích cú pháp, bạn có thể sử dụng:

int i = Convert.ToInt32("01101101", 2);

Thêm vào câu trả lời của @ StriplingWar Warrior về cờ bit trong enums, có một quy ước dễ dàng mà bạn có thể sử dụng theo hệ thập lục phân để đếm ngược lên trên qua các ca bit. Sử dụng chuỗi 1-2-4-8, di chuyển một cột sang trái và lặp lại.

[Flags]
enum Scenery
{
  Trees   = 0x001, // 000000000001
  Grass   = 0x002, // 000000000010
  Flowers = 0x004, // 000000000100
  Cactus  = 0x008, // 000000001000
  Birds   = 0x010, // 000000010000
  Bushes  = 0x020, // 000000100000
  Shrubs  = 0x040, // 000001000000
  Trails  = 0x080, // 000010000000
  Ferns   = 0x100, // 000100000000
  Rocks   = 0x200, // 001000000000
  Animals = 0x400, // 010000000000
  Moss    = 0x800, // 100000000000
}

Quét xuống bắt đầu với cột bên phải và chú ý mẫu 1-2-4-8 (ca) 1-2-4-8 (ca) ...

Để trả lời câu hỏi ban đầu, tôi đề nghị thứ hai @ Sahuagin sử dụng các chữ thập lục phân. Nếu bạn đang làm việc với các số nhị phân thường đủ để điều này trở thành mối quan tâm, thì đáng để bạn sử dụng hệ thập lục phân.

Nếu bạn cần xem số nhị phân trong mã nguồn, tôi khuyên bạn nên thêm nhận xét bằng chữ nhị phân như tôi có ở trên.

Bạn luôn có thể tạo các ký tự gần đúng, các hằng số chứa giá trị bạn theo sau:

const int b001 = 1;
const int b010 = 2;
const int b011 = 3;
// etc ...
Debug.Assert((b001 | b010) == b011);

Nếu bạn sử dụng chúng thường xuyên thì bạn có thể bọc chúng trong một lớp tĩnh để sử dụng lại.

Tuy nhiên, ngoài chủ đề, nếu bạn có bất kỳ ngữ nghĩa nào liên quan đến các bit (được biết tại thời điểm biên dịch), tôi sẽ đề nghị sử dụng Enum thay thế:

enum Flags
{ 
    First = 0,
    Second = 1,
    Third = 2,
    SecondAndThird = 3
}
// later ...
Debug.Assert((Flags.Second | Flags.Third) == Flags.SecondAndThird);

Nếu bạn xem trạng thái triển khai tính năng ngôn ngữ của Nền tảng trình biên dịch .NET ("Roslyn"), bạn có thể thấy rõ rằng trong C # 6.0, đây là một tính năng được lên kế hoạch, vì vậy trong phiên bản tiếp theo, chúng tôi có thể thực hiện theo cách thông thường.

string sTable="static class BinaryTable\r\n{";
string stemp = "";
for (int i = 0; i < 256; i++)
{
stemp = System.Convert.ToString(i, 2);
while(stemp.Length<8) stemp = "0" + stemp;
sTable += "\tconst char nb" + stemp + "=" + i.ToString() + ";\r\n";
}
sTable += "}";
Clipboard.Clear();
Clipboard.SetText ( sTable);
MessageBox.Show(sTable);

Sử dụng cái này, đối với nhị phân 8 bit, tôi sử dụng cái này để tạo một lớp tĩnh và nó đặt nó vào bảng tạm .. Sau đó, nó được dán vào dự án và thêm vào phần Sử dụng, vì vậy mọi thứ với nb001010 đều được lấy ra khỏi một bảng, tại ít tĩnh nhất, nhưng vẫn ... Tôi sử dụng C # cho rất nhiều mã hóa đồ họa PIC và sử dụng 0b101010 rất nhiều trong Hi-Tech C

- mẫu từ mã outpt--

static class BinaryTable
{   const char nb00000000=0;
    const char nb00000001=1;
    const char nb00000010=2;
    const char nb00000011=3;
    const char nb00000100=4;
//etc, etc, etc, etc, etc, etc, etc, 
}

:-) CẦN

Tính năng nhị phân không được triển khai trong C # 6.0 & Visual Studio 2015. nhưng vào ngày 30 tháng 3 năm 2016, Microsoft đã công bố phiên bản mới của Visual Studio '15' Preview mà chúng ta có thể sử dụng các chữ nhị phân.

Chúng ta có thể sử dụng một hoặc nhiều ký tự gạch dưới (_) cho dấu tách chữ số. vì vậy đoạn mã sẽ trông giống như:

int x           = 0b10___10_0__________________00; //binary value of 80
int SeventyFive = 0B100_________1011; //binary value of 75

WriteLine($" {x} \n {SeventyFive}");

và chúng ta có thể sử dụng 0b và 0B như trong đoạn mã trên.

nếu bạn không muốn sử dụng dấu tách chữ số, bạn có thể sử dụng nó mà không cần dấu tách chữ số như đoạn mã dưới đây

int x           = 0b1010000; //binary value of 80
int SeventyFive = 0B1001011; //binary value of 75

WriteLine($" {x} \n {SeventyFive}");

Mặc dù không thể sử dụng bằng chữ, nhưng có lẽ BitConverter cũng có thể là một giải pháp?

Mặc dù giải pháp phân tích cú pháp chuỗi là phổ biến nhất, tôi không thích nó, bởi vì chuỗi phân tích cú pháp có thể là một hiệu suất tuyệt vời trong một số trường hợp.

Khi cần một loại mặt nạ bitfield hoặc nhị phân, tôi muốn viết nó như thế

bitMask dài = 1011001;

Và sau đó

int bit5 = BitField.GetBit (bitMask, 5);

Hoặc là

cờ bool5 = BitField.GetFlag (bitMask, 5); `

Lớp BitField ở đâu

public static class BitField
{
    public static int GetBit(int bitField, int index)
    {
        return (bitField / (int)Math.Pow(10, index)) % 10;
    }

    public static bool GetFlag(int bitField, int index)
    {
        return GetBit(bitField, index) == 1;
    }
}

Bạn có thể sử dụng 0b000001kể từ Visual Studio 2017 (C # 7.0)

Về cơ bản, tôi nghĩ câu trả lời là KHÔNG, không có cách nào dễ dàng. Sử dụng hằng số thập phân hoặc thập lục phân - chúng đơn giản và rõ ràng. Câu trả lời @RoyTinkers cũng tốt - sử dụng một nhận xét.

int someHexFlag = 0x010; // 000000010000
int someDecFlag = 8;     // 000000001000

Các câu trả lời khác ở đây trình bày một số công việc hữu ích - một vòng, nhưng tôi nghĩ chúng không tốt hơn câu trả lời đơn giản. Các nhà thiết kế ngôn ngữ C # có thể coi tiền tố '0b' là không cần thiết. HEX dễ dàng chuyển đổi thành nhị phân, và hầu hết các lập trình viên sẽ phải biết tương đương tháng 12 của 0-8.

Ngoài ra, khi kiểm tra các giá trị trong trình gỡ lỗi, chúng sẽ được hiển thị có HEX hoặc DEC.