int8 x = 12;
int8 y = 84;
int16 z = x + y; // ERROR: compiler is stupid int16 z = (x + y) as int16;
or int16 z = (x as int16) + (y as int16);
?byte foo = 4; byte boo = 86; byte arglebargle = foo + boo; // cast monkey! cast!
I remember old assembly language guys annoyed at the types of math available with high level languages. I think they were a bit crusty but still they had a point about inability to manage precision without big hammers.
At least the C# way forces you to think about whether you're loosing precision. But I dislike having to add casts. I use casts a lot, but I distrust the because they hide errors. I find myself really wanting safe operators and unsafe ones. Safe as in, overflow results in a hard fault that I can catch. Unsafe means overflow is silent.
The comment about assembly comes from remembering a conversation with an older firmware guy. In his world multiplying two 32 numbers resulted in a 64 bit result. And division was 64 bits divided by 32 bits with a 64 bit result, 32 bit result plus a 32 bit remainder.
I think his thoughts on C's 32 bit number X 32 number => 32 bit result can be summed up in a single word: gah!
How is that a solution to OP's problem?