Type Conversion

Values keep arriving in the wrong type. A web form hands you text, a database hands you a long, an average comes back as a double when the report needs a decimal.

C# will not convert for you when something could be lost. Beyond that you have four tools, and they differ in exactly one important way: what happens when the conversion cannot work.

int unitsShipped = 1450;

long totalUnits = unitsShipped;       // implicit — a long holds every int
decimal asDecimal = unitsShipped;     // implicit
double asDouble = unitsShipped;       // implicit

double measured = 12.87;
int truncated = (int)measured;        // 12 — the fraction is cut off
int negative = (int)-12.87;           // -12 — cut off towards zero, not down

long fromDatabase = 3_000_000_000;
int wrapped = (int)fromDatabase;      // -1294967296, with no warning

Console.WriteLine($"{truncated} {negative} {wrapped}");

• Widening conversions are implicit because the target type can hold every possible source value, so there is nothing to decide.
• A cast to int truncates towards zero. It does not round: 12.87 becomes 12, and -12.87 becomes -12 rather than -13.
• A cast between whole-number types that does not fit wraps, exactly like overflow. Wrap checked(...) around it if you would rather be told.
• The underscores in 3_000_000_000 are digit separators. They are ignored by the compiler and exist only so a person can read the number.

Console.WriteLine((int)2.5);               // 2  — truncated
Console.WriteLine((int)3.9);               // 3  — truncated
Console.WriteLine(Convert.ToInt32(2.5));   // 2  — rounded to the nearest even
Console.WriteLine(Convert.ToInt32(3.5));   // 4  — rounded to the nearest even

Console.WriteLine(Math.Round(2.5, MidpointRounding.AwayFromZero));   // 3

• A cast discards the fraction. Convert rounds to the nearest whole number, which is a different answer for anything above .5.
• On an exact half, Convert rounds to the nearest even number, so 2.5 gives 2 and 3.5 gives 4. That is deliberate: always rounding halves upwards biases a long column of figures upwards.
• It is also not what most people expect. When the business rule is "a half rounds up", write it out with Math.Round and MidpointRounding.AwayFromZero so the intent is on the page.

Console.Write("Quantity ordered: ");
string? entered = Console.ReadLine();

if (int.TryParse(entered, out int quantity) && quantity > 0)
{
    Console.WriteLine($"Ordering {quantity} units.");
}
else
{
    Console.WriteLine("Enter a whole number greater than zero.");
}

• TryParse returns true or false instead of throwing, and fills in the out variable when it succeeds.
• out int quantity declares the variable inside the same statement, so there is no line above it holding a placeholder value.
• When parsing fails, quantity is 0. Do not read it in the failure branch — a zero there means "no answer", not "zero units".
• && stops at the first false, so quantity > 0 is only reached when parsing worked.

using System.Globalization;

string fromApi = "1240.50";

// Explicit about the format the sender used.
bool parsed = decimal.TryParse(
    fromApi,
    NumberStyles.Number,
    CultureInfo.InvariantCulture,
    out decimal amount);

Console.WriteLine($"{parsed}: {amount}");   // True: 1240.50

// Uses whatever culture the machine is configured for.
decimal.TryParse(fromApi, out decimal ambient);
Console.WriteLine(ambient);

• The second call reads the machine's regional settings. On a server configured for Germany the dot is a thousands separator, so "1240.50" parses as 124050 — a value a thousand times too large, with no exception to tell you.
• InvariantCulture pins the format so the same text gives the same number on every machine.
• The rule worth keeping: pass an explicit culture for anything machine-to-machine, and leave culture-aware parsing for text a person typed in their own locale.

object stored = new Employee("Priya Sharma");

if (stored is Employee employee)
{
    Console.WriteLine(employee.Name);
}

Employee? maybe = stored as Employee;   // null instead of throwing
if (maybe is not null)
{
    Console.WriteLine(maybe.Name);
}

// Invoice invoice = (Invoice)stored;   // InvalidCastException at run time

public class Employee
{
    public Employee(string name)
    {
        Name = name;
    }

    public string Name { get; }
}

• is with a variable name tests the type and gives you a typed variable in one step. This is the form to reach for first.
• as returns null when the conversion is not possible, which suits code that is going to check for null anyway.
• A plain cast throws InvalidCastException. Use it when the wrong type would be a bug you want reported loudly rather than handled.