对于不从 0 开始的缓冲区，是否有一种不那么痛苦的 GetBytes 方法？

Question

我必须处理项目中的原始字节，我基本上需要做这样的事情，

byte[] ToBytes(){
  byte[] buffer=new byte[somelength];
  byte[] tmp;
  tmp=BitConverter.GetBytes(SomeShort);
  buffer[0]=tmp[0];
  buffer[1]=tmp[1];
  tmp=BitConverter.GetBytes(SomeOtherShort);
  buffer[2]=tmp[0];
  buffer[3]=tmp[1];
}

我觉得这是非常错误的，但我找不到任何更好的方法来做到这一点。有更简单的方法吗？

Answer 1

BinaryWriter 非常高效：

    byte[] ToBytes() {
        var ms = new MemoryStream(somelength);
        var bw = new BinaryWriter(ms);
        bw.Write(SomeShort);
        bw.Write(SomeOtherShort);
        return ms.ToArray();
    }

Answer 2

您不需要将 tmp 初始化为新数组。 BitConverter.GetBytes 创建一个新数组并为您返回它。对于 GetBytes 您无能为力，但您可以使用 Buffer.BlockCopy 来简化复制操作。

如果您不是在性能关键的代码段中执行此操作，则可以使用一点 LINQy 并执行以下操作：

IEnumerable<byte> bytes = BitConverter.GetBytes(first);
bytes = bytes.Concat(BitConverter.GetBytes(second));
bytes = bytes.Concat(BitConverter.GetBytes(third));
// ... so on; you can chain the calls too
return bytes.ToArray();

Answer 3

如果您事先知道大小（有一组值类型），则可以使用结构体并在结构体中分配值。然后使用不安全代码复制原始字节。我仍然建议不要这样做，除非出于速度目的确实有必要。你可能会认为这很痛苦:)

private struct MyStruct
{
    public short A;
    public short B;

    public MyStruct(short a, short b)
    {
        A = a;
        B = b;
    }
}

private unsafe byte[] UnsafeStruct(MyStruct myStruct)
{
    byte[] buffer = new byte[4]; // where 4 is the size of the struct
    fixed (byte* ptr = buffer)
    {
        *((MyStruct*)ptr) = myStruct;
    }
    return buffer;
}

Answer 4

只是位移位...

buffer[0]=(byte)SomeShort;
buffer[1]=(byte)(SomeShort >> 8);
buffer[2]=(byte)SomeOtherShort;
buffer[3]=(byte)(SomeOtherShort >> 8);

这也意味着您可以完全控制字节序（在本例中为小字节序）

Answer 5

您可以使用 Array.Copy 使代码稍微短一些，但是 BitConverter 中没有任何 GetBytes 重载或等效函数将字节直接放入缓冲区。

也许 BinaryWriter 在 MemoryStream 是您想要的吗？

请注意，如果采用您不喜欢的 BitConverter API 约定，则会给您的班级用户带来同样的问题。相反，编写一个接受 BinaryWriter 并将您的类序列化到其中的方法，当您的类嵌入到其他对象中时，这可以很好地扩展。