Recently in the forum someone asked about bits in a byte and how it is populated into a bit array

The thread originator first populated a byte array and fed that into a bit array…
`byte````[] byteArray = ````new` ``` byte````[] { 1 };  `
```BitArray bitArray = ````new` ``` BitArray(byteArray);```

When he went to print the array to his surprise the output was backward to what he expected…

```//Simplification of what he did is this  ```
` `
`for` `(``int` `i = 0; i < bitArray.Length; i++) `
` `
```{ ```
` `
`    ````Console.Write(Convert.ToInt16(bitArray[i])); ```
` `
`    ````//note: without the convert to an int the output would be true and false ```
`    ````//10000000 would output truefalsefalsefalsefalsefalsefalse ```
```} ```

He should have done something like this starting with the most significant bit

```for (var idx = bitArray.Length - 1; idx >= 0; idx--) //Parse from left most bit to right most bit ```
```{ ```
`    ````Console.Write("{0}", Convert.ToInt16(bitArray[idx])); ```
```} ```
```Console.WriteLine();   //note: without the convert to an int the output would be true and false //00000001 would output falsefalsefalsefalsefalsefalsefalsetrue ```

Let’s explore why… here is a byte represented by a string of bits (00000001)

When a byte is converted to a bit array it starts with position 0 and goes up to 7.  The bit positions represent values and adding all the positions set to 1 or true totals the value of the converted byte.  A byte starts with the lowest significant bit on the right and the most significant bit on the left

So what does all this mean?

The logic of a byte is each position represents a value the lowest or least significant bit represents 1, the next bit or next one to the left of it is 2, the next 4 and so on…

Bit position                   7        6        5        4        3        2        1        0

Value of position     128     64      32     16        8        4        2        1

Let’s see what some strings of eight bits or a byte equals

Here we have just the first or lowest significant bit set to true or 1 which also represent the value 1, all others unset

00000001 = 1 // 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1

Here we have the least significant bit set, the next one unset and the next following one set… all others unset

00000101 = 5 // 0 + 0 + 0 + 0 + 0 + 0 + 4 + 1

Here we have another… see what it is…

10001001 = 137 // 128 + 0 + 0 + 0 + 8 + 0 + 0 + 1

Going beyond the context of the forum post we are now going to talk about bitwise operations

OR (Inclusive OR) ( | sign in C#, Or in vb.nET )

And finally build on shift with an example of Circular ***

The AND ( & sign in C#, And in vb.nET )  will take the corresponding placed bits and compare them and output according the following logic table A helper method providing AND functionality to a pair of bytes
`private` `static` ``` byte``` `ByteAND(``byte` `val1, ``byte` `val2) `
```{ ```
`    ``return` `Convert.ToByte(val1 & val2); `
```} ```
` `
```//use it as follows  ```
`byte` `andVal1 = 6; ````//00000110  ```
`byte` `andVal2 = 5; ````//00000101  ```
`byte` `outputAND = ByteAND(andVal1, andVal2); `
```//returns 4 or 00000100  ```

The OR (Inclusive OR) ( | sign in C#, Or in vb.nET )  will take the corresponding placed bits and compare them and output according the following logic table A helper method providing OR functionality to a pair of bytes
`private` `static` ``` byte``` `ByteOR(``byte` `val1, ``byte` `val2) `
```{ ```
`    ``return` `Convert.ToByte(val1 | val2); `
```} ```
` ````//use as follows  ```
` `
`byte` `orVal1 = 6; ````//00000110  ```
`byte` `orVal2 = 5; ````//00000101  ```
`byte` `outputOR = ByteOR(orVal1, orVal2); `
```//retuturns 7 or 00000111  ```

The NOT ( ~ sign in C#, Not in vb.nET)  )  will take the corresponding placed bits and compare them and output according the following logic table A helper method providing NOT functionality to a pair of bytes
`private` `static` ``` byte``` `ByteNOT(``byte` `val1) `
```{ ```
`    ``return` `(``byte````)~val1;  ```
` ````} ```
`  ````//use as follows  ```
` ``byte` `notVal1 = 1; ````//00000001  ```
` ``byte` `outputNOT = ByteNOT(notVal1); `
` ````//returns 254 or 11111110   ```

The XOR (Exclusive OR) ( ^ sign in C#, Xor in vb.nET)  will take the corresponding placed bits and compare them and output according the following logic table A helper method providing NOT functionality to a pair of bytes
`private` `static` ``` byte``` `ByteXOR(``byte` `val1, ``byte` `val2) `
```{ ```
`    ``return` `Convert.ToByte(val1 ^ val2); `
```} ```
```//use as follows  ```
`byte` `xorVal1 = 6; ````//00000110  ```
`byte` `xorVal2 = 5; ````//00000101  ```
`byte` `outputXOR = ByteXOR(xorVal1, xorVal2); `
```//returns 3 or 00000011  ```

Note:In the following if you click the images you will see the animation

Next are shift operations

Left Shift to shift all bits to the left a specified number of times `private` `static` ``` byte``` `ShiftLeft(``byte` `val1, ``int` `shift) `
```{ ```
`    ``return` `(``byte``)(val1 << shift);````  ```
```} ```
```//use as follows  ```
`byte` `leftVal = 1; `
`byte` `outputLeftShift = ShiftLeft(leftVal, 1); ````//Shift one bit to left  ```
```//returns 2 or 00000010  ```

Right Shift to shift all bits to the left a specified number of times `private` `static` ``` byte``` `ShiftRight(``byte` `val1, ``int` `shift) `
```{ ```
`    ``return` `(``byte````)(val1 >> shift); ````//or val1 << (8 - shift));  `
```} ```
```//use as follows  ```
`byte` `rightVal = 2; `
`byte` `outputRightShift = ShiftRight(rightVal, 1); ````//Shift one bit to right  ```
```//returns 1 or 00000001  ```

Now we are going to create a circular shift method and note C# doesn’t include a built it operator for this… We are going create a method that does both right and left

`private` `static` ``` byte``` `CircularShift(``byte` `val, ``int` `shift, ``bool` `rightLeft) `
```{ ```
`     ``byte` `newVal = 0; `
`     ``if` `(rightLeft) `
`     ````{ ```
`         ````//Shift right  ```
`         ``newVal = (``byte````)(val >> shift | val << (8 - shift)); ```
`     ````} ```
`            ``else` `if` ```(!rightLeft) ```
`     ````{ ```
`         ````//Shift left  ```
`         ``newVal = (``byte````)(val << shift | val >> (8 - shift)); ```
`     ````} ```
`            ``return` `newVal; `
```} ```
```//use as follows  ```
`byte` `circRightVal = 1; ````//00000001  ```
`byte` `outputCircRight = CircularShift(circRightVal, 1, ` `true````); ```
```//returns 128 or 10000000  ```
`byte` `circLeftVal = 128; ````//10000000  ```
`byte` `outputCircLeft = CircularShift(circLeftVal, 1, ``false````); ```
```//returns 1 or 00000001  ```