Conversions, casting and parsing

(int)2.99 is 2 in C#, Convert.ToInt32(2.99) is 3, and casting an object that holds 72 to long throws InvalidCastException, although 72 fits in a long with room to spare. Each of these conversions follows its own rule for fractions, overflow and bad input, and the rule decides whether a fare, a count or an amount typed into a form comes out right.

You will see which conversions C# makes by itself, what casting a double to an int drops, how Convert rounds a half, and how parsing reads numbers from text with TryParse, NumberStyles and an explicit culture.

Widening happens by itself; narrowing needs a cast

A conversion turns a value of one type into a value of another. When every value of the source type fits in the target type, C# converts on its own: an int becomes a long or a double in an assignment. These are implicit conversionsimplicit conversion: A conversion that C# makes without being asked, because every value of the source type fits in the target type, such as int to long. A few of them, such as long to double, can still lose digits, never the size of the number.. When some values cannot fit, as with double to int, the compiler asks for a cast, (int)value, an explicit conversionexplicit conversion: A conversion written as a cast, such as (int)price, because it can lose information or fail. Unchecked, an out-of-range value is cut or clamped without an error; in a checked context it throws OverflowException. that says you accept what may be lost. This program makes both kinds:

using System.Globalization;

// Every number prints with the invariant culture, the same on every computer.
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// Widening: every int fits in a long and in a double, so no cast is needed.
int seats = 72;
long seatsAsLong = seats;
double seatsAsDouble = seats;
Console.WriteLine($"int {seats} -> long {seatsAsLong}, double {seatsAsDouble}");

// Also implicit, and still not exact: a double keeps about 15 to 17 digits.
long tickets = 9_007_199_254_740_993;
double ticketsAsDouble = tickets;
Console.WriteLine($"long {tickets} -> double {ticketsAsDouble:F0}");

// Narrowing needs a cast, and the cast decides what is lost.
double[] fares = [2.99, -2.99, 3e9, double.NaN];
foreach (double fare in fares)
{
    Console.WriteLine($"(int){fare} = {(int)fare}");
}

long total = 3_000_000_000;
Console.WriteLine($"(int){total} = {(int)total}");

try
{
    Console.WriteLine(checked((int)fares[2]));
}
catch (OverflowException)
{
    Console.WriteLine($"checked((int){fares[2]}) threw OverflowException");
}

int 72 -> long 72, double 72
long 9007199254740993 -> double 9007199254740992
(int)2.99 = 2
(int)-2.99 = -2
(int)3000000000 = 2147483647
(int)NaN = 0
(int)3000000000 = -1294967296
checked((int)3000000000) threw OverflowException

The second line is the exception to “implicit means safe”: a long converts to a double by itself, yet 9,007,199,254,740,993 came back as 9,007,199,254,740,992, because a double keeps about 15 to 17 significant digits. Microsoft’s reference lists this case, and int to float, as conversions that can lose precision but never the order of magnitude. Step through what casting each double to int did:

A cast to int drops the fraction, rounding toward zero, so 2.99 became 2 and -2.99 became -2. A double too large for an int gave its largest value, 2,147,483,647, and NaN gave 0, the rule of .NET 9 and later; a long too large kept only its low 32 bits and came out as -1,294,967,296. Inside checked(…) the out-of-range cast threw OverflowException instead.

Convert rounds to the nearest whole number; a cast cuts

Cutting 2.99 to 2 is right for “how many whole boxes fit” and wrong for “the nearest whole rupee”. Four ways to turn a double into a whole number agree on most values and differ on halves:

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// The same four doubles turned into whole numbers in four ways.
double[] values = [2.5, 3.5, -2.5, 2.99];
Console.WriteLine($"{"value",6} {"(int)",6} {"Convert",8} {"Round",6} {"AwayFromZero",13}");
foreach (double v in values)
{
    int cast = (int)v;
    int converted = Convert.ToInt32(v);
    double rounded = Math.Round(v);
    double away = Math.Round(v, MidpointRounding.AwayFromZero);
    Console.WriteLine($"{v,6} {cast,6} {converted,8} {rounded,6} {away,13}");
}

 value  (int)  Convert  Round  AwayFromZero
   2.5      2        2      2             3
   3.5      3        4      4             4
  -2.5     -2       -2     -2            -3
  2.99      2        3      3             3

The cast cut every value toward zero, 2.99 included. Convert.ToInt32 rounds to the nearest int, and a value exactly halfway goes to the even neighbour: 2.5 became 2 and 3.5 became 4, the rule that Microsoft’s reference for Convert.ToInt32(Double) states. Math.Round without a mode does the same and returns a double; with MidpointRounding.AwayFromZero halves go away from zero, 2.5 to 3 and -2.5 to -3, as in the lesson on decimal.

