Can I insert a number in binary instead of hexadecimal?

Question

How to write a binary number in code without using

Convert.ToInt16("00001000", 2);

I want it to be very fast, I do not want to read a number from a string. Is there a faster way?

Answer 1

From the C # language specification:

2.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.

You can do it your own way:

Convert.ToInt16("00001000", 2);

Or a representation of a number in hexadecimal format, for example, using a prefix 0x, as in:

0x8

I do not know another way.

Answer 2

: 0x8.
Google Calculator .

Answer 3

, , "flags", , . :

[Flags]
enum FlagsEnum
{
    Zero = 0,
    One = 1 << 0,
    Two = 1 << 1,
    Four = 1 << 2,
    Eight = 1 << 3,
    Sixteen = 1 << 4,
    ThirtyTwo = 1 << 5,
    SixtyFour = 1 << 6,
    OneHundredTwentyEight = 1 << 7,
    // etc.
}

, , / .

, "00001000" (1 << 3). - , , , "00101000", ; - (1 << 5) | (1 << 3), .

Answer 4

public static class B
{
    public static readonly V _0000 = 0x0;
    public static readonly V _0001 = 0x1;
    public static readonly V _0010 = 0x2;
    public static readonly V _0011 = 0x3;
    public static readonly V _0100 = 0x4;
    public static readonly V _0101 = 0x5;
    public static readonly V _0110 = 0x6;
    public static readonly V _0111 = 0x7;

    public static readonly V _1000 = 0x8;
    public static readonly V _1001 = 0x9;
    public static readonly V _1010 = 0xA;
    public static readonly V _1011 = 0xB;
    public static readonly V _1100 = 0xC;
    public static readonly V _1101 = 0xD;
    public static readonly V _1110 = 0xE;
    public static readonly V _1111 = 0xF;

    public struct V
    {
        ulong Value;

        public V(ulong value)
        {
            this.Value = value;
        }

        private V Shift(ulong value)
        {
            return new V((this.Value << 4) + value);
        }

        public V _0000 { get { return this.Shift(0x0); } }
        public V _0001 { get { return this.Shift(0x1); } }
        public V _0010 { get { return this.Shift(0x2); } }
        public V _0011 { get { return this.Shift(0x3); } }
        public V _0100 { get { return this.Shift(0x4); } }
        public V _0101 { get { return this.Shift(0x5); } }
        public V _0110 { get { return this.Shift(0x6); } }
        public V _0111 { get { return this.Shift(0x7); } }

        public V _1000 { get { return this.Shift(0x8); } }
        public V _1001 { get { return this.Shift(0x9); } }
        public V _1010 { get { return this.Shift(0xA); } }
        public V _1011 { get { return this.Shift(0xB); } }
        public V _1100 { get { return this.Shift(0xC); } }
        public V _1101 { get { return this.Shift(0xD); } }
        public V _1110 { get { return this.Shift(0xE); } }
        public V _1111 { get { return this.Shift(0xF); } }

        static public implicit operator V(ulong value)
        {
            return new V(value);
        }

        static public implicit operator ulong(V this_)
        {
            return this_.Value;
        }

        static public implicit operator uint(V this_)
        {
            return (uint)this_.Value;
        }

        static public implicit operator ushort(V this_)
        {
            return (ushort)this_.Value;
        }

        static public implicit operator byte(V this_)
        {
            return (byte)this_.Value;
        }
    }
}

:

byte x = B._0010._0011;
ushort y = B._1001._0011._1111._0000;
uint z = B._1001._0011._1111._1000._0011;
ulong d = B._1001._0011._1111._1000._0011._0001;

Implemented in CityLizard Framework (CityLizard.Binary.dll) .