What is the idiomatic c# for unpacking an integer from a byte array?

Question

I'm parsing a binary file format. It encodes an integer using four bytes in a way that will naturally fit within c#'s uint type.

What is the most C#/idiomatic way to implement this function:

uint ReadUint(byte[] buffer);

Assume the buffer contains 4 elements. A complete answer might consider some of the common byte orderings caused by little/big endian assumptions in the file, and document the one(s) it chooses to parse.

Answer 1

As someone coming from C, this is how I currently implement this function:

static uint ReadLength(byte[] buffer)
{
    uint result = ((uint) buffer[3]) << 24;
    result |= ((uint) buffer[2]) << 16;
    result |= ((uint) buffer[1]) << 8;
    result |= buffer[offset];
    return result;
}

This parses a format that Wikipedia claims is laid out in little-endian fashion, on a .net implementation running on i386/Vista

Answer 2

Assuming that you want to read a stream of them (as your code would suggest) I would say that this is pretty close to the de facto standard way:

MemoryStream ms = new MemoryStream(new byte[100]);
BinaryReader br = new BinaryReader(ms);
uint q = br.ReadUInt32();

Answer 3

I would normally use the BitConverter class for this. In your case the BitConverter.ToUInt32() method.

Answer 4

The most basic (but a little dangerous re endianness) is:

return BitConverter.ToUInt32(buffer, 0);

Other than than, bit-shifting is fine (as per your own reply) - or you can use Jon's EndianBitConverter in MiscUtil, which handles the translations.

(edit)

The little-endian bit-shifting version I use in protobuf-net is pretty-much identical to your version - I just read them in ascending order and use bitwise (not numeric) addition:

return ((uint)buffer[0])
        | (((uint)buffer[1]) << 8)
        | (((uint)buffer[2]) << 16)
        | (((uint)buffer[3]) << 24);

Answer 5

byte[] ba = new byte[]{ 0x10, 0xFF, 0x11, 0x01 } ;
var ui = BitConverter.ToUInt32(ba, 0);

Use the BitConverter Class.

Answer 6

Simplest way is just

int val  = System.BitConverter.ToInt32(buffer, 0);

This uses the current system endianness, which may or may not be what you want.

Answer 7

This reply is actually an extended comment (hence wiki) comparing the performance of BitConverter and bitshifting using + vs |; it applies when micro-optimising only!!

Results first:

BitConverter: 972ms, chk=1855032704
Bitwise: 740ms, chk=1855032704
ReadLength: 1316ms, chk=1855032704

Or results if tweaked to allow non-zero base offsets:

BitConverter: 905ms, chk=1855032704
Bitwise: 1058ms, chk=1855032704
ReadLength: 1244ms, chk=1855032704

And the code:

using System;
using System.Diagnostics;
static class Program
{
    static void Main()
    {
        byte[] buffer = BitConverter.GetBytes((uint)123);
        const int LOOP = 50000000;
        uint chk = 0;
        var watch = Stopwatch.StartNew();
        for (int i = 0; i < LOOP; i++)
        {
            chk += BitConverter.ToUInt32(buffer, 0);
        }
        watch.Stop();
        Console.WriteLine("BitConverter: " + watch.ElapsedMilliseconds
            + "ms, chk=" + chk);

        chk = 0;
        watch = Stopwatch.StartNew();
        for (int i = 0; i < LOOP; i++)
        {
            chk += Bitwise(buffer);
        }
        watch.Stop();
        Console.WriteLine("Bitwise: " + watch.ElapsedMilliseconds
            + "ms, chk=" + chk);

        chk = 0;
        watch = Stopwatch.StartNew();
        for (int i = 0; i < LOOP; i++)
        {
            chk += ReadLength(buffer);
        }
        watch.Stop();
        Console.WriteLine("ReadLength: " + watch.ElapsedMilliseconds
            + "ms, chk=" + chk);

        Console.ReadKey();
    }
    static uint Bitwise(byte[] buffer)
    {
        return ((uint)buffer[0])
            | (((uint)buffer[1]) << 8)
            | (((uint)buffer[2]) << 16)
            | (((uint)buffer[3]) << 24);
    }
    static uint ReadLength(byte[] buffer)
    {
        uint result = ((uint)buffer[3]) << 24;
        result += ((uint)buffer[2]) << 16;
        result += ((uint)buffer[1]) << 8;
        result += buffer[0];
        return result;
    }
}