How exactly do you *obtain* a list with one million byte arrays? Wouldn't it
be much faster (and more memory-efficient) to change whatever is producing
such a list to produce the list you need in the first place?

What's the result of the conversion? Another list? Keep in mind that
allocating memory takes time too. The conversion of individual entries is
not the bottleneck, in the sense that you will not be able to speed that up
much. You'll want to focus on minimizing the conversion effort.

On my PC it takes about 0.043 seconds to convert each byte[3] to long
in a list with one million elements.

Actually I had to test with ten million elements and divide by 10,
because I could not really measure with so small data as one
million elements.

Your 1-2 seconds must be spend on something else.

I think you need to analyze the app again.

List<byte[]> is not suitable for native code I think.

But because there are just 3 bytes you may be able to
do it faster that BitConverter that has to handle all
8 bytes.

The 0.043 seconds are with:

        private static long Cvt1(byte[] b)
        {
            byte[] tmp = new byte[8];
            tmp[0] = b[0];
            tmp[1] = b[1];
            tmp[2] = b[2];
            return BitConverter.ToInt64(tmp, 0);
        }

but using:

        private static long Cvt2(byte[] b)
        {
            return (b[2] << 16) | (b[1] << 8) | b[0];
        }

then I can get it down to 0.006 seconds.

But if it is probably not relevant. If your existing code takes 1.000
seconds then the difference will just reduce it to 0.963 seconds - noone
will notice the difference.

Arne