C# Data Types: int, double, decimal, char, bool and Their Ranges

C# is statically typed: every variable, field and expression has a type known at compile time. The language has a set of built-in types with keywords of their own (int, double, string...). Each keyword is an alias for a type in the System namespace, so int and System.Int32 are the same type, and string and System.String are the same type.

The built-in types

An integer literal without a suffix is an int, or the first of uint, long and ulong that can hold it if it is too big for an int, and a literal with a decimal point is a double. That is why float f = 2.5; and decimal d = 2.5; fail to compile: the literal is a double, and there is no implicit conversion from double to float or decimal. Add the suffix: 2.5f, 2.5m.

Every numeric type exposes its limits as constants:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"byte:  {byte.MinValue} to {byte.MaxValue}");
        Console.WriteLine($"short: {short.MinValue} to {short.MaxValue}");
        Console.WriteLine($"int:   {int.MinValue} to {int.MaxValue}");
        Console.WriteLine($"long:  {long.MinValue} to {long.MaxValue}");
        Console.WriteLine($"decimal max: {decimal.MaxValue}");
        Console.WriteLine($"double max:  {double.MaxValue:E3}");
        Console.WriteLine($"sizes: int {sizeof(int)}, long {sizeof(long)}, double {sizeof(double)}, char {sizeof(char)}");

        int hex = 0xFF;             // hexadecimal
        int bits = 0b1010_0001;     // binary (C# 7)
        long big = 3_000_000_000;   // digit separators (C# 7)
        Console.WriteLine($"{hex} {bits} {big}");
    }
}

Output:

byte:  0 to 255
short: -32768 to 32767
int:   -2147483648 to 2147483647
long:  -9223372036854775808 to 9223372036854775807
decimal max: 79228162514264337593543950335
double max:  1.798E+308
sizes: int 4, long 8, double 8, char 2
255 161 3000000000

In practice most code uses four of these: int for counts and indexes, long for IDs and large totals, double for measurements and math, and decimal for money.

decimal vs double

double (and float) store numbers in binary. Most decimal fractions, including 0.1, have no exact binary form, so they are stored as the nearest representable value and small errors accumulate. decimal stores a base-10 integer plus a scale, so 0.1 is exactly 0.1.

using System;

class Program
{
    static void Main()
    {
        double a = 0.1 + 0.2;
        decimal b = 0.1m + 0.2m;
        Console.WriteLine(a == 0.3);          // False
        Console.WriteLine(b == 0.3m);         // True
        Console.WriteLine(a.ToString("G17")); // 17 significant digits
        Console.WriteLine(b);

        double dsum = 0;
        decimal msum = 0;
        for (int i = 0; i < 10; i++)
        {
            dsum += 0.1;
            msum += 0.1m;
        }
        Console.WriteLine($"double sum == 1.0: {dsum == 1.0}");
        Console.WriteLine($"decimal sum == 1.0: {msum == 1.0m}");

        decimal price = 19.99m;
        int quantity = 3;
        decimal total = price * quantity;
        Console.WriteLine($"Total: {total}");
        Console.WriteLine($"Split three ways: {total / 3}");
    }
}

Output:

False
True
0.30000000000000004
0.3
double sum == 1.0: False
decimal sum == 1.0: True
Total: 59.97
Split three ways: 19.99

Use decimal for money, prices, tax and anything a person will add up by hand and compare. It keeps trailing zeros from its inputs (1.50m prints as 1.50) and has 28 to 29 significant digits.

Use double for physical measurements, statistics, geometry and games. It is several times faster, uses half the memory, and its range is enormous. Never compare two computed doubles with ==; compare the difference against a tolerance: Math.Abs(x - y) < 1e-9.

decimal is not magic: 1m / 3m is still 0.3333333333333333333333333333, and double arithmetic does not throw on division by zero (it produces infinity, or NaN for 0.0 / 0.0), while decimal and integer division by zero throw a DivideByZeroException.

Integer overflow and checked

Integer arithmetic that exceeds the type's range wraps around by default, silently. The compiler catches overflow in constant expressions, but not when the values come from variables:

using System;

