0

我有一个字节数组,它可以包含数百万字节,并由以下结构表示:该数组分为 n 段,每段 16 字节。每个段的前 8 个字节代表一个 long 类型的值(8 个字节),后面跟着 2 个 short 类型的值(2*4 个字节)。

我寻找将字节数组段转换为以下类型的类对象集合的绝对最快方法:

public class Foo
{
    public long Value1 { get; set; }
    public float Value2 { get; set; }
    public float Value3 { get; set; }

    public Foo(long value1, float value2, float value3)
    {
        Value1 = value1;
        Value2 = value2;
        Value3 = value3;
    }
}

到目前为止我尝试过的是使用 BitConverter.ToInt64(...),... 但是转换时间太长了,因为我必须处理数百万字节大小的数组和数百个这样的数组。

var collection = new List<Foo>();
        var byteArraySize = byteArray.Count();
        for (var counter = 0; counter < byteArraySize; counter += PacketLength) //Packetlength here is 16
        {
            collection.Add(new Foo(
                               BitConverter.ToInt64(byteArray, counter),
                               BitConverter.ToSingle(byteArray, counter + 8),
                               BitConverter.ToSingle(byteArray, counter + 12)));
        }

有人可以告诉我如何应用位移逻辑来加速这个过程。使用指针逻辑的不安全代码也可以工作。

非常感谢。

4

1 回答 1

2

以下代码在我的机器上处理 1 GiB 数据需要 4.668 秒,其中 0.028 秒用于转换数据,4.641 秒用于创建Foo对象。您的原始代码需要 6.227 秒。

unsafe Foo[] Load(byte[] buffer, int offset, int length)
{
    fixed (byte* ptr = buffer)
    {
        Data* data = (Data*)(ptr + offset);
        Foo[] result = new Foo[length / sizeof(Data)];
        for (int i = 0; i < result.Length; i++)
        {
            result[i] = new Foo(data);
            data++;
        }
        return result;
    }
}

struct Data
{
    public long Value1;
    public float Value2;
    public float Value3;
}

class Foo
{
    public long Value1 { get; set; }
    public float Value2 { get; set; }
    public float Value3 { get; set; }

    public unsafe Foo(Data* data)
    {
        Value1 = data->Value1;
        Value2 = data->Value2;
        Value3 = data->Value3;
    }
}
于 2013-09-29T12:11:56.520 回答