Converting Byte Array To Int24

For signed int24, little endian use:

int num = array[0] | array[1] << 8 | (sbyte)array[2] << 16;

For signed int24, big endian use:

int num = (sbyte)array[0] << 16 | array[1] << 8 | array[2];

For unsigned int24, little endian use:

int num = array[0] | array[1] << 8 | array[2] << 16;

For unsigned int24, big endian use:

int num = array[0] << 16 | array[1] << 8 | array[2];

Note that for any signed int, little endian of n bytes, just list all the bytes, connect them using a '|', shift them one by one, and add (sbyte) to the last byte to make it signed:

var num = array[0] | array[1] << 8 | array[2] << 16 | ... | (sbyte)array[n] << 8*n;

For big endian, just reverse the shift order:

var num = array[n] | array[n-1] << 8 | array[n-2] << 16 | ... | (sbyte)array[0] << 8*n;

Or, of course, alternatively:

var num = (sbyte)array[0] << 8*n | array[1] << 8*(n-1) | ... | array[0];

You have to make sure that the (sbyte) is with the highest order byte (the last byte if little endian, the first byte if big endian) to get C# create the sign for the int.

Of course, for unsigned int, just remove the (sbyte).

Last thing.. the array can be byte[] or int[]. So you can do this:

var num = stream.ReadByte() | stream.ReadByte() << 8 | (sbyte)stream.ReadByte() << 16;

Where stream is a System.IO.Stream.

I have written an extension method for this problem some time ago.

public enum Endian : int {
    Little,
    Big
}

public static int ToInt32(this byte[] buffer, Endian endian = Endian.Little) {
    if (buffer.Length < 1 || buffer.Length > 4)
        throw new ArgumentException(" ... ");

    if (endian == Endian.Big)
        buffer.Reverse();

    int sum = 0;
    for (int i = buffer.Length - 1; i > -1; --i)
        sum += (buffer[i] << (i << 3));

    if ((buffer[buffer.Length - 1] & 0x80) == 0x80)
        sum |= (0xFFFFFF << (buffer.Length << 3));

    return sum;
}

public static unsafe void Reverse(this byte[] buffer) {
    fixed (byte* b = buffer) {
        byte* s, e;
        s = b;
        e = b + buffer.Length - 1;

        byte t;                
        while (s < e) {
            t = *s;
            *s = *e;
            *e = t;
            ++s;
            --e;
        }
    }
}

The Endian enum and the Reverse method are used by the ToInt32 method for Endian purposes.

The ToInt32 method has some nice benefits:

1. It's an extension method so you can call it with your byte[] object.

byte[] x = { 0xFF, 0xFF, 0x7F };
int value = x.ToInt32();

2. It's able to convert the byte array to both byte orders.

byte[] x = { 0x12, 0x34, 0x56 };
int valueLittle = x.ToInt32(Endian.Little); // Return 5,649,426
int valueBig    = x.ToInt32(Endian.Big);    // Return 1,193,046

3. It takes care of the sign bit.

byte[] x = { 0x00, 0x00, 0x80 };
x.ToInt32();           // Return -8,388,608
x.ToInt32(Endian.Big); // Return 128

I've tried to make the methods so fast as I can. Did some benchmarks and speed was good for me.
Hope this solution helps and makes the life easier. ;)

Just to complement @glglgl answer, in C# you can try the following:

public int ReadInt24(byte[] array, int pos)
{
    if(array == null || array.Length < 3)
       return -1; //some invalid value
    if (BitConverter.IsLittleEndian)
        return ((array[2]) + (array[1] * 256) + (array[0] * 65536));
    else
        return ((array[0]) + (array[1] * 256) + (array[2] * 65536));
}

The property BitConverter.IsLittleEndian will tell about the current Endianness

Indicates the byte order ("endianness") in which data is stored in this computer architecture.

For signed int24 use:

int num = array[0] | array[1] << 8 | (sbyte)array[2] << 16;