Konwersja string na int w C#, rzutowanie i konwersja typów: Parse, TryParse, Convert

C# nigdy sam nie konwertuje między niezwiązanymi typami. String zawierający cyfry to nadal string, a double nie staje się po cichu int. Konwertujesz jawnie, a narzędzie zależy od tego, co konwertujesz: tekst na liczbę (parsowanie), jeden typ liczbowy na inny (rzutowanie) albo obiekt na bardziej szczegółowy typ (as, is).

String na int: Parse, TryParse i Convert

Są trzy standardowe sposoby zamiany tekstu na 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"));
    }
}

Wynik:

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

int.TryParse zwraca bool i zapisuje wynik w zmiennej out, która przy niepowodzeniu dostaje 0. Ponieważ złe dane są normalne we wszystkim, co wpisuje użytkownik, TryParse to domyślny wybór dla danych wejściowych, plików i parametrów zapytań. Te same metody istnieją w każdym typie liczbowym: long.TryParse, double.TryParse, decimal.Parse i tak dalej.

Co każda z nich robi ze złymi danymi

Trzy metody różnią się tylko sposobem, w jaki zawodzą:

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

Wynik:

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 niesie dobrze znany komunikat "Input string was not in a correct format" (w .NET 8 i nowszych "The input string '12.5' was not in a correct format", z tekstem w cudzysłowie) i to jeden z najczęstszych błędów czasu działania w C#: "12.5" nie jest int, tak samo jak "1,000". Żeby je akceptować, parsuj jako decimal albo powiedz parserowi, które style są dozwolone:

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

Wynik:

1000
255
13
10

Kultura: dlaczego "1.5" może stać się 15

Parsowanie domyślnie używa bieżącej kultury, a kultury różnią się separatorami. W niemieckiej i kilku innych europejskich kulturach (także w polskiej) separatorem dziesiętnym jest przecinek, a w niemieckiej kropka grupuje tysiące. Ten sam string daje różne liczby:

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

Wynik:

1.5
15
1.5

Kod, który czyta pliki z danymi, JSON, konfigurację albo cokolwiek generowanego maszynowo, powinien zawsze przekazywać CultureInfo.InvariantCulture, zarówno przy parsowaniu, jak i przy formatowaniu. Inaczej ten sam program działa na komputerze programisty, a na serwerze ustawionym na inny język źle odczytuje każdą liczbę. Bieżącej kultury używaj tylko dla tekstu, który człowiek wpisał albo przeczyta.

Niejawne i jawne konwersje liczbowe

Konwersje rozszerzające zachodzą niejawnie: int na long, int na double, float na double, int na decimal. Konwersja, która może stracić wielkość wartości albo jej część ułamkową, wymaga jawnego rzutowania (type)value. Jeden wyjątek, o którym warto pamiętać: int lub long na float oraz long na double są niejawne, choć mogą tracić precyzję: float f = 16_777_217; się kompiluje i zapisuje 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}");
    }
}

Wynik:

9 -9
10
2
4
705032704
9.99
7 7.0 7

Trzy rzeczy do zapamiętania. Rzutowanie z liczby zmiennoprzecinkowej na całkowitą obcina; nie zaokrągla. Convert.ToInt32(double) zaokrągla, stosując zaokrąglanie bankierskie (połówki idą do parzystego sąsiada). A rzutowanie całkowite, które się nie mieści, zawija się po cichu, chyba że działa w kontekście checked, gdzie rzuca OverflowException (zobacz typy danych).

int x = 3.7; to błąd kompilacji (CS0266: cannot implicitly convert type 'double' to 'int', an explicit conversion exists), czyli kompilator prosi cię o wybór między rzutowaniem a metodą zaokrąglania.

Liczby i inne typy na string

Każdy typ ma ToString(), a typy liczbowe przyjmują string formatu. Interpolacja stringów wywołuje to samo formatowanie:

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

Wynik:

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

Kody formatu (D, F, N, C, X, P, E) i własne wzorce, takie jak "0.00", omawia strona interpolacja stringów.

Znaki i wartości logiczne

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

Wynik:

7
55
7
7
A
True
False
1
False

(int)'7' to 55, kod znaku, a nie 7. Potyka się o to każdy, kto sumuje cyfry liczby; odejmij '0' albo użyj char.GetNumericValue. bool.Parse przyjmuje "true" i "false" w dowolnej wielkości liter i nic poza tym ("yes" i "1" rzucają wyjątek).

Konwersje referencyjne: rzutowania, as i is

Dla typów klas rzutowanie sprawdza w czasie działania rzeczywisty typ obiektu. Rzutowanie w górę na klasę bazową jest niejawne. Rzutowanie w dół na klasę pochodną wymaga jawnego rzutowania, które rzuca InvalidCastException, gdy obiekt jest czymś innym:

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

Wynik:

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

Wybieraj is ze zmienną, gdy musisz rozgałęzić kod według typu; to jedno sprawdzenie, nie może rzucić wyjątku, a nowa zmienna jest w zakresie tylko tam, gdzie test się powiódł. Używaj zwykłego rzutowania, gdy inny typ byłby błędem, który powinien głośno się ujawnić. Przypadek opakowanego int zaskakuje osoby czytające liczby z kolekcji object albo komórek DataRow: najpierw rozpakuj do dokładnego typu ((long)(int)boxed) albo użyj Convert.ToInt64(boxed), który obsługuje każdy typ liczbowy.