What are the built-in numeric data types in C#? When do you use int, long, double or decimal, and how do overflow, checked arithmetic and floating-point precision affect real code?

1. Integer representation: two's complement

Signed integers use two's complement: the top bit has negative weight. For sbyte, 0111_1111 is 127 and 1000_0000 is -128. Adding 1 to 127 just carries into the top bit, giving -128 — that is why overflow "wraps". The CPU sets an overflow flag, but in an unchecked context the JIT ignores it.

In a checked context the compiler emits different IL opcodes — add.ovf, mul.ovf, conv.ovf.i4 — and the JIT turns those into an instruction plus a conditional jump to a throw helper (jo on x64). The cost is small (a predictable branch), which is why checking money or quota arithmetic is usually affordable.

checked(a + b)   ->  add.ovf      ->  add eax, edx ; jo ThrowOverflow
unchecked(a + b) ->  add          ->  add eax, edx

Constant expressions are always checked at compile time: int x = int.MaxValue + 1; is error CS0220 unless wrapped in unchecked.

2. IEEE 754 binary floating point

double is 64 bits: 1 sign bit, 11 exponent bits, 52 fraction bits (plus an implicit leading 1). Its value is ±1.fraction × 2^(exponent − 1023).

• Only fractions with a power-of-two denominator are exact (0.5, 0.25, 0.375). 0.1 becomes 0.1000000000000000055511151231257827....
• Precision is relative: near 1.0 the gap between adjacent doubles is ~2.2e-16 (double.Epsilon is not that — it is the smallest positive subnormal, ~4.9e-324). Near 1e16 the gap is 2.0, so 1e16 + 1 == 1e16.
• Special values: +0 and -0, ±Infinity, and NaN (many bit patterns). NaN != NaN, which breaks naive sorting and dictionary keys.
• Since .NET Core 3.0, double.ToString() produces the shortest round-trippable string, so 0.1 + 0.2 prints as 0.30000000000000004 rather than hiding the error.

Operations are not associative: (a + b) + c can differ from a + (b + c). Summing a large array in a different order (or in parallel, or with SIMD) can change the last digits. For stable totals, sort ascending or use Kahan summation.

3. How decimal works

System.Decimal is a 128-bit decimal floating-point number:

• a 96-bit unsigned integer coefficient,
• a scale from 0 to 28 (the power of ten to divide by),
• a sign bit.

So 19.95m is stored as 1995 × 10^-2. Any base-10 fraction with up to 28–29 digits is exact. Operations are implemented in software (no hardware instruction), which makes them roughly an order of magnitude slower than double, but for business code that cost is negligible compared with I/O.

decimal preserves scale: 1.10m and 1.1m are equal but print differently. Division can still round: 1m / 3m is 0.3333333333333333333333333333. Exactness is about base-10 fractions, not about infinite precision.

4. Implicit and explicit conversions

• Widening conversions are implicit when no information is lost in magnitude: int → long, int → double, float → double.
• Some implicit conversions lose precision silently: long → double (doubles have only 53 bits of mantissa, so large IDs get rounded) and long → float.
• There is no implicit conversion between double and decimal in either direction — the language forces you to decide.
• Explicit casts from floating point to integer truncate toward zero ((int)2.9 == 2, (int)-2.9 == -2). Out-of-range casts from double to int were platform-dependent historically; .NET 9 standardised saturating behaviour on x86/x64, but code should never rely on it — validate the range first.

5. Generic math (.NET 7+)

Interfaces such as INumber<T>, IBinaryInteger<T> and IFloatingPoint<T> let you write one algorithm for all numeric types:

static T Sum<T>(ReadOnlySpan<T> values) where T : INumber<T>
{
    T total = T.Zero;
    foreach (var v in values) total += v;
    return total;
}

They also make conversion policy explicit: int.CreateChecked(x) throws, CreateSaturating clamps, CreateTruncating wraps.

6. Database and serialisation boundaries

• SQL Server int/bigint map to int/long; decimal(p,s) maps to decimal — configure precision in EF Core, otherwise you get a warning and the provider default decimal(18,2), which may truncate rates like 0.0725.
• SQL float is a double; never store money in it.
• JSON numbers have no type; JavaScript clients parse them as double, so a long ID above 2⁵³ (9,007,199,254,740,992) loses precision in the browser. Serialise large IDs as strings (JsonNumberHandling.WriteAsString).

Try it yourself

1. Print 0.1 + 0.2 and 0.1m + 0.2m, then compare each with 0.3.
2. Run int x = int.MaxValue; x++; with and without <CheckForOverflowUnderflow>.
3. Sum 1,000,000 copies of 0.1 as double and as decimal and compare to 100000.
4. Cast long id = 9_007_199_254_740_993; to double and back and observe the change.

namespace Basics;

public static class Numbers
{
    public static void Main()
    {
        // 1. Binary floating point vs decimal
        Console.WriteLine(0.1 + 0.2 == 0.3);     // False
        Console.WriteLine(0.1m + 0.2m == 0.3m);  // True

        // 2. Silent wrap vs checked
        int count = int.MaxValue;
        Console.WriteLine(count + 1);            // -2147483648
        try
        {
            Console.WriteLine(checked(count + 1));
        }
        catch (OverflowException ex)
        {
            Console.WriteLine($"Caught: {ex.Message}");
        }

        // 3. Division by zero differs by type
        double d = 0;
        Console.WriteLine(1 / d);                // ∞
        Console.WriteLine(double.IsNaN(0 / d));  // True
        // Console.WriteLine(1 / 0);             // CS0020 for constants; DivideByZeroException for variables

        // 4. Rounding money explicitly
        decimal lineTotal = 2.345m;
        Console.WriteLine(Math.Round(lineTotal, 2));                                 // 2.34 (ToEven)
        Console.WriteLine(Math.Round(lineTotal, 2, MidpointRounding.AwayFromZero));  // 2.35
    }

    // Money calculation: decimal end to end, round once per line
    public static decimal InvoiceTotal(IEnumerable<(decimal UnitPrice, int Qty)> lines, decimal gstRate = 0.10m)
    {
        decimal subtotal = 0m;
        foreach (var (unitPrice, qty) in lines)
        {
            subtotal += checked(Math.Round(unitPrice * qty, 2, MidpointRounding.AwayFromZero));
        }
        return Math.Round(subtotal * (1 + gstRate), 2, MidpointRounding.AwayFromZero);
    }
}