Comparing a "short" to a "ulong" causes compiler error CS0034

[Spontifixus]

In my codebase I have the following code:

 ulong ulongValue = 0;
 if (ulongValue > long.MaxValue) { /*...*/ }
 else if (ulongValue > uint.MaxValue) { /*...*/ }
 else if (ulongValue > int.MaxValue) { /*...*/ }
 else if (ulongValue > ushort.MaxValue) { /*...*/ }
 else if (ulongValue > short.MaxValue) { /*...*/ }
 else if (ulongValue > byte.MaxValue) { /*...*/ }

The statement ulongValue > short.MaxValue causes a compiler error:

CS0034: Operator '>' is ambiguous on operands of type 'ulong' and 'short'

All other comparisons work just fine. I could of course cast short.MaxValue to a ulong, but I don't see why that would be necessary in the first place.

I already had a look at the latest source files for the referenced types and found that the implementation of the CompareTo-methods of the Int16-type differs from that of all other numeric types:

• https://github.com/dotnet/corefx/blob/master/src/Common/src/CoreLib/System/UInt64.cs
• https://github.com/dotnet/corefx/blob/master/src/Common/src/CoreLib/System/Int16.cs

Is this intended bavior and I am doing something wrong here?

NB: The full .NET framework shows the same behavior.

[benaadams]

Issue for C# compiler https://github.com/dotnet/roslyn rather than runtime?

[PathogenDavid]

This is intended behavior. (Section numbers below refer to C# Language Specification 5.0.)

---

The reason the ulong/short comparison is invalid is due to this rule: (§4.1.5 / Integral Types)

For the binary +, –, *, /, %, &, ^, |, ==, !=, >, <, >=, and <= operators, the operands are converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of both operands.

Emphasis mine. Not all values of short can be converted to all values of ulong, so the conversion isn't permitted.

---

The reason the ulong/int.MaxValue and ulong/long.MaxValue comparisons are allowed is due to this one: (§6.1.9 / Implicit constant expression conversions)

An implicit constant expression conversion permits the following conversions:

• A constant-expression (§7.19) of type int can be converted to type sbyte, byte, short, ushort, uint, or ulong, provided the value of the constant-expression is within the range of the destination type.
• A constant-expression of type long can be converted to type ulong, provided the value of the constant-expression is not negative.

There is no rule like this for 16 or 8 bit types.

Additionally, if you modify your code to not use a constant, you can see it no longer compiles:

void Test(ulong ulongValue)
{
    int maxInt = int.MaxValue;
    if (ulongValue > maxInt) {} // CS0034
}

[Spontifixus]

Thank you for clarifying this!