c# convert two ushort values into one byte using low bits and high bits

Question

I am having a question, I need to convert to two u short numbers lets say 1 and 2 to 1 byte. someting like

0 0 1 0 values of 2 and 0 0 0 1 value of 1

so in result i get a byte with value 00100001 , Is it possible, I am not a master low level coder.

Answer 1

这应该工作：

 (byte)(((value1 & 0xF)<<4) | (value2 & 0xF))

Answer 2

I am not a master low level coder.

Well, now is the time to become one!

Edit: this answer was made before the question was clear enough to understand exactly what was required. See other answers.

Use a 'bit mask' on the two numbers, then bitwise-OR them together.
I can't quite tell how you exactly want it, but let's say you wanted the first 4 bits of the first ushort , then the last 4 bits of the second ushort . To note: ushort is 16 bits wide.

ushort u1 = 44828; //10101111 00011100 in binary
ushort u2 = 65384; //11111111 01101000 in binary

int u1_first4bits = (u1 & 0xF000) >> 8;

The 'mask' is 0xF000. It masks over u1:

44828         1010 1111 0001 1100
0xF000        1111 0000 0000 0000
bitwise-AND   1010 0000 0000 0000

The problem is, this new number is still 16 bits long - we must shift it by 8 bits with >> 8 to make it
0000 0000 1010 0000

Then another mask operation on the second number:

int u2_last4bits  =  u2 & 0x000F;

Illustrated:

65384         1111 1111 0110 1000
0x000F        0000 0000 0000 1111
bitwise-AND   0000 0000 0000 1000

Here, we did not need to shift the bits, as they are already where we want them.
Then we bitwise-OR them together:

byte b1 = (byte)(u1_first4bits | u2_last4bits);
//b1 is now 10101000 which is 168

Illustrated:

u1_first4bits 0000 0000 1010 0000
u2_last4bits  0000 0000 0000 1000
bitwise-OR    0000 0000 1010 1000

Notice that u1_first4bits and u2_first4bits needed to be of type int - this is because C# bitwise operations return int . To create our byte b1 , we had to cast the bitwase-OR operation to a byte.

Answer 3

Assuming, you want to take the 2 ushorts (16 bit each) and convert them to a 32 bit representation (integer), you can use the "BitArray" Class, fill it with a 4 byte array, and convert it to an integer.

The following example will produce:

 00000000 00000010 00000000 00000001

which is

 131073

as integer.

ushort x1 = 1;
ushort x2 = 2;

//get the bytes of the ushorts. 2 byte per number. 
byte[] b1 = System.BitConverter.GetBytes(x1);
byte[] b2 = System.BitConverter.GetBytes(x2);

//Combine the two arrays to one array of length 4. 
byte[] result = new Byte[4];
result[0] = b1[0];
result[1] = b1[1];
result[2] = b2[0];
result[3] = b2[1];

//fill the bitArray.
BitArray br = new BitArray(result);

//test output.
int c = 0;
for (int i = br.Length -1; i >= 0; i--){

    Console.Write(br.Get(i)? "1":"0");
    if (++c == 8)
    {
        Console.Write(" ");
        c = 0;
    }
}

//convert to int and output. 
int[] array = new int[1];
br.CopyTo(array, 0);
Console.WriteLine();
Console.Write(array[0]);

Console.ReadLine();

Of course you can alter this example and throw away 1 Byte per ushort. But this wouldn't be a correct "conversion" then.