C# Remainder - SyntBlaze

The % operator in C# is the remainder operator. It computes the remainder resulting from the division of its left-hand operand (dividend) by its right-hand operand (divisor).

var result = dividend % divisor;

Type Support and Numeric Promotion

The % operator is predefined for the following standard numeric types:

Integer types: int, uint, long, ulong.
Floating-point types: float, double.
High-precision decimal: decimal.

When the % operator is applied to smaller integral types (sbyte, byte, short, ushort), C# applies implicit numeric promotion. The operands are automatically converted to int before the operation is evaluated, and the resulting remainder is of type int.

byte a = 5;
byte b = 3;
var result = a % b; // result is of type int, not byte

Sign Determination Rules

In C#, the sign of a non-zero remainder is strictly determined by the left-hand operand (the dividend). The sign of the right-hand operand (the divisor) has no effect on the sign of the result.

Console.WriteLine( 5 %  3);  // Output:  2
Console.WriteLine(-5 %  3);  // Output: -2
Console.WriteLine( 5 % -3);  // Output:  2
Console.WriteLine(-5 % -3);  // Output: -2

Floating-Point Mechanics

Unlike some C-family languages, C# natively supports the % operator for floating-point types (float and double). For finite values, the remainder is conceptually calculated by truncating the intermediate quotient towards zero. Due to standard IEEE 754 floating-point precision mechanics, using float or double can result in minor precision artifacts. To achieve exact base-10 fractional remainders, the decimal type must be used:

Console.WriteLine(5.5m % 2.2m); // Output: 1.1 (Exact decimal evaluation)
Console.WriteLine(5.5 % 2.2);   // Output: 1.0999999999999996 (IEEE 754 double precision)

When evaluating floating-point operands, the % operator adheres to specific rules regarding NaN (Not a Number) and infinity:

If either operand is NaN, the result is NaN.
If the dividend is infinity, the result is NaN.
If the divisor is zero, the result is NaN (no exception is thrown).
If the dividend is finite and the divisor is infinity, the result is the dividend.

Console.WriteLine(5.0 % double.PositiveInfinity); // Output: 5
Console.WriteLine(double.PositiveInfinity % 5.0); // Output: NaN
Console.WriteLine(5.0 % 0.0);                     // Output: NaN

Exceptions and Edge Cases

The behavior of the % operator under exceptional conditions depends entirely on the numeric types involved:

Integer Division by Zero: Evaluating x % 0 where x is an integer type throws a DivideByZeroException.
Decimal Division by Zero: Evaluating x % 0m throws a DivideByZeroException.
Integer Overflow: Evaluating int.MinValue % -1 (or long.MinValue % -1L) throws an OverflowException. This occurs because the underlying division operation (int.MinValue / -1) results in a value that exceeds the maximum bounds of the signed integer type.