4

如果我有一个字节数组，并且想要将该数组的连续 16 字节块（包含 .net 的 a 表示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();
    }
}

为了摆脱MemoryStreamand ，我认为将sBinaryReader数组输入构造函数会比我在下面提供的解决方案更快，但奇怪的是，下面的版本快两倍。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]);
}

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

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

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

或者有没有其他更快的方法？

4

2 回答 2

3

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

我为你准备了第三种解决方案，但在我写它之前，有必要说我还没有测试过它的性能。

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...)".

于 2013-06-07T12:38:55.633 回答
3

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

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 ，我认为东西的写法和​​读法一样。

于 2017-06-19T09:32:54.683 回答