## DEV Community is a community of 908,655 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

Davide Bellone

Posted on • Updated on • Originally published at code4it.dev

# C# sorting - a subtle mistake

Recently I've noticed a funny (ehm...) thing.

## The guilty

It isn't true that the inverse of a negative number is always a positive number. Or, equally, that `(x < 0) -> (-x > 0)`.

You could say "Hey, -(-5) == 5". Yes, that's true.
We can test it this way:

``````[Test]
public void TestInverse()
{
int x = -5;
int y = -x;
Assert.IsTrue(y > 0);
}
``````

But what if we consider edge cases?

``````[Test]
public void TestInverse_EdgeCase()
{
int x = int.MinValue;
int y = -x;
Assert.IsTrue(y > 0);
}
``````

It will fail. Miserably.

## The reason

The reason is simple: the sign occupies space.
In fact, the range of int is -2,147,483,648 to 2,147,483,647. The inverse of -2,147,483,648 would cause overflow, and returns the same value.

## The lesson

Why am I pointing at this?

Imagine you are implementing a `CompareTo(x, y)` method, you know, the usual one that returns `0` if the values are considered equal, -1 if x < y and 1 if x > y.

You could use this method to sort an array.
Now you want to sort that array descending. What to do?

This edge case explains why it is a terrible idea to use `CompareTo(-x, -y)`. Results can be unexpected.

The best solution is to simply switch the parameters: `CompareTo(y, x)`.