Типы данных в C#: int, double, decimal, char, bool и их диапазоны

C# статически типизирован: у каждой переменной, поля и выражения есть тип, известный при компиляции. В языке есть набор встроенных типов со своими ключевыми словами (int, double, string...). Каждое ключевое слово это псевдоним типа из пространства имён System, поэтому int и System.Int32 это один и тот же тип, и string и System.String тоже один и тот же тип.

Встроенные типы

Целочисленный литерал без суффикса имеет тип int, а если он слишком велик для int, то первый из uint, long и ulong, в который он помещается; литерал с десятичной точкой имеет тип double. Поэтому float f = 2.5; и decimal d = 2.5; не компилируются: литерал имеет тип double, а неявного преобразования из double во float или decimal нет. Добавьте суффикс: 2.5f, 2.5m.

Каждый числовой тип предоставляет свои границы в виде констант:

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}");
    }
}

Вывод:

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

На практике большая часть кода использует четыре из них: int для счётчиков и индексов, long для идентификаторов и больших сумм, double для измерений и математики и decimal для денег.

decimal или double

double (и float) хранят числа в двоичном виде. У большинства десятичных дробей, включая 0.1, нет точного двоичного представления, поэтому они хранятся как ближайшее представимое значение, и мелкие ошибки накапливаются. decimal хранит десятичное целое плюс масштаб, поэтому 0.1 это ровно 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}");
    }
}

Вывод:

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

Используйте decimal для денег, цен, налогов и всего, что человек будет складывать вручную и сверять. Он сохраняет нули в конце из входных данных (1.50m печатается как 1.50) и имеет от 28 до 29 значащих цифр.

Используйте double для физических измерений, статистики, геометрии и игр. Он в несколько раз быстрее, занимает вдвое меньше памяти, а его диапазон огромен. Никогда не сравнивайте два вычисленных double через ==; сравнивайте разницу с допуском: Math.Abs(x - y) < 1e-9.

decimal не волшебный: 1m / 3m всё равно равно 0.3333333333333333333333333333, а арифметика double не выбрасывает исключение при делении на ноль (получается бесконечность или NaN для 0.0 / 0.0), тогда как деление на ноль у decimal и целых чисел выбрасывает DivideByZeroException.

Переполнение целых чисел и checked

Целочисленная арифметика, выходящая за диапазон типа, по умолчанию молча переходит через границу. Компилятор ловит переполнение в константных выражениях, но не тогда, когда значения берутся из переменных:

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);
    }
}

Вывод:

-2147483648
OverflowException
-1294967296
2147483648

checked(...) или блок checked { ... } превращает переполнение в OverflowException. Можно также включить проверку для всего проекта через <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. Запись int x = int.MaxValue + 1; с константами это ошибка компиляции (CS0220), потому что компилятор видит переполнение.

Последняя строка показывает исправление большинства ошибок переполнения: преобразуйте в более широкий тип до арифметики. (long)(max + 1) было бы неправильно, потому что к моменту приведения сложение уже переполнилось.

Типы значений и ссылочные типы

Каждый тип C# является либо типом значения, либо ссылочным типом, и от этого зависит, что делает присваивание.

• Типы значений: все числовые типы, bool, char, DateTime, перечисления и любая struct. Переменная содержит данные; присваивание их копирует.
• Ссылочные типы: string, массивы, object и любой class. Переменная содержит ссылку на объект; присваивание копирует ссылку, поэтому обе переменные видят один и тот же объект.

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}");
    }
}

Вывод:

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

string это ссылочный тип, который на практике ведёт себя как значение: он неизменяемый, а == сравнивает текст, а не ссылки. Подробнее о пользовательских типах значений в разделе структуры.

char и bool

char это одна кодовая единица UTF-16, записанная в одинарных кавычках. Внутри это числовой тип, поэтому он преобразуется в int и поддерживает арифметику:

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);
    }
}

Вывод:

66
C
True
True
7
b
True

У bool ровно два значения, и он не преобразуется в числа и из чисел: if (count) это ошибка компиляции, а не проверка на ненулевое значение. Пишите if (count != 0). Символы за пределами базовой многоязычной плоскости, например большинство эмодзи, занимают два значения char (суррогатную пару), поэтому Length у string считает единицы UTF-16, а не видимые символы.

Значения по умолчанию

Поля, элементы массивов и default(T) получают значение по умолчанию для своего типа: ноль для чисел, false для bool, '\0' для char и null для ссылочных типов. Локальные переменные значения по умолчанию не получают, и им нужно присвоить значение перед использованием.

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));
    }
}

Вывод:

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

Начиная с C# 7.1 можно писать литерал default без типа, если компилятор может его вывести (int x = default;). Тип значения не может быть null, и именно для этого существует int? (тип значения, допускающий null); см. типы, допускающие null.

Целые числа размера указателя и большие целые

Для особых случаев есть ещё два числовых типа. nint и nuint (C# 9) это целые числа размера указателя, 32 или 64 бита в зависимости от платформы, используемые во взаимодействии с нативным кодом и в низкоуровневом коде. System.Numerics.BigInteger хранит целые числа любого размера ценой скорости:

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