Parsing turns text into numbers, and the culture decides what a comma means

Most numbers arrive as text. Parsing reads them: int.Parse throws when the text is not a number, int.TryParse returns false instead, and Convert.ToInt32 parses like Parse but turns null into 0:

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// Five inputs, three ways to turn text into an int.
string?[] inputs = ["42", " 42 ", "4.5", "", null];
Console.WriteLine($"{"text",6}  {"int.Parse",-21} {"int.TryParse",-13} Convert.ToInt32");
foreach (string? text in inputs)
{
    string shown = text is null ? "null" : $"\"{text}\"";
    string parsed = Outcome(() => int.Parse(text!, CultureInfo.InvariantCulture));
    bool ok = int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out int value);
    string converted = Outcome(() => Convert.ToInt32(text, CultureInfo.InvariantCulture));
    Console.WriteLine($"{shown,6}  {parsed,-21} {$"{ok}, {value}",-13} {converted}");
}

// Amounts as text, read as decimals with the invariant culture and NumberStyles.Number.
Console.WriteLine();
string[] amounts = ["1,234.50", "1,23,456.50", "12,34", "1.234,50", "-250.00"];
foreach (string amount in amounts)
{
    bool read = decimal.TryParse(amount, NumberStyles.Number, CultureInfo.InvariantCulture, out decimal d);
    Console.WriteLine($"{amount,-12} {(read ? d.ToString() : "not a number")}");
}

static string Outcome(Func<int> parse)
{
    try
    {
        return parse().ToString();
    }
    catch (Exception e)
    {
        return e.GetType().Name;
    }
}

  text  int.Parse             int.TryParse  Convert.ToInt32
  "42"  42                    True, 42      42
" 42 "  42                    True, 42      42
 "4.5"  FormatException       False, 0      FormatException
    ""  FormatException       False, 0      FormatException
  null  ArgumentNullException False, 0      0

1,234.50     1234.50
1,23,456.50  123456.50
12,34        1234
1.234,50     not a number
-250.00      -250.00

Only TryParse never threw, and null separates the other two: int.Parse threw ArgumentNullException, while Convert.ToInt32 returned 0, a number nobody typed. The lower half reads amounts as decimal with NumberStyles.Number and the invariant cultureinvariant culture: CultureInfo.InvariantCulture: a culture tied to no country that formats and parses the same way on every computer, with a dot for decimals and a comma between thousands. Use it for text that programs exchange. More in “Console input, output, arguments and exit codes”. It accepted 1,234.50 and also 1,23,456.50, because parsing accepts a group separator anywhere between digits, and for the same reason it read 12,34, which a German writer means as twelve point three four, as 1234 without a word. Pass the culture the text was written in, and check the shape of text that matters.

Numbers stored as object, or as an interface they implement, are a fourth case. Storing them there is boxingboxing: Storing a value of a value type, such as an int, in a variable of type object or of an interface type. Getting the value back out is unboxing, and it must name exactly the type that went in., and getting them back is unboxing, which needs the exact type that went in. Answer three questions about a value you need as an int, and the table rules out the conversions that would get it wrong:

Numeric casts at the edges, and conversions of your own types Pro: opens with a Pro, Premium or Ultimate pass

Parsing real-world text: cultures, currency, dates and an import Pro: opens with a Pro, Premium or Ultimate pass

Boxing and unboxing, with the bytes counted Pro: opens with a Pro, Premium or Ultimate pass

Practise: round a reading the way you mean it

Then try the questions on casts, Convert and parsing. The idea you have answered worst comes first, and each choice explains what it gets right or wrong:

Interview questions

Fresher · What is the difference between a cast, Convert.ToInt32 and int.Parse?

A cast converts a value whose type the language already knows how to convert, such as a double to an int, and drops the fraction: (int)2.99 is 2. Convert.ToInt32 takes many types: given a double it rounds to the nearest whole number with halves to the even neighbour, so 2.99 gives 3 and 2.5 gives 2; given a string it parses, and it turns null into 0. int.Parse takes only text and throws FormatException on text that is not a whole number, and ArgumentNullException on null. For text from users or files, use int.TryParse with an explicit culture, which returns false instead of throwing.

Key takeaways

• Widening conversions such as int to long happen by themselves, while narrowing ones such as double to int need a cast, which says that something may be lost.
• Casting a double to an int drops the fraction toward zero, while Convert.ToInt32 rounds to the nearest whole number with halves going to the even neighbour.
• int.Parse throws on bad text, int.TryParse returns false, and Convert.ToInt32 turns null into 0.
• Parsing accepts a group separator anywhere between digits, so pass the culture the text was written in and check the shape of text that matters.