Question

我希望尽快从byte[]获得float[]，而不需要遍历整个数组（可能是通过强制转换）。不安全的代码很好。谢谢！

我正在寻找比浮点数组长4倍的字节数组（字节数组的维数将是浮点数组的4倍，因为每个浮点数由4个字节组成）。我会把它传递给BinaryWriter。

修改：那些尖叫着“过早优化”的评论家：在优化之前，我使用ANTS分析器对此进行了基准测试。速度显着提高，因为该文件具有直写缓存，并且浮点数组的大小恰好与磁盘上的扇区大小相匹配。二进制编写器包装使用pinvoke'd win32 API创建的文件句柄。优化发生，因为这减少了函数调用的数量。

而且，关于内存，这个应用程序创建了大量使用大量内存的缓存。我可以分配一次字节缓冲区并重复使用它多次 - 在这个特定实例中的双内存使用量相当于应用程序整体内存消耗的舍入误差。

所以我想这里的教训不是过早假设;）

Answer 1

有一种脏的快速（不是不安全的代码）这样做的方法：

[StructLayout(LayoutKind.Explicit)]
struct BytetoDoubleConverter
{
    [FieldOffset(0)]
    public Byte[] Bytes;

    [FieldOffset(0)]
    public Double[] Doubles;
}
//...
static Double Sum(byte[] data)
{
    BytetoDoubleConverter convert = new BytetoDoubleConverter { Bytes = data };
    Double result = 0;
    for (int i = 0; i < convert.Doubles.Length / sizeof(Double); i++)
    {
        result += convert.Doubles[i];
    }
    return result;
}

这会有效，但我不确定对Mono或CLR的较新版本的支持。唯一奇怪的是array.Length是字节长度。这可以解释，因为它查看了与数组一起存储的数组长度，并且因为该数组是一个字节数组，其长度仍然是字节长度。索引器确实认为Double是八个字节大，因此不需要进行计算。

