Строку в int в C#: приведение и преобразование типов, Parse, TryParse, Convert

C# никогда сам не преобразует несвязанные типы. Строка, содержащая цифры, остаётся строкой, а double не превращается незаметно в int. Вы преобразуете явно, а инструмент зависит от того, что именно преобразуется: текст в число (разбор), один числовой тип в другой (приведение) или объект в более конкретный тип (as, is).

Строку в int: Parse, TryParse и Convert

Есть три стандартных способа превратить текст в int:

using System;

class Program
{
    static void Main()
    {
        string text = "1250";

        int a = int.Parse(text);
        int b = Convert.ToInt32(text);
        Console.WriteLine(a + b);

        if (int.TryParse(text, out int c))
        {
            Console.WriteLine($"TryParse ok: {c}");
        }

        if (!int.TryParse("12 apples", out int d))
        {
            Console.WriteLine($"TryParse failed, d = {d}");
        }

        Console.WriteLine(int.Parse("  42 "));   // surrounding spaces are allowed
        Console.WriteLine(int.Parse("-17"));
    }
}

Вывод:

2500
TryParse ok: 1250
TryParse failed, d = 0
42
-17

int.TryParse возвращает bool и записывает результат в переменную out, которая при неудаче получает 0. Поскольку плохой ввод нормален для всего, что набирает пользователь, TryParse это выбор по умолчанию для ввода, файлов и строк запроса. Те же методы есть у каждого числового типа: long.TryParse, double.TryParse, decimal.Parse и так далее.

Что каждый из них делает с плохим вводом

Три метода различаются только тем, как они сообщают о неудаче:

using System;

class Program
{
    static void Try(string label, Func<int> parse)
    {
        try
        {
            Console.WriteLine($"{label} = {parse()}");
        }
        catch (Exception e)
        {
            Console.WriteLine($"{label} throws {e.GetType().Name}");
        }
    }

    static void Main()
    {
        string empty = null;
        Try("int.Parse(null)", () => int.Parse(empty));
        Try("Convert.ToInt32(null)", () => Convert.ToInt32(empty));
        Try("int.Parse(\"abc\")", () => int.Parse("abc"));
        Try("int.Parse(\"12.5\")", () => int.Parse("12.5"));
        Try("int.Parse(\"1,000\")", () => int.Parse("1,000"));
        Try("int.Parse(\"9999999999\")", () => int.Parse("9999999999"));
        Try("int.Parse(\"\")", () => int.Parse(""));
    }
}

Вывод:

int.Parse(null) throws ArgumentNullException
Convert.ToInt32(null) = 0
int.Parse("abc") throws FormatException
int.Parse("12.5") throws FormatException
int.Parse("1,000") throws FormatException
int.Parse("9999999999") throws OverflowException
int.Parse("") throws FormatException

FormatException несёт знакомое сообщение «Input string was not in a correct format» (в .NET 8 и новее «The input string '12.5' was not in a correct format» с цитатой текста) и это одна из самых частых ошибок времени выполнения в C#: "12.5" это не int, и "1,000" тоже. Чтобы принимать такие строки, разбирайте их как decimal или укажите парсеру, какие стили допустимы:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var inv = CultureInfo.InvariantCulture;

        int withCommas = int.Parse("1,000", NumberStyles.AllowThousands, inv);
        int fromHex = int.Parse("FF", NumberStyles.HexNumber);
        decimal price = decimal.Parse("12.5", inv);
        int rounded = (int)Math.Round(price, MidpointRounding.AwayFromZero);

        Console.WriteLine(withCommas);
        Console.WriteLine(fromHex);
        Console.WriteLine(rounded);
        Console.WriteLine(Convert.ToInt32("1010", 2));  // from binary
    }
}

Вывод:

1000
255
13
10

Культура: почему «1.5» может стать 15

По умолчанию разбор использует текущую культуру, а культуры расходятся в разделителях. В немецкой и ряде других европейских культур десятичный разделитель это запятая, а точка разделяет тысячи. Одна и та же строка даёт разные числа:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var german = new CultureInfo("de-DE");
        var inv = CultureInfo.InvariantCulture;

        decimal a = decimal.Parse("1.5", inv);
        decimal b = decimal.Parse("1.5", german);   // "." is a group separator here
        decimal c = decimal.Parse("1,5", german);

        Console.WriteLine(a.ToString(inv));
        Console.WriteLine(b.ToString(inv));
        Console.WriteLine(c.ToString(inv));
    }
}

Вывод:

1.5
15
1.5

Код, который читает файлы данных, JSON, конфигурацию или что-то сгенерированное машиной, всегда должен передавать CultureInfo.InvariantCulture и при разборе, и при форматировании. Иначе одна и та же программа работает на машине разработчика и неправильно читает каждое число на сервере с другим языком. Используйте текущую культуру только для текста, который набрал или будет читать человек.

Неявные и явные числовые преобразования

Расширяющие преобразования выполняются неявно: int в long, int в double, float в double, int в decimal. Преобразование, которое может потерять величину значения или его дробную часть, требует явного приведения (type)value. Одно исключение стоит помнить: int или long во float и long в double выполняются неявно, хотя могут терять точность: float f = 16_777_217; компилируется и сохраняет 16777216.

using System;

