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

Question

如果我有一个字节数组，并且想要将该数组的连续 16 字节块（包含 .net 的 Decimal 表示）转换为正确的 Decimal 结构，那么最有效的方法是什么？

在我正在优化的情况下，这是在我的分析器中显示为最大 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 和BinaryReader，我认为将BitConverter.ToInt32(src, offset + x)s 的数组输入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]);
}

这是MemoryStream/BinaryReader 组合的10 倍，我用一堆极值对其进行了测试以确保它有效，但十进制表示并不像其他原始类型，所以我还不相信它适用于 100% 的可能十进制值。

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

（只有一个问题：虽然小数表示为 16 个字节，但一些可能的值不构成有效的小数，所以不检查memcpy 可能会破坏事情......）

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

Answer 1

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

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();
}

结果：Time: 1.68s serialization, 1.81s deserialization。这是我们的基线。我还尝试将Buffer.BlockCopy 转换为int[4]，这为我们提供了 0.42 秒的反序列化时间。使用问题中描述的方法，反序列化下降到 0.29s。

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

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

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。很确定这是最快的速度......不过，你必须在这里接受 unsafe ，而且我认为内容的编写方式与读取方式相同。

Answer 2

@Eugene Beresovksy 从流中读取非常昂贵。 MemoryStream 无疑是一个功能强大且用途广泛的工具，但直接读取二进制数组的成本相当高。也许正因为如此，第二种方法的效果更好。

我有第 3 个解决方案给你，但在我写之前，有必要说我还没有测试过它的性能。

public static decimal ByteArrayToDecimal(byte[] src, int offset)
{
    var i1 = BitConverter.ToInt32(src, offset);
    var i2 = BitConverter.ToInt32(src, offset + 4);
    var i3 = BitConverter.ToInt32(src, offset + 8);
    var i4 = BitConverter.ToInt32(src, offset + 12);

    return new decimal(new int[] { i1, i2, i3, i4 });
}

这是一种基于二进制构建构建而无需担心System.Decimal 的规范的方法。它与默认的 .net 位提取方法相反：

System.Int32[] bits = Decimal.GetBits((decimal)10);

编辑：

这个解决方案可能没有表现得更好，但也没有这个问题："(There's only one problem: Although decimals are represented as 16 bytes, some of the possible values do not constitute valid decimals, so doing an uncheckedmemcpy could potentially break things...)"。