我已经对它进行了更多的搜索，实际上它已在MSDN， How to: Create a C/C++ Union by Using Attributes (C# and Visual Basic) 上进行了描述，因此未来的版本可能会支持这种情况。我不确定Mono。

Answer 2

过早优化是万恶之源！ @ Vlad建议迭代每个浮点数是一个比切换到byte []更合理的答案。采用下表的运行时表来增加元素数量（平均50次运行）：

Elements      BinaryWriter(float)      BinaryWriter(byte[])
-----------------------------------------------------------
10               8.72ms                    8.76ms
100              8.94ms                    8.82ms
1000            10.32ms                    9.06ms
10000           32.56ms                   10.34ms
100000         213.28ms                  739.90ms
1000000       1955.92ms                10668.56ms

对于少量元素，两者之间几乎没有差别。一旦你进入了大量的元素范围，从float []复制到byte []所花费的时间远远超过了好处。

顺便说一下：

float[] data = new float[...];
foreach(float value in data)
{
    writer.Write(value);
}

Answer 3

有一种方法可以避免内存复制和迭代。

你可以使用一个非常难看的黑客来使用（不安全的）内存操作临时将你的数组更改为另一种类型。

我在32和32中测试了这个黑客。 64位操作系统，因此它应该是可移植的。

源代码+样本使用率维持在https://gist.github.com/1050703，但为方便起见，我也会将其粘贴到此处：

public static unsafe class FastArraySerializer
{
    [StructLayout(LayoutKind.Explicit)]
    private struct Union
    {
        [FieldOffset(0)] public byte[] bytes;
        [FieldOffset(0)] public float[] floats;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private struct ArrayHeader
    {
        public UIntPtr type;
        public UIntPtr length;
    }

    private static readonly UIntPtr BYTE_ARRAY_TYPE;
    private static readonly UIntPtr FLOAT_ARRAY_TYPE;

    static FastArraySerializer()
    {
        fixed (void* pBytes = new byte[1])
        fixed (void* pFloats = new float[1])
        {
            BYTE_ARRAY_TYPE = getHeader(pBytes)->type;
            FLOAT_ARRAY_TYPE = getHeader(pFloats)->type;
        }
    }

    public static void AsByteArray(this float[] floats, Action<byte[]> action)
    {
        if (floats.handleNullOrEmptyArray(action)) 
            return;

        var union = new Union {floats = floats};
        union.floats.toByteArray();
        try
        {
            action(union.bytes);
        }
        finally
        {
            union.bytes.toFloatArray();
        }
    }

    public static void AsFloatArray(this byte[] bytes, Action<float[]> action)
    {
        if (bytes.handleNullOrEmptyArray(action)) 
            return;

        var union = new Union {bytes = bytes};
        union.bytes.toFloatArray();
        try
        {
            action(union.floats);
        }
        finally
        {
            union.floats.toByteArray();
        }
    }

    public static bool handleNullOrEmptyArray<TSrc,TDst>(this TSrc[] array, Action<TDst[]> action)
    {
        if (array == null)
        {
            action(null);
            return true;
        }

        if (array.Length == 0)
        {
            action(new TDst[0]);
            return true;
        }

        return false;
    }

    private static ArrayHeader* getHeader(void* pBytes)
    {
        return (ArrayHeader*)pBytes - 1;
    }

    private static void toFloatArray(this byte[] bytes)
    {
        fixed (void* pArray = bytes)
        {
            var pHeader = getHeader(pArray);

            pHeader->type = FLOAT_ARRAY_TYPE;
            pHeader->length = (UIntPtr)(bytes.Length / sizeof(float));
        }
    }

    private static void toByteArray(this float[] floats)
    {
        fixed(void* pArray = floats)
        {
            var pHeader = getHeader(pArray);

            pHeader->type = BYTE_ARRAY_TYPE;
            pHeader->length = (UIntPtr)(floats.Length * sizeof(float));
        }
    }
}

用法是：

var floats = new float[] {0, 1, 0, 1};
floats.AsByteArray(bytes =>
{
    foreach (var b in bytes)
    {
        Console.WriteLine(b);
    }
});

Answer 4

如果您不希望发生任何转换，我建议使用Buffer.BlockCopy（）。

public static void BlockCopy(
    Array src,
    int srcOffset,
    Array dst,
    int dstOffset,
    int count
)

例如：

float[] floatArray = new float[1000];
byte[] byteArray = new byte[floatArray.Length * 4];

Buffer.BlockCopy(floatArray, 0, byteArray, 0, byteArray.Length);

Answer 5

你最好让BinaryWriter do this for you。无论使用哪种方法，都会对整个数据集进行迭代，因此无需使用字节进行迭代。

Answer 6

虽然您可以使用byte*和unsafe获取fixed指针，但无法将byte*转换为byte[]以便作者接受它作为参数而不执行数据复制。您不想这样做，因为它会使内存占用量增加一倍和在需要执行的不可避免的迭代中添加额外的迭代，以便将数据输出到磁盘。

相反，您仍然可以使用float方法更好地迭代浮点数组并将每个Write(double)单独写入作者。由于作者内部的缓冲，它仍然会很快。请参阅sixlettervariables的数字。

Answer 7

我们有一个名为LudicrousSpeedSerialization的类，它包含以下不安全的方法：

    static public byte[] ConvertFloatsToBytes(float[] data)
    {
        int n = data.Length;
        byte[] ret = new byte[n * sizeof(float)];
        if (n == 0) return ret;

        unsafe
        {
            fixed (byte* pByteArray = &ret[0])
            {
                float* pFloatArray = (float*)pByteArray;
                for (int i = 0; i < n; i++)
                {
                    pFloatArray[i] = data[i];
                }
            }
        }

        return ret;
    }

Answer 8

虽然它基本上在幕后做了for循环，但它确实在一行中完成了工作

byte[] byteArray = floatArray.Select(
                    f=>System.BitConverter.GetBytes(f)).Aggregate(
                    (bytes, f) => {List<byte> temp = bytes.ToList(); temp.AddRange(f); return temp.ToArray(); });

将float []转换为byte []的最快方法是什么？

8 个答案: