将十进制复制到字节数组中而不进行分配

Question

梦想

我正在寻找一种方法将十进制值复制到字节数组缓冲区中，然后无需任何堆分配即可将这些字节读回十进制。理想情况下，这不需要不安全的上下文。

我的尝试

我以前在 C# 中使用过临时联合来做一些疯狂的事情。这是一种非常酷的方式，可以随意随意读取内存，但您必须小心。您可能会进入变量我明确存在的损坏状态，例如byte[]，但在调试器中查看的值是int[]。我什至不知道这样的事情是可能的！

注意：Marc 在下面的 cmets 中提出了一个非常重要的观点。由于字节顺序，您无法使用像这样的重叠结构概念可靠地将数字直接转换为字节。在这种情况下，您可以安全地使用整数，因为十进制类型在内部使用了 4 个整数。这是来自 protobuf-net 的十进制序列化程序的 [示例]。

1: struct union w/decimal and byte[]

第一次尝试尝试使用带有 decimal 和 byte[] 字段的结构联合概念，两者都在 0 偏移处，因此它们占用完全相同的内存位置。然后我可以写入一个字段并从另一个字段读取。

[StructLayout(LayoutKind.Explicit)]
private readonly struct convert_decimal_to_bytes
{
    [FieldOffset(0)]
    public readonly decimal value;
    [FieldOffset(0)]
    public readonly byte[] bytes;

    public convert_decimal_to_bytes(decimal value)
    {
        bytes = default;
        this.value = value;
    }
}

这甚至不会在没有抛出的情况下运行 - 类型无法加载以下内容：

System.TypeLoadException : Could not load type 'convert_decimal_to_bytes' from assembly 'teloneum, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null' because it contains an object field at offset 0 that is incorrectly aligned or overlapped by a non-object field.

显然 CLR 不喜欢它们被重叠——但这只是因为一个是值类型而另一个是引用类型。

2：结构联合，带十进制和 16 个字节！

所以我决定删除引用类型！现在，下面的工作，或者至少，它会工作，但顺序都搞砸了。我当然可以一个大的十进制数，在这里运行它，然后按字段偏移量进行匹配，使其与我的测试相匹配，但这似乎是错误的——另外，我试过的每个小数中至少有三个零字节:) 也许我最后只是偷懒了……毕竟已经晚了。

[StructLayout(LayoutKind.Explicit)]
private readonly struct convert_decimal_to_bytes
{
    [FieldOffset(0)] public readonly decimal value;

    [FieldOffset( 0)] public readonly byte byte_1;
    [FieldOffset( 1)] public readonly byte byte_2;
    [FieldOffset( 2)] public readonly byte byte_3;
    [FieldOffset( 3)] public readonly byte byte_4;
    [FieldOffset( 4)] public readonly byte byte_5;
    [FieldOffset( 5)] public readonly byte byte_6;
    [FieldOffset( 6)] public readonly byte byte_7;
    [FieldOffset( 7)] public readonly byte byte_8;
    [FieldOffset( 8)] public readonly byte byte_9;
    [FieldOffset( 9)] public readonly byte byte_10;
    [FieldOffset(10)] public readonly byte byte_11;
    [FieldOffset(11)] public readonly byte byte_12;
    [FieldOffset(12)] public readonly byte byte_13;
    [FieldOffset(13)] public readonly byte byte_14;
    [FieldOffset(14)] public readonly byte byte_15;
    [FieldOffset(15)] public readonly byte byte_16;

    public convert_decimal_to_bytes(decimal value)
    {
        byte_1  = default;
        byte_2  = default;
        byte_3  = default;
        byte_4  = default;
        byte_5  = default;
        byte_6  = default;
        byte_7  = default;
        byte_8  = default;
        byte_9  = default;
        byte_10 = default;
        byte_11 = default;
        byte_12 = default;
        byte_13 = default;
        byte_14 = default;
        byte_15 = default;
        byte_16 = default;
        this.value = value;
    }

    public convert_decimal_to_bytes(int startIndex, byte[] buffer)
    {
        value = default;
        byte_1 = buffer[startIndex++];
        byte_2 = buffer[startIndex++];
        byte_3 = buffer[startIndex++];
        byte_4 = buffer[startIndex++];
        byte_5 = buffer[startIndex++];
        byte_6 = buffer[startIndex++];
        byte_7 = buffer[startIndex++];
        byte_8 = buffer[startIndex++];
        byte_9 = buffer[startIndex++];
        byte_10 = buffer[startIndex++];
        byte_11 = buffer[startIndex++];
        byte_12 = buffer[startIndex++];
        byte_13 = buffer[startIndex++];
        byte_14 = buffer[startIndex++];
        byte_15 = buffer[startIndex++];
        byte_16 = buffer[startIndex];
    }


    public static void Copy(decimal value, int startIndex, byte[] buffer)
    {
        var convert = new convert_decimal_to_bytes(value);

        buffer[startIndex++] = convert.byte_1;
        buffer[startIndex++] = convert.byte_2;
        buffer[startIndex++] = convert.byte_3;
        buffer[startIndex++] = convert.byte_4;
        buffer[startIndex++] = convert.byte_5;
        buffer[startIndex++] = convert.byte_6;
        buffer[startIndex++] = convert.byte_7;
        buffer[startIndex++] = convert.byte_8;
        buffer[startIndex++] = convert.byte_9;
        buffer[startIndex++] = convert.byte_10;
        buffer[startIndex++] = convert.byte_11;
        buffer[startIndex++] = convert.byte_12;
        buffer[startIndex++] = convert.byte_13;
        buffer[startIndex++] = convert.byte_14;
        buffer[startIndex++] = convert.byte_15;
        buffer[startIndex]   = convert.byte_16;
    }

    public static decimal Read(int startIndex, byte[] buffer)
    {
        var convert = new convert_decimal_to_bytes(startIndex, buffer);

        return convert.value;
    }
}

Answer 1

在 .NET 5.0 之前，如果没有一些丑陋的骇客，这是很尴尬的。从 .NET 5.0 开始，接受 span 的方法越来越多。

您可以使用堆栈分配跨度的GetBits(decimal d, Span<int>) 方法，然后根据需要将四个整数转换为现有字节数组，例如BitConverter.TryWriteBytes。

在另一个方向，有一个Decimal(ReadOnlySpan<int>) 构造函数，因此您可以再次stackalloc 一个Span<int>，重复使用BitConverter.ToInt32(ReadOnlySpan<byte>) 从字节数组填充该跨度，并将其传递给构造函数。

顺便说一句，您可能希望通过代码库更广泛地采用跨度，而不是接受字节数组和起始索引。

这里有一些示例代码可以完成上述所有操作 - 可能会稍微更有效地完成，但希望这可以让想法得到理解，并且确实避免了分配：

using System;

class Program
{
    public static void Copy(decimal value, int startIndex, byte[] buffer)
    {
        Span<int> int32s = stackalloc int[4];
        decimal.GetBits(value, int32s);

        var bufferSpan = buffer.AsSpan();
        for (int i = 0; i < 4; i++)
        {
            // These slices are bigger than we need, but this is the simplest approach.
            var slice = bufferSpan.Slice(startIndex + i * 4);
            if (!BitConverter.TryWriteBytes(slice, int32s[i]))
            {
                throw new ArgumentException("Not enough space in span");
            }
        }
    }

    public static decimal Read(int startIndex, byte[] buffer)
    {
        Span<int> int32s = stackalloc int[4];
        ReadOnlySpan<byte> bufferSpan = buffer.AsSpan();
        for (int i = 0; i < 4; i++)
        {
            var slice = bufferSpan.Slice(startIndex + i * 4);
            int32s[i] = BitConverter.ToInt32(slice);
        }
        return new decimal(int32s);
    }

    static void Main()
    {
        byte[] bytes = new byte[16];
        decimal original = 1234.567m;
        Copy(original, 0, bytes);
        decimal restored = Read(0, bytes);
        Console.WriteLine(restored);
    }
}

---

或同样的事情使用MemoryMarshal:

public static void Copy(decimal value, int startIndex, byte[] buffer)
    => decimal.GetBits(value, MemoryMarshal.Cast<byte, int>(buffer.AsSpan(startIndex)));

public static decimal Read(int startIndex, byte[] buffer)
    => new decimal(MemoryMarshal.Cast<byte, int>(buffer.AsSpan(startIndex)));

Answer 2

事实上，查阅 MSDN 示例代码，我找到了一个简单的方法来做到这一点：

        int[] data = decimal.GetBits(h);
        bool sign = (data[3] & 0x80000000) != 0;
        byte scale = (byte)(((data[3] >> 16) & 0x7F) + (byte)(!sign ? 0x20 : 0x00));
        List<byte> bytes = new List<byte>() // For concatenation
        bytes.AddRange(BitConverter.GetBytes(data[0]));
        bytes.AddRange(BitConverter.GetBytes(data[1]));
        bytes.AddRange(BitConverter.GetBytes(data[2]));
        bytes.Add(scale);
        return bytes.ToArray();

然后返回：

        byte[] bytes = array.Take(13);
        byte scale = bytes[12];
        bool sign = true;
        if (scale >= 0x20)
        {
            sign = false;
            scale -= 0x20;
        }

        return new decimal(BitConverter.ToInt32(bytes,0), 
                           BitConverter.ToInt32(bytes,4), 
                           BitConverter.ToInt32(bytes,8), sign, scale);

我正在使用上面的代码来序列化/反序列化小数。由于 MSDN 文档点是最后一个 int 中未使用的位（前 16 个和最后 3 个，我将最后一个 int 转换为“有符号比例”，所以我有更少的字节要分配。原始十进制大小为 16 -字节长。