Converting an int[] to byte[] in C#

Question

I know how to do this the long way: by creating a byte array of the necessary size and using a for-loop to cast every element from the int array.

I was wondering if there was a faster way, as it seems that the method above would break if the int was bigger than an sbyte.

Solution 1

If you want a bitwise copy, i.e. get 4 bytes out of one int, then use Buffer.BlockCopy:

byte[] result = new byte[intArray.Length * sizeof(int)];
Buffer.BlockCopy(intArray, 0, result, 0, result.Length);

Don't use Array.Copy, because it will try to convert and not just copy. See the remarks on the MSDN page for more info.

Solution 2

Besides the accepted answer (which I am now using), an alternative one-liner for Linq lovers would be:

byte[] bytes = ints.SelectMany(BitConverter.GetBytes).ToArray(); 

I suppose, though, that it would be slower...

Solution 3

A little old thread, it's 2022 now…
I had a bunch of shorts laying around (sorry, no ints ;-) ) and thought it would be cool to have them as a byte array instead. After reading about all the different ways to approach this, I was very confused and just started benchmarking my favourite ones.
(The code should be easy to apply to any base type.)
It uses BenchmarkDotNet to do the actual testing and statistical analysis.

using System;
using System.Linq;
using System.Runtime.InteropServices;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

namespace ArrayCastingBenchmark;

public class Benchy {
    private const int number_of_shorts = 100000;
    private readonly short[] shorts;

    public Benchy() {
        Random r = new(43);
        shorts = new short[number_of_shorts];
        for (int i = 0; i < number_of_shorts; i++)
            shorts[i] = (short) r.Next(short.MaxValue);
    }

    [Benchmark]
    public ReadOnlySpan<byte> SPANSTYLE() {
        ReadOnlySpan<short> shortSpan = new ReadOnlySpan<short>(shorts);
        return MemoryMarshal.Cast<short, byte>(shortSpan);
    }

    [Benchmark]
    public byte[] BLOCKCOPY() {
        byte[] bytes = new byte[shorts.Length * sizeof(short)];
        Buffer.BlockCopy(shorts, 0, bytes, 0, bytes.Length);
        return bytes;
    }

    [Benchmark]
    public byte[] LINQY() {
        return shorts.Select(i => (byte) i).ToArray();
    }

    [Benchmark]
    public byte[] BITCONVERTER() {
        byte[] bytes = shorts.SelectMany(BitConverter.GetBytes).ToArray();
        return bytes;
    }

    //[Benchmark]
    //public void BINARYWRITER() {
    //    var fhandle = File.OpenHandle("_shorts_binarywriter.bin", FileMode.Create, FileAccess.Write);
    //    var binaryWriter = new BinaryWriter(new FileStream(fhandle, FileAccess.Write));
    //    foreach (var shorty in shorts)
    //        binaryWriter.Write(shorty);
    //    binaryWriter.Flush();
    //    binaryWriter.Close();
    //    fhandle.Close();
    //}
}

internal class Program {
    static void Main(string[] args) {
        var summary = BenchmarkRunner.Run<Benchy>();
    }
}

I left the last one in, because if you just add a File.WriteAllBytes to the end of all methods and make them actually produce some output, suddenly BLOCKCOPY get's ever so slightly faster than SPANSTYLE on my machine. If anyone else experiences this or has an idea how this can happen, please tell me.

EDIT: Sorry, forgot to include the actual results (mind you: on my machine) as it runs for quite a while with the standard settings and all the warm-up.

 |       Method |              Mean |           Error |          StdDev |
 |------------- |------------------:|----------------:|----------------:|
 |    SPANSTYLE |         0.4592 ns |       0.0333 ns |       0.0666 ns |
 |    BLOCKCOPY |    15,384.8031 ns |     304.6014 ns |     775.3079 ns |
 |        LINQY |   175,187.7816 ns |   1,119.2713 ns |   1,046.9671 ns |
 | BITCONVERTER | 9,053,750.0355 ns | 330,414.7870 ns | 910,058.2814 ns |

Comments

[Henk Holterman]

byte array and "bigger than short" mismatch.

[soandos]

I meant that int is not one to one with a byte in terms of size.

[Henk Holterman]

And short/ushort are not one to one with byte.

[Henk Holterman]

@scandos: and do you want to convert 4 bytes to 1 int, ... etc. Please note the Edit link under your question.

[soandos]

@henk: Apologies. I Did not think about it, but assumed that I could just load 4 bytes, then read them as an int. seems that it requires more "formatting" as not every 4 bytes was perhaps meant to be an int (smaller numbers require less space, and as stated above, directly casting leads to data loss).

[soandos]

how does it know to get 4 bytes per int?

[Daniel Hilgarth]

It just copies the memory. It doesn't know about int or byte. The memory representation of result will be exactly the same as that of intArray.

[Moop]

How would you do the reverse? Take a byte[] and copy it to a int[]?

[Daniel Hilgarth]

@Moop int[] result = new int[byteArray.Length / sizeof(int)]; Buffer.BlockCopy(byteArray, 0, result, 0, result.Length);

[Zenima]

You can also use the following, if you don't know the element type of a value type array compile time: byte[] result = new byte[Buffer.ByteLength((Array)valueTypeArray)];

[Meirion Hughes]

yeah, but its fine for a quick short unit test. proposed an edit as you don't need the v=> ... yptes(v)

[Philippe Paré]

Even works with multidimensional arrays! I'm impressed, thanks a lot.

[Jonathan Vukadinovic]

Just a correction for the inverse solution that Daniel provided (from byte[] to int[]) it should be: Buffer.BlockCopy(byteArray, 0, result, 0, byteArray.Length); => basically the last parameter should not be result.Length and instead byteArray,Length

[Kiquenet]

and convert UInt16[] ?

[Kiquenet]

Powershell: ([System.Text.Encoding]::ASCII.GetString($Monitor.SerialNumb‌​erID)).Replace("$([c‌​har]0x0000)","")

[Dirk Boer]

do you need to take endianness into account i.e. if you are not sure if you would run on Linux or Windows?

[Daniel Hilgarth]

@DirkBoer: It depends on your scenario. Depending on the endianess, the bytes in an int are ordered differently, so the result will differ based on the endianess. If you need to ensure that the resulting byte array can be read correctly on any system, you should either normalize it to a known endianess first or communicate the endianess that was used on the system where the byte array was written. If you just want to read it again on the same system, you don't have to care.

[Dirk Boer]

Hi @DanielHilgarth, thanks for your answer! Ok as I'm right now too lazy to build something I guess this will fly into my face some day when I switch my server to a different OS :) Thanks for taking your time to answer!

[Daniel Hilgarth]

The explanation for the speed of Span is that it doesn't actually create a copy of the data. A Span is just a glorified pointer. So, all your code is doing, is to create a new pointer to the same data. Also, your LINQ test is incorrect. Just casting a short to a byte will lose information because a short holds 16 bit of data and a byte only 8