在 C# 中，将 ulong[64] 转换为 byte[512] 更快？

Question

我有一种方法可以在 for 语句中使用二进制移位将 ulong 转换为字节，但它的时间效率不是很高。有没有办法将大小为 64 的 ulong 数组直接转换为大小为 512 的字节数组？这是一段运行数千次的代码，我需要每毫秒保存一次，这样我才能反过来节省秒数。

编辑： 现在这就是我正在做的事情：

                for (int k = 0; k < ulongs.Length; k++) {
                    bytes[(k << 3)] = (byte)(ulongs[k] >> 56);
                    bytes[(k << 3) + 1] = (byte)(ulongs[k] >> 48);
                    bytes[(k << 3) + 2] = (byte)(ulongs[k] >> 40);
                    bytes[(k << 3) + 3] = (byte)(ulongs[k] >> 32);
                    bytes[(k << 3) + 4] = (byte)(ulongs[k] >> 24);
                    bytes[(k << 3) + 5] = (byte)(ulongs[k] >> 16);
                    bytes[(k << 3) + 6] = (byte)(ulongs[k] >> 8);
                    bytes[(k << 3) + 7] = (byte)(ulongs[k]);
                }

Answer 1

unsafe 
{
    fixed (ulong* src = ulongs) 
    {
        Marshal.Copy(new IntPtr((void*)src), bytes, 0, 512);
    }
}

这似乎有效。我不确定是否需要修复，但我在计时测试中损失了一秒。

Answer 2

可能最快的方法是使用unsafe 和fixed 构造。这是一个例子：

ulong[] ulongs = new ulong[64];
byte[] bytes = new byte[512];

unsafe
{
    fixed (ulong* src = ulongs)
    {
        byte* pb = (byte*)src;
        for (int i = 0; i < bytes.Count(); i++)
        {
             bytes[i] = *(pb + i);
        }
    }
}

在编译上述代码时，请不要忘记使用/unsafe编译器开关。

编辑：这是第一个代码片段的修改版本，它在我的机器上运行得更快：

unsafe
{
    fixed (ulong* src = ulongs)
    {
        fixed (byte *dst = bytes)
        {
            ulong* pl = (ulong*)dst;
            for (int i = 0; i < ulongs.Count(); i++)
            {
                *(pl + i) = *(src + i);
            }   
        }
    }
}

Answer 3

您可以使用struct 和使用StructLayout 属性强制变量占据相同空间的显式布局指令来实现此目的。

这样您就可以使用ulong 属性写入值并使用byte 数组属性读取它。当然，这假设 byte 数组确实占用了您期望的空间，并且它没有使用 32 位来保存 8 位信息。我必须在规范中查找，我还没有这样做。

Answer 4

使用 System.Buffer 辅助类。

ulong[] buffer = null;
int byteLength = Buffer.ByteLength(buffer);
byte[] byteBuffer = new byte[byteLength];
Buffer.BlockCopy(buffer, 0, byteBuffer, 0, byteLength);