class Program
{
    static void Main()
    {
        int max = int.MaxValue;
        int wrapped = max + 1;           // no error: wraps around
        Console.WriteLine(wrapped);

        try
        {
            int safe = checked(max + 1); // throws instead of wrapping
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("OverflowException");
        }

        long views = 3_000_000_000;
        int truncated = unchecked((int)views); // explicit narrowing keeps low 32 bits
        Console.WriteLine(truncated);

        long total = (long)max + 1;       // widen first to get the right answer
        Console.WriteLine(total);
    }
}

Output:

-2147483648
OverflowException
-1294967296
2147483648

checked(...) or a checked { ... } block turns overflow into an OverflowException. You can also turn it on for the whole project with <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. Writing int x = int.MaxValue + 1; with constants is a compile error (CS0220), because the compiler can see the overflow.

The last line shows the fix for most overflow bugs: convert to a wider type before the arithmetic. (long)(max + 1) would be wrong, since the addition has already wrapped by the time the cast runs.

Value types and reference types

Every C# type is either a value type or a reference type, and the difference decides what assignment does.

• Value types: all numeric types, bool, char, DateTime, enums, and every struct. The variable contains the data; assignment copies it.
• Reference types: string, arrays, object, and every class. The variable contains a reference to an object; assignment copies the reference, so both variables see the same object.

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        int b = a;      // copy of the value
        b = 99;
        Console.WriteLine($"a={a} b={b}");

        int[] first = { 1, 2, 3 };
        int[] second = first;   // copy of the reference
        second[0] = 99;
        Console.WriteLine($"first[0]={first[0]}");

        string s1 = "cat";
        string s2 = s1;
        s2 += "s";              // strings are immutable: s2 now refers to a new string
        Console.WriteLine($"s1={s1} s2={s2}");
    }
}

Output:

a=10 b=99
first[0]=99
s1=cat s2=cats

string is a reference type that behaves like a value in practice: it is immutable, and == compares the text, not the references. More on user-defined value types in structs.

char and bool

A char is one UTF-16 code unit, written in single quotes. It is a numeric type underneath, so it converts to int and supports arithmetic:

using System;

class Program
{
    static void Main()
    {
        char grade = 'B';
        Console.WriteLine((int)grade);           // 66
        Console.WriteLine((char)(grade + 1));    // C
        Console.WriteLine(char.IsLetter(grade));
        Console.WriteLine(char.IsDigit('7'));
        Console.WriteLine('7' - '0');             // digit char to its value
        Console.WriteLine(char.ToLower(grade));

        bool isOpen = true;
        bool hasStock = false;
        Console.WriteLine(isOpen && !hasStock);
    }
}

Output:

66
C
True
True
7
b
True

bool has exactly two values and does not convert to or from numbers: if (count) is a compile error, not a test for non-zero. Write if (count != 0). Characters outside the Basic Multilingual Plane, such as most emoji, take two char values (a surrogate pair), so a string's Length counts UTF-16 units, not visible characters.

Default values

Fields, array elements and default(T) get the type's default value: zero for numbers, false for bool, '\0' for char, and null for reference types. Local variables get no default and must be assigned before use.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(default(int));
        Console.WriteLine(default(decimal));
        Console.WriteLine(default(bool));
        Console.WriteLine(default(string) == null);
        Console.WriteLine(default(DateTime).ToString("yyyy-MM-dd"));

        var counts = new int[3];
        Console.WriteLine(string.Join(",", counts));
    }
}

Output:

0
0
False
True
0001-01-01
0,0,0

Since C# 7.1 you can write the default literal without the type when the compiler can infer it (int x = default;). A value type cannot be null, which is what int? (a nullable value type) is for; see nullable types.

Native-sized and big integers

Two more numeric types exist for special cases. nint and nuint (C# 9) are integers the size of a pointer, 32 or 64 bits depending on the platform, used in interop and low-level code. System.Numerics.BigInteger holds integers of any size, at the cost of speed:

using System.Numerics;
BigInteger factorial = 1;
for (int i = 2; i <= 30; i++) factorial *= i;
// 265252859812191058636308480000000