Question

I was a looking at the source code of a project, and I noticed the following statement (both keyByte and codedByte are of type byte):

return (byte)(keyByte - codedByte);

I’m trying now to understand what would the result be in cases where keyByte is smaller than codedByte, which results in a negative integer.

After some experiments to understand the result of casting a negative integer which has a value in the range [-255 : -1], I got the following results:

byte result = (byte) (-6);  // result = 250
byte result = (byte) (-50); // result = 206
byte result = (byte) (-17); // result = 239
byte result = (byte) (-20); // result = 236

So, provided that -256 < a < 0 , I was able to determine the result by:

result = 256 + a;

My question is: should I always expect this to be the case?

Answer 1

Yes, that will always be the case (i.e. it is not simply dependent on your environment or compiler, but is defined as part of the C# language spec). See http://msdn.microsoft.com/en-us/library/aa691349(v=vs.71).aspx:

In an unchecked context, the result is truncated by discarding any high-order bits that do not fit in the destination type.

The next question is, if you take away the high-order bits of a negative int between -256 and -1, and read it as a byte, what do you get? This is what you’ve already discovered through experimentation: it is 256 + x.

Note that endianness does not matter because we’re discarding the high-order (or most significant) bits, not the “first” 24 bits. So regardless of which end we took it from, we’re left with the least significant byte that made up that int.