C# Binary Literals

C# binary literals

C# 7.0 supports binary literals (and optional digit separators via underscore characters).

An example:

int myValue = 0b0010_0110_0000_0011;

You can also find more information on the Roslyn GitHub page.

C# binary constants representation

As of C#7 you can represent a binary literal value in code:

private static void BinaryLiteralsFeature()
{
    var employeeNumber = 0b00100010; //binary equivalent of whole number 34. Underlying data type defaults to System.Int32
    Console.WriteLine(employeeNumber); //prints 34 on console.
    long empNumberWithLongBackingType = 0b00100010; //here backing data type is long (System.Int64)
    Console.WriteLine(empNumberWithLongBackingType); //prints 34 on console.
    int employeeNumber_WithCapitalPrefix = 0B00100010; //0b and 0B prefixes are equivalent.
    Console.WriteLine(employeeNumber_WithCapitalPrefix); //prints 34 on console.
}

Further information can be found here.

Binary notation for writing bits - C#

as of c# 6 c# 7 you can use 0b prefix to get binary similar to the 0x for hex

int x           = 0b1010000; //binary value of 80
int seventyFive = 0b1001011; //binary value of 75

give it a shot

Why does the new feature binary literals start with 0b instead of being suffixed?

Integer literals possess two varying properties: their types, which can be specified with suffixes like L or UL, and their radices (called "forms" in the documentation), which can be specified with prefixes like 0x and now 0b.

Specifying a type was always done through a suffix, and specifying a radix was always done through a prefix, so it makes sense to keep the same convention. In addition, you can combine both specifiers.

For instance:

0b00101010UL

Would denote the literal 42, stored as an unsigned long, and expressed in radix 2.

binary number represented in a long variable in c#

I dont think there is any such representation in C#

From the ECMA script

9.4.4.2 Integer literals Integer literals are used to write values of types int, uint, long, and ulong. Integer literals have two possible
forms: decimal and hexadecimal.

Also check .NET Compiler Platform ("Roslyn")

Probably C# 6.0 will add that feature

C# now tries to help us by introducing a binary literal. Let's start with what we currently have:

var num1 = 1234; //1234
var num2 = 0x1234; //4660

What could possible come now? Here's the answer:

var num3 = 0b1010; //10

Of course binary digits are becoming quite long very fast. This is why a nice separator has been introduced:

var num4 = 0b1100_1010; //202

There can be as many underscores as possible. The underscores can also be connected. And the best thing: Underscores do also work for normal numbers and hex literals:

var num5 = 1_234_567_890; //123456789
var num6 = 0xFF_FA_88_BC; //4294609084
var num7 = 0b10_01__01_10; //150

The only constraint of the underscore is, that of course a number cannot start with it.

Binary literals will make enumerations and bit vectors a little bit easier to understand and handle. It is just more close at what we have been thinking when creating such constructs.

---

Related Topics