C# String to Int, Casting and Type Conversion: Parse, TryParse, Convert

C# never converts between unrelated types on its own. A string that contains digits is still a string, and a double does not quietly become an int. You convert explicitly, and which tool you use depends on what you are converting: text to a number (parsing), one numeric type to another (casting), or an object to a more specific type (as, is).

String to int: Parse, TryParse and Convert

There are three standard ways to turn text into an 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"));
    }
}

Output:

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

int.TryParse returns a bool and writes the result into an out variable, which is set to 0 on failure. Because bad input is normal for anything a user types, TryParse is the default choice for input, files and query strings. The same methods exist on every numeric type: long.TryParse, double.TryParse, decimal.Parse, and so on.

What each one does with bad input

The three methods differ only in how they fail:

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

Output:

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

A FormatException carries the familiar message "Input string was not in a correct format" (on .NET 8 and later, "The input string '12.5' was not in a correct format", with the text quoted), and it is one of the most common C# runtime errors: "12.5" is not an int, and neither is "1,000". To accept those, parse as decimal, or tell the parser which styles are allowed:

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

Output:

1000
255
13
10

Culture: why "1.5" can become 15

Parsing uses the current culture by default, and cultures disagree about separators. In German and several other European cultures the decimal separator is a comma and the period groups thousands. The same string gives different numbers:

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

Output:

1.5
15
1.5

Code that reads data files, JSON, configuration or anything machine-generated should always pass CultureInfo.InvariantCulture, both when parsing and when formatting. Otherwise the same program works on a developer's machine and misreads every number on a server set to another language. Use the current culture only for text a person typed or will read.

Implicit and explicit numeric conversions

Widening conversions happen implicitly: int to long, int to double, float to double, int to decimal. A conversion that can lose the value's magnitude or its fractional part requires an explicit cast (type)value. One exception to keep in mind: int or long to float, and long to double, are implicit even though they can lose precision: float f = 16_777_217; compiles and stores 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}");
    }
}

Output:

9 -9
10
2
4
705032704
9.99
7 7.0 7

Three things to remember. A cast from floating point to integer truncates; it does not round. Convert.ToInt32(double) rounds, using banker's rounding (halves go to the even neighbor). And an integer cast that does not fit wraps silently unless it runs in a checked context, where it throws OverflowException (see data types).

int x = 3.7; is a compile error (CS0266: cannot implicitly convert type 'double' to 'int', an explicit conversion exists), which is the compiler asking you to choose between a cast and a rounding method.

Numbers and other types to string

Every type has ToString(), and numeric types accept a format string. String interpolation calls the same formatting:

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

Output:

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

The format codes (D, F, N, C, X, P, E) and custom patterns like "0.00" are covered in string interpolation.

Characters and booleans

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

Output:

7
55
7
7
A
True
False
1
False

(int)'7' is 55, the character's code, not 7. That trips up anyone summing digits of a number; subtract '0' or use char.GetNumericValue. bool.Parse accepts "true" and "false" in any case, and nothing else ("yes" and "1" throw).

Reference conversions: casts, as and is

For class types, a cast checks the object's actual type at run time. Upcasting to a base class is implicit. Downcasting to a derived class needs an explicit cast, which throws InvalidCastException when the object is something else:

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

Output:

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

Prefer is with a variable when you need to branch on the type; it is one check, it cannot throw, and the new variable is only in scope where the test succeeded. Use a plain cast when a different type would be a bug that should fail loudly. The boxed int case catches people reading numbers from object collections or DataRow cells: unbox to the exact type first ((long)(int)boxed), or use Convert.ToInt64(boxed), which handles any numeric type.