Запись чисел в коде в двоичном виде. - .NET

А можно-ли в C# представлять числа в двоичном виде на подобии как в C? Т.е. просто что-то типа

int x = 0b00010000;

а не городить конструкции:

int x = Convert.ToInt32("00010000", 2);

для красоты и упрощеня читабельности.

... << My edition based on RSDN@Home 1.2.0 alpha 4 rev. 1481 >>

Здравствуйте, stele, Вы писали:

S>А можно-ли в C# представлять числа в двоичном виде на подобии как в C? Т.е. просто что-то типа
S>

S>int x = 0b00010000;
S>

    public static class StringEx
    {
        public static Int32 b(this String input)
        {
            return Convert.ToInt32(input, 2);
        }
    }

        static void Main()
        {
            Int32 a = "00010000".b();
        }

Здравствуйте, stele, Вы писали:

S>А можно-ли в C# представлять числа в двоичном виде на подобии как в C?

В D — можно, но в Си?..

Здравствуйте, Qbit86, Вы писали:

Q>В D — можно, но в Си?..

Ну я в Сях не большой знаток, но в Си для AVR8 такая бинарная запись чисел употребляется. И иногда удобна для, как это правильно наывается, битовых полей. Ну когда по сути это не число, а некий набор бит.

... << My edition based on RSDN@Home 1.2.0 alpha 4 rev. 1481 >>

Здравствуйте, stele, Вы писали:

S>А можно-ли в C# представлять числа в двоичном виде на подобии как в C? Т.е. просто что-то типа
S>

S>int x = 0b00010000;
S>

S>а не городить конструкции:
S>

S>int x = Convert.ToInt32("00010000", 2);
S>

S>для красоты и упрощеня читабельности.

По аналогии с С++. Можно сделать такой класс:

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;

Здравствуйте, stele, Вы писали:

S>А можно-ли в C# представлять числа в двоичном виде на подобии как в C? Т.е. просто что-то типа
S>

S>int x = 0b00010000;
S>

S>а не городить конструкции:
S>

S>int x = Convert.ToInt32("00010000", 2);
S>

S>для красоты и упрощеня читабельности.

А шестнадцатеричные константы не устраивают ? Это не так уж сложно — в уме перевести их в двоичные.

Интересно, но пожалуй мне вариант QrystaL будет поудобнее — попроще копипастить виз аврсдудию.

... << My edition based on RSDN@Home 1.2.0 alpha 4 rev. 1481 >>

Здравствуйте, Pavel Dvorkin, Вы писали:

PD>А шестнадцатеричные константы не устраивают ? Это не так уж сложно — в уме перевести их в двоичные.

Это маски символов для алфавита 16-сегментного индикатора. Уж больно много переводить. Да и не наглядно, если вдруг поэкспериментировать с начертанием.

... << My edition based on RSDN@Home 1.2.0 alpha 4 rev. 1481 >>

От:	stele	www.stele.su
Дата:	13.02.11 22:02
Оценка:

	От:	QrystaL
	Дата:	13.02.11 22:20
	Оценка:	8 (1)

От:	Qbit86	https://twitter.com/qbit86
Дата:	13.02.11 22:32
Оценка:

От:	stele	www.stele.su
Дата:	13.02.11 22:48
Оценка:

От:	sergey_shandar	http://getboost.codeplex.com/
Дата:	14.02.11 02:59
Оценка:	23 (5)

	От:	Pavel Dvorkin
	Дата:	14.02.11 06:36
	Оценка:	1 (1)