class Program
{
    static void Main()
    {
        int items = 7;
        long bigItems = items;       // implicit: always fits
        double ratio = items;        // implicit
        decimal money = items;       // implicit

        double price = 9.99;
        int whole = (int)price;      // explicit: truncates toward zero
        int negative = (int)-9.99;
        Console.WriteLine($"{whole} {negative}");

        Console.WriteLine(Convert.ToInt32(9.99));   // rounds
        Console.WriteLine(Convert.ToInt32(2.5));    // halves go to even: 2
        Console.WriteLine(Convert.ToInt32(3.5));    // 4

        long large = 5_000_000_000;
        int wrapped = (int)large;    // keeps the low 32 bits
        Console.WriteLine(wrapped);

        decimal amount = (decimal)price;  // double to decimal: explicit
        Console.WriteLine(amount);
        Console.WriteLine($"{bigItems} {ratio:F1} {money}");
    }
}

Вывод:

9 -9
10
2
4
705032704
9.99
7 7.0 7

Три вещи нужно запомнить. Приведение числа с плавающей точкой к целому отбрасывает дробную часть, а не округляет. Convert.ToInt32(double) округляет по банковскому правилу (половины идут к чётному соседу). А целочисленное приведение, в которое значение не помещается, молча переходит через границу, если не выполняется в контексте checked, где выбрасывается OverflowException (см. типы данных).

int x = 3.7; это ошибка компиляции (CS0266: cannot implicitly convert type 'double' to 'int', an explicit conversion exists): так компилятор просит вас выбрать между приведением и методом округления.

Числа и другие типы в строку

У каждого типа есть ToString(), а числовые типы принимают строку формата. Интерполяция строк вызывает то же форматирование:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        int orderId = 42;
        decimal total = 1234.5m;
        var us = new CultureInfo("en-US");

        Console.WriteLine(orderId.ToString());
        Console.WriteLine(orderId.ToString("D6"));        // 000042
        Console.WriteLine(total.ToString("F2"));          // 1234.50
        Console.WriteLine(total.ToString("N2", us));      // 1,234.50
        Console.WriteLine(total.ToString("C", us));       // $1,234.50
        Console.WriteLine(255.ToString("X"));             // FF
        Console.WriteLine(Convert.ToString(10, 2));       // 1010
        Console.WriteLine(true.ToString());
        Console.WriteLine($"Order {orderId:D6}: {total:F2}");
    }
}

Вывод:

42
000042
1234.50
1,234.50
$1,234.50
FF
1010
True
Order 000042: 1234.50

Коды форматирования (D, F, N, C, X, P, E) и пользовательские шаблоны вроде "0.00" описаны в разделе интерполяция строк.

Символы и логические значения

using System;

class Program
{
    static void Main()
    {
        char digit = '7';
        Console.WriteLine(digit);            // the character
        Console.WriteLine((int)digit);       // its code: 55
        Console.WriteLine(digit - '0');      // its value: 7
        Console.WriteLine(char.GetNumericValue(digit));
        Console.WriteLine((char)65);         // A

        Console.WriteLine(bool.Parse("True"));
        Console.WriteLine(bool.Parse("false"));
        Console.WriteLine(Convert.ToInt32(true));
        Console.WriteLine(Convert.ToBoolean(0));
    }
}

Вывод:

7
55
7
7
A
True
False
1
False

(int)'7' равно 55, коду символа, а не 7. На этом спотыкаются все, кто суммирует цифры числа; вычтите '0' или используйте char.GetNumericValue. bool.Parse принимает «true» и «false» в любом регистре и больше ничего («yes» и «1» вызывают исключение).

Ссылочные преобразования: приведение, as и is

Для классов приведение проверяет фактический тип объекта во время выполнения. Восходящее приведение к базовому классу неявное. Нисходящее приведение к производному классу требует явного приведения, которое выбрасывает InvalidCastException, если объект другого типа:

using System;

class Payment { public decimal Amount = 50m; }
class CardPayment : Payment { public string Last4 = "4242"; }
class CashPayment : Payment { }

class Program
{
    static void Main()
    {
        Payment p = new CardPayment();       // upcast: implicit

        CardPayment card = (CardPayment)p;   // downcast: works, it is a card
        Console.WriteLine(card.Last4);

        Payment cash = new CashPayment();
        CardPayment maybe = cash as CardPayment;  // as: null instead of an exception
        Console.WriteLine(maybe == null);

        if (p is CardPayment c)              // is pattern (C# 7): test and convert
        {
            Console.WriteLine($"Card ending {c.Last4}, {c.Amount:F2}");
        }

        try
        {
            var wrong = (CardPayment)cash;
        }
        catch (InvalidCastException)
        {
            Console.WriteLine("InvalidCastException");
        }

        object boxed = 5;                    // an int boxed as object
        int unboxed = (int)boxed;            // fine
        Console.WriteLine(unboxed);
        try
        {
            long wrongUnbox = (long)boxed;   // must unbox to the exact type
        }
        catch (InvalidCastException)
        {
            Console.WriteLine("cannot unbox int as long");
        }
    }
}

Вывод:

4242
True
Card ending 4242, 50.00
InvalidCastException
5
cannot unbox int as long

Предпочитайте is с переменной, когда нужно ветвиться по типу: это одна проверка, она не может выбросить исключение, а новая переменная видна только там, где проверка прошла. Используйте обычное приведение, когда другой тип был бы ошибкой, которая должна громко проявиться. Случай с упакованным int ловит тех, кто читает числа из коллекций object или ячеек DataRow: сначала распакуйте в точный тип ((long)(int)boxed) или используйте Convert.ToInt64(boxed), который справляется с любым числовым типом.