Handling Integer Reversal with Overflow Check in C#

I am working on a function to reverse an integer in C# while also handling negative numbers. I have come up with the following implementation:

public void Reverse(int x)
    {
        const int INT_MAX = 2147483647;
        const int INT_MIN = -2147483648;

        bool isNegative = false;
        if (x < 0)
        {
            isNegative = true;
            x = Math.Abs(x);
        }

        long reversed = 0;
        while (x != 0)
        {
            int lastDigit = x % 10;
            reversed = reversed * 10 + lastDigit;
            x = x / 10;
        }

        if (isNegative)
        {
            reversed = -reversed;
        }

        if (reversed > INT_MAX || reversed < INT_MIN)
        {
            Console.WriteLine(0);
        }

        Console.WriteLine ((int)reversed);
    }

The function seems to work fine for positive numbers, but when I pass in INT_MIN, which is -2147483648, I encounter unexpected behavior. The Math.Abs(x) call throws a System.OverflowException: Negating the minimum value of a two's complement number is invalid.

My intention was to convert the input integer to its absolute value before reversing it, so the function can correctly handle negative numbers. However, it seems that taking the absolute value of INT_MIN is causing an overflow in this implementation.

Can someone please suggest how I can handle the reversal of negative numbers while also avoiding overflow?

There are a couple of things you can do: use a long for your intermediate value or ignore negatives.

The modulus operator % works just fine on negative numbers and returns a negative result. So the range of possible outputs from x % 10 is [-9..9]. For what you're trying to do this means that you don't have to explicitly handle negative numbers, you can just ignore them.

This simplifies the method significantly:

static long Reverse(int x)
{
	long result = 0;
	while (x != 0)
	{
		result = result * 10 + x % 10;
		x /= 10;
	}
	return result;
}

For int.MinValue (your INT_MIN) the sequence goes like this:

Since I like nice compact code, let's use a for loop to cut down the lines:

static long Reverse(int x)
{
	long result = 0;
	for (; value != 0; value /= 10)
		result = result * 10 + value % 10;
	return result;
}

(Yes, I could have put the body in the loop increment too, but this is easier to read.)