Why do the SByte and Int32 CompareTo() methods behave differently?

Question

If you run the following code:

SByte w = -5;
Console.WriteLine(w.CompareTo(0));

Int32 x = -5;
Console.WriteLine(x.CompareTo(0));

SByte y = 5;
Console.WriteLine(y.CompareTo(0));

Int32 z = 5;
Console.WriteLine(z.CompareTo(0));

then you get the following output:

-5
-1
5
1

Why do these methods with the same name that have almost identical descriptions in the MSDN documentation behave so differently?

Answer 1

Because the SByte.CompareTo() is implemented like

return m_value - value;

so a simple subtraction. This works because the m_value is converted automatically to int, and any possibile combination of values is "legal" with int.

With two Int32 this can't be done, because for example Int32.MinValue.CompareTo(Int32.MaxValue) would become Int32.MinValue - Int32.MaxValue that would be outside the int range, and in fact it is implemented as two comparisons:

if (m_value < value) return -1;
if (m_value > value) return 1;
return 0;

in general

The only important "thing" of the returned value of a CompareTo is its sign (or if it is 0). The "value" is irrelevant. The return value of 1, 5, 500, 5000, 5000000 of CompareTo() are the same. CompareTo can't be used to measure "distance" between numbers. So both implementations are equivalent.

It is totally wrong to do:

if (someValue.CompareTo(someOtherValue) == -1)

you must always

if (someValue.CompareTo(someOtherValue) < 0)

why the SByte.CompareTo is built that way

SByte.CompareTo is implementing a "branchless" comparison (there are no ifs in the code, the flow of code is linear). Processors have problems with branches, so branchless code could be faster than "branchful" code, so this microoptimization. Clearly SByte.CompareTo could have been written as Int32.CompareTo.

why any negative value is equivalent to -1 (and any positive value is equivalent to +1)

This is probably something that is derived directly from the C language: the qsort function for example to compare items uses a user-defined method that is like:

Pointer to a function that compares two elements.
This function is called repeatedly by qsort to compare two elements. It shall follow the following prototype:

int compar (const void* p1, const void* p2);

Taking two pointers as arguments (both converted to const void*). The function defines the order of the elements by returning (in a stable and transitive manner):
return value meaning
<0 The element pointed to by p1 goes before the element pointed to by p2
0 The element pointed to by p1 is equivalent to the element pointed to by p2
>0 The element pointed to by p1 goes after the element pointed to by p2

how is the .CompareTo implemented in other primitive types?

SByte, Byte, Int16, UInt16, Char all use the subtraction "method", while Int32, UInt32, Int64, UInt64 all use the if "method".

Answer 2

Looking at the source for these two methods, they are implemented differently:

public int CompareTo(sbyte value)
{
    return (int)(this - value);
}

vs

public int CompareTo(int value)
{
    if (this < value)
    {
        return -1;
    }

    if (this > value)
    {
        return 1;
    }

    return 0;
 }

But none of this matters, since the sign of the returned value is the only thing that you should be checking.