Integers, overflow and checked arithmetic

In C#, int.MaxValue + 1 is -2,147,483,648: the sum wraps around to the smallest int, and the program carries on without an error. Thirty orders of 1,000,000.00 each, counted in hundredths in an int, add up to -1,294,967,296 the same way.

C# integers come in fixed sizes, from the 8 bits of a byte to the 128 bits of Int128, and each has a smallest and a largest value. You will pick a type from the range its values reach, watch what happens one step past the edge, and turn that silent wraparound into an exception with checked arithmetic.

Each integer type holds a fixed range of whole numbers

An integer type stores a whole number in a fixed number of bits, and the bits decide its range. This program prints the smallest and largest value of each type, then the type that the compiler gives to some literals:

using System.Globalization;
using System.Runtime.CompilerServices;

// Every number prints with the invariant culture, the same on every computer.
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

Console.WriteLine("Type    Bits  Smallest to largest");
Row("sbyte", 8, sbyte.MinValue, sbyte.MaxValue);
Row("byte", 8, byte.MinValue, byte.MaxValue);
Row("short", 16, short.MinValue, short.MaxValue);
Row("ushort", 16, ushort.MinValue, ushort.MaxValue);
Row("int", 32, int.MinValue, int.MaxValue);
Row("uint", 32, uint.MinValue, uint.MaxValue);
Row("long", 64, long.MinValue, long.MaxValue);
Row("ulong", 64, ulong.MinValue, ulong.MaxValue);
Row("nint", nint.Size * 8, nint.MinValue, nint.MaxValue);
Console.WriteLine($"Int128 has 128 bits; its largest value is {Int128.MaxValue:N0}");

Console.WriteLine();
Console.WriteLine("Literal          Value          Type");
Literal(0x7FFF_FFFF);
Literal(0b1111_1111);
Literal(1_00_000);
Literal(3_000_000_000);
Literal(3_000_000_000L);
Literal(100U);
Literal(100UL);

static void Row<T>(string name, int bits, T min, T max)
    where T : IFormattable =>
    Console.WriteLine($"{name,-7} {bits,4}  {min:N0} to {max:N0}");

// CallerArgumentExpression hands the method the literal exactly as it is written.
static void Literal<T>(T value, [CallerArgumentExpression(nameof(value))] string text = "") =>
    Console.WriteLine($"{text,-16} {value,-14} {typeof(T).Name}");

Type    Bits  Smallest to largest
sbyte      8  -128 to 127
byte       8  0 to 255
short     16  -32,768 to 32,767
ushort    16  0 to 65,535
int       32  -2,147,483,648 to 2,147,483,647
uint      32  0 to 4,294,967,295
long      64  -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
ulong     64  0 to 18,446,744,073,709,551,615
nint      64  -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
Int128 has 128 bits; its largest value is 170,141,183,460,469,231,731,687,303,715,884,105,727

Literal          Value          Type
0x7FFF_FFFF      2147483647     Int32
0b1111_1111      255            Int32
1_00_000         100000         Int32
3_000_000_000    3000000000     UInt32
3_000_000_000L   3000000000     Int64
100U             100            UInt32
100UL            100            UInt64

The signed types, sbyte, short, int and long, spend one bit on the sign, so int stops at 2,147,483,647 while uint, with no sign, reaches 4,294,967,295. nint has the size of a pointer in the process that runs the program, 64 bits here. A literal can be hexadecimal (0x) or binary (0b), an underscore is only a separator for the reader, so 1_00_000 is 100,000, and a suffix picks the type: L for long, U for uint, UL for ulong.

Choose the type by the largest value the program can ever store:

• int for counts and indexes, the everyday choice: Microsoft’s conventions prefer it to the unsigned types.
• long when values can pass 2.1 billion, such as file sizes in bytes or money counted in its smallest unit.
• byte for the raw bytes of files and network messages.
• Int128, new in .NET 7, only for values past long’s 9.2 × 10¹⁸.

A result that does not fit wraps around, unless the code is checked

When a result is too big for its type, C# keeps the low bits that fit and drops the rest. Step through 127 + 1 in an sbyte, whose 8 bits make the arithmetic easy to follow:

Signed integers use two’s complementtwo's complement: The way .NET stores signed integers in binary: the top bit counts as minus 2 to the power of the bits below it, so 1000 0000 in an sbyte is -128, and one past the largest value reads back as the smallest., which is why one past the largest value reads back as the smallest. An int does the same at its edge:

using System.Globalization;

// Every number prints with the invariant culture, the same on every computer.
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// One past the largest value of a type wraps around to its smallest, with no error.
int max = int.MaxValue;
int next = max + 1;
Console.WriteLine($"int.MaxValue + 1 = {next:N0}");

sbyte small = 127;
small++;
Console.WriteLine($"127 in an sbyte, plus 1 = {small}");

byte full = 255;
full++;
Console.WriteLine($"255 in a byte, plus 1 = {full}");

uint none = 0;
none--;
Console.WriteLine($"0 in a uint, minus 1 = {none:N0}");

// 30 orders of 1,000,000.00 each, counted in hundredths (cents or paise).
int order = 100_000_000;
int totalInt = 0;
long totalLong = 0;
for (int i = 0; i < 30; i++)
{
    totalInt += order;
    totalLong += order;
}
Console.WriteLine($"30 orders, int total:  {totalInt:N0}");
Console.WriteLine($"30 orders, long total: {totalLong:N0}");

// checked turns the same overflow into an exception.
try
{
    int checkedNext = checked(max + 1);
    Console.WriteLine(checkedNext);
}
catch (OverflowException e)
{
    Console.WriteLine($"checked(max + 1): {e.GetType().Name}: {e.Message}");
}

int.MaxValue + 1 = -2,147,483,648
127 in an sbyte, plus 1 = -128
255 in a byte, plus 1 = 0
0 in a uint, minus 1 = 4,294,967,295
30 orders, int total:  -1,294,967,296
30 orders, long total: 3,000,000,000
checked(max + 1): OverflowException: Arithmetic operation resulted in an overflow.

The order totals are the realistic case: 30 orders of 100,000,000 hundredths make 3,000,000,000, which no int can hold, so the int total came out negative while the long total is right. Microsoft’s documentation describes the same edge in Environment.TickCount, the milliseconds since the computer started: it climbs for about 24.9 days to int.MaxValue, then jumps to int.MinValue.

This silent wrap is integer overflowinteger overflow: A result too large or too small for its integer type. By default C# keeps the low bits that fit, so the value wraps around without an error; in a checked context the operation throws OverflowException instead., and it is the default, because integer arithmetic in C# is unchecked unless you ask otherwise. Checked arithmetic is the other choice: inside checked(…) the same addition threw OverflowException, as the last line shows, so a wrong total stops the program instead of reaching a report. Four tools decide what happens at the edge of a type:

• checked, as a block or an expression, turns integer overflow inside it into an OverflowException.
• unchecked asks for wrapping on purpose, for example in a hash function.
• The project setting CheckForOverflowUnderflow makes checked arithmetic the default for every line of a project.
• A wider type, such as long for int, moves the edge beyond any value the program will meet.

Integer division and the remainder have edges of their own, with negative numbers and with zero.

Checked and unchecked contexts, reproduced in code Pro: opens with a Pro, Premium or Ultimate pass

Division, remainders, shifts and money in long, with the numbers Pro: opens with a Pro, Premium or Ultimate pass

Practise: totals that cannot wrap

Then try the questions on ranges and wraparound, with the idea you are less sure of first:

Interview questions

Fresher · What happens when an int overflows in C#?

By default nothing visible: integer arithmetic in C# is unchecked, so the result keeps only the low 32 bits and wraps around. int.MaxValue + 1 gives int.MinValue, -2,147,483,648, without an exception, and 30 orders of 100,000,000 hundredths summed in an int come out negative. In a checked context, a checked block or expression, or a project built with CheckForOverflowUnderflow, the same operation throws OverflowException. The defence is a type wide enough for every value, such as long for money in paise, plus checked arithmetic where a wrapped value would be wrong.

Key takeaways

• Each C# integer type has a fixed size and range: int stops at 2,147,483,647, long at about 9.2 × 10¹⁸.
• A literal’s value and suffix decide its type, and an underscore in a literal only helps the reader.
• By default a result that does not fit wraps around without an error, as int.MaxValue + 1 became int.MinValue.
• Checked arithmetic, a checked block or expression, turns that overflow into an OverflowException.