高效地将字节数组转换为十进制

如果我有一个字节数组并且想要转换该数组的连续 16 字节块，其中包含 .net 的表示形式Decimal, 转化为适当的Decimalstruct，最有效的方法是什么？

在我正在优化的情况下，以下代码在我的分析器中显示为最大的 CPU 消耗者。

public static decimal ByteArrayToDecimal(byte[] src, int offset)
{
    using (MemoryStream stream = new MemoryStream(src))
    {
        stream.Position = offset;
        using (BinaryReader reader = new BinaryReader(stream))
            return reader.ReadDecimal();
    }
}

为了摆脱MemoryStream and BinaryReader，我想喂养一系列BitConverter.ToInt32(src, offset + x)进入Decimal(Int32[])构造函数会比我下面介绍的解决方案更快，但奇怪的是，下面的版本快两倍。

const byte DecimalSignBit = 128;
public static decimal ByteArrayToDecimal(byte[] src, int offset)
{
    return new decimal(
        BitConverter.ToInt32(src, offset),
        BitConverter.ToInt32(src, offset + 4),
        BitConverter.ToInt32(src, offset + 8),
        src[offset + 15] == DecimalSignBit,
        src[offset + 14]);
}

This is 速度提高 10 倍 as the MemoryStream/BinaryReader组合，我用一堆极端值测试了它以确保它有效，但十进制表示并不像其他基本类型那样简单，所以我还不相信它适用于 100% 的可能十进制值。

然而从理论上讲，可能有一种方法可以将这 16 个连续字节复制到内存中的其他位置，并将其声明为 Decimal，而无需任何检查。有人知道这样做的方法吗？

（只有一个问题：虽然小数表示为 16 个字节，但某些可能的值并不构成有效的小数，因此进行未经检查的memcpy可能会破坏东西......）

或者还有其他更快的方法吗？

尽管这是一个老问题，但我有点好奇，所以决定进行一些实验。我们先从实验代码开始。

static void Main(string[] args)
{
    byte[] serialized = new byte[16 * 10000000];

    Stopwatch sw = Stopwatch.StartNew();
    for (int i = 0; i < 10000000; ++i)
    {
        decimal d = i;

        // Serialize
        using (var ms = new MemoryStream(serialized))
        {
            ms.Position = (i * 16);
            using (var bw = new BinaryWriter(ms))
            {
                bw.Write(d);
            }
        }
    }
    var ser = sw.Elapsed.TotalSeconds;

    sw = Stopwatch.StartNew();
    decimal total = 0;
    for (int i = 0; i < 10000000; ++i)
    {
        // Deserialize
        using (var ms = new MemoryStream(serialized))
        {
            ms.Position = (i * 16);
            using (var br = new BinaryReader(ms))
            {
                total += br.ReadDecimal();
            }
        }
    }
    var dser = sw.Elapsed.TotalSeconds;

    Console.WriteLine("Time: {0:0.00}s serialization, {1:0.00}s deserialization", ser, dser);
    Console.ReadLine();
}

Result: Time: 1.68s serialization, 1.81s deserialization。这是我们的基线。我也尝试过Buffer.BlockCopy to an int[4]，这为我们提供了 0.42 秒的反序列化时间。使用问题中描述的方法，反序列化时间降至 0.29 秒。

然而从理论上讲，可能有一种方法可以复制这 16 个连续的 byte 到内存中的其他位置并声明它是 Decimal， 没有任何检查。有人知道这样做的方法吗？

是的，最快的方法是使用不安全的代码，这在这里没问题，因为小数是值类型：

static unsafe void Main(string[] args)
{
    byte[] serialized = new byte[16 * 10000000];

    Stopwatch sw = Stopwatch.StartNew();
    for (int i = 0; i < 10000000; ++i)
    {
        decimal d = i;

        fixed (byte* sp = serialized)
        {
            *(decimal*)(sp + i * 16) = d;
        }
    }
    var ser = sw.Elapsed.TotalSeconds;

    sw = Stopwatch.StartNew();
    decimal total = 0;
    for (int i = 0; i < 10000000; ++i)
    {
        // Deserialize
        decimal d;
        fixed (byte* sp = serialized)
        {
            d = *(decimal*)(sp + i * 16);
        }

        total += d;
    }
    var dser = sw.Elapsed.TotalSeconds;

    Console.WriteLine("Time: {0:0.00}s serialization, {1:0.00}s deserialization", ser, dser);

    Console.ReadLine();
}

此时，我们的结果是：Time: 0.07s serialization, 0.16s deserialization。很确定这是最快的……不过，你必须接受这里的不安全，而且我认为内容的编写方式与读取方式相同。