Parsing values from Byte array C# using Shift and Bitware AND operatorts

Bitwise operators are usually used to work with individual bits inside a byte. In C# there is BitArray class which allows you to work with bits, but I'd say it's rarely used, probably because bitwise operators became common practice for this task (and also BitArray is useless for many operations which can be done with bitwise operators anyway).

In your example there is byte array which encodes certain data, but individual pieces of this data are not represented by a whole byte value. Instead - one byte might encode several pieces of information in its individual bits.

If look at this operation:

stream[start + 2] >> 4) & 0x0F

It reads first half (first 4 bits) of 3rd byte as a number. In your example 3rd byte is 0x12 which in binary form is 0001 0010. Right shift, well, shifts given number of bits to the right:

0001 0010 >> 4 = 0000 0001

Now left half of byte is moved to the right half, and left half became zero. As you see, now left half 0001 and whole byte 0000 0001 represent the same number - that is number "1". That was the goal of >> 4 operation. Doing & 0x0F after that is useless and does nothing, so I will omit explanation of that.

Now we got left half and need to get right half. We do that with

stream[start + 2] & 0x0F

Bitwise AND, as you probably know, leaves only bits which are set ("1") in both numbers:

0001 0010 &
0000 1111 < this is 0x0F in binary
0000 0010

By doing that we zeroed left half of the byte and now right half (0010) and number we got (0000 0010) represent the same number ("2").

So in result we got left half ("1" in decimal) and right half ("2" in decimal). You can see this is used to represent Frequency, OrbitalPosition and several other properties in your case.

Let's see at this operation:

((stream[start + 8] >> 7) & 0x01) == 0x01

If we have byte abcd efjk and do right shift by 7 bits, we have:

abcd efjk >> 7
0000 000a

So we got value of leftmost bit (a). Doing & 0x01 is again useless and does nothing, so can be omitted. So we can conclude that WestEastFlag flag is stored in leftmost bit of 9th byte. If that bit is 1 - flag is set, otherwise - not set. Bitshift by 7 bits allows us to get to this flag.

You can apply the same logic to other operations:

(stream[start + 8] >> 5) & 0x03

abcd efkj >> 5
0000 0abc

0000 0abc &
0000 0011 < 0x03
0000 00bc

So this one allows us to get to bits b and c (6 and 7 if count from the right), in which, according to that code, Polarization is stored.

For better understanding you can first avoid unnecessary operations (as described above), and also use binary literals:

// easier to undrestand what's going on, compared to 0x03
(stream[start + 8] >> 5) & 0b0000_0011 // < need last two bits after the shift

For readability for particular set of operations used in this question you can create extension method like that (warning - proper test it if will use, not properly tested):

public static class ByteExtensions {
    public static byte GetBits(this byte x, byte from, byte to) {
        if (to > 8)
            throw new ArgumentOutOfRangeException(nameof(to));
        if (to < from)
            throw new ArgumentOutOfRangeException(nameof(from));
        x >>= (from - 1);
        x &= (byte)(0xFF >> (7 - (to - from)));
        return x;
    }
}

Then operations described above can be performed using it. For example:

stream[start + 2] >> 4) & 0x0F // get left half

becomes

stream[start + 2].GetBits(5, 8) // get left half (so, bits 5,6,7,8)

And

(stream[start + 8] >> 5) & 0x03 // get bits 6,7

Becomes

stream[start + 8].GetBits(6,7)