Type casting needed for byte = byte - byte?

Question

I have the following code:

foreach (byte b in bytes)
{
    byte inv = byte.MaxValue - b;
    // Add the new value to a list....
}

When I do this I get the following error:

Cannot implicitly convert type 'int' to 'byte'. 
An explicit conversion exists (are you missing a cast?)

Each part of this statement is a byte. Why does C# want to convert the byte.MaxValue - b to an int?

Shouldn't you be able to do this some how without casting? (i.e. I don't want to have to do this: byte inv = (byte) (byte.MaxValue - b);)

Answer 1

According to the C# Language Reference:

because the arithmetic expression on the right-hand side of the assignment operator evaluates to int by default.

The reason for this could be because your processor is going to be faster at accessing a 4-byte memory address than a 1-byte memory address, so arithmetic operators are defined to work on 4-byte operands.

Answer 2

For addition, multiplication, and subtraction, there's a fairly good explanation: Including the carry bits in the calculation and then throwing them away is far easier than figuring out the carry bits if they were thrown away originally.

For bitwise operators (intersection, inclusive union, exclusive union, complement) that reasoning simply doesn't hold water. The only thing I can think of is that sign-extension would be somewhat ambiguous if you started with a mixture of signed and unsigned operands and then saved the result in a wider type. But that doesn't explain why bitwise operations which are unary or where all operands have the same type should widen the result to int. I consider it a very annoying design flaw with C# that:

byte a, b;
byte c = a | b;

generates an error.

Answer 3

Raymond Chen answers your question here:

http://blogs.msdn.com/oldnewthing/archive/2004/03/10/87247.aspx