OverflowException: Value was either too large or too small for an int32

This error occurs when trying to convert a string to an integer, but the value in the string exceeds the allowable range for the Int32 type.

In C#, the Int32 type, commonly referred to as int, is a 32-bit signed integer that can only represent values between -2,147,483,648 (Int32.MinValue) and 2,147,483,647 (Int32.MaxValue). When attempting to parse a string that represents a number outside this range using int.Parse() or Convert.ToInt32(), an OverflowException is thrown.

string input = "9223372036854775807"; // exceeds the range of Int32
int number = int.Parse(input); // throws OverflowException

The cause of the OverflowException is simple: the value you're trying to parse is outside the bounds of the Int32 range. The Int32 type can store only values from -2,147,483,648 to 2,147,483,647. Any attempt to convert a number that falls outside this range results in an overflow, leading to the exception.

To fix this issue, you need to either use a larger integer type or handle invalid inputs more gracefully.

1. Use a Larger Integer Type

If you're working with values that might exceed the Int32 range, consider using a larger integer type such as Int64 (long) or BigInteger.

Using Int64 (long)

Int64 (also known as long) is a 64-bit signed integer and can handle much larger values. It has a range of -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.

long longValue = long.Parse("9223372036854775807");
Console.WriteLine(longValue); // Outputs: 9223372036854775807

Using BigInteger

If you need to work with numbers that can be arbitrarily large, BigInteger from the System.Numerics namespace allows you to store integers with no practical limit. This is especially useful when working with extremely large numbers in financial or scientific applications.

using System.Numerics;

BigInteger bigIntValue = BigInteger.Parse("9999999999999999999999999999999999999999");
Console.WriteLine(bigIntValue); // Outputs: 9999999999999999999999999999999999999999

Integer Max Sizes

Here is a reference table for common integer types in C#:

2. Use int.TryParse()

Another way to handle the OverflowException is by using int.TryParse() instead of int.Parse(). The advantage of TryParse() is that it doesn’t throw an exception if the value is invalid. Instead, it returns false when the parsing fails, allowing you to decide how to handle invalid input without using a try/catch block.

string input = "9223372036854775807";

if (int.TryParse(input, out int result))
{
    // Use the valid integer
    Console.WriteLine("Parsed successfully: " + result);
}
else
{
    // Handle invalid input (e.g., log the error, return a default value, etc.)
    Console.WriteLine("Invalid input. Could not parse the number.");
}

This method is cleaner and more efficient than using a try/catch block, especially when dealing with user input or data that may not be well-formed.