Question

如何在不使用

的情况下在代码中编写二进制数

Convert.ToInt16("00001000", 2);

我希望它非常快，我不想从字符串中读取数字。有没有更快的方法？

Answer 1

来自C＃语言规范：

2.4.4.2整数文字

整数文字用于编写   类型int，uint，long和的值   ULONG。整数文字有两个   可能的形式：十进制和   十六进制。

你可以按照自己的方式去做：

Convert.ToInt16("00001000", 2);

或以十六进制格式表示数字，例如使用0x前缀，如：

0x8

我不知道其他任何方式。

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;

在CityLizard Framework (CityLizard.Binary.dll)中实施。

我可以用二进制而不是十六进制嵌入数字吗？

4 个答案: