Type Conversion

Implicit Conversion

C# automatically converts between compatible types when no data would be lost — for example, converting an `int` to a `double`, since every whole number is also perfectly representable as a floating-point number. This is called a "widening" conversion, because you're moving to a type that can hold everything the original could, and more.

int wholeNumber = 42;
double decimalNumber = wholeNumber; // implicit, safe — no data can be lost
Console.WriteLine(decimalNumber);

long bigNumber = wholeNumber; // int → long is also implicit
float f = wholeNumber;        // int → float is also implicit

Explicit Conversion (Casting)

Converting from a larger/more-precise type to a smaller/less-precise one risks losing data, so C# requires an explicit cast — parentheses around the target type — to make that risk visible directly in your code, rather than letting it happen silently.

double price = 19.99;
int roundedDown = (int)price; // explicit cast — truncates, doesn't round!
Console.WriteLine(roundedDown);

long bigNumber = 5_000_000_000;
int truncated = (int)bigNumber; // may lose data if it doesn't fit in an int

What Happens When Data Is Lost

When a value genuinely doesn't fit in the smaller target type, the result is not an error by default — it silently wraps around to an unexpected value, which can be a genuinely dangerous source of subtle bugs in production code.

long tooLarge = 5_000_000_000; // larger than int can hold
int result = (int)tooLarge;
Console.WriteLine(result); // 705032704 — NOT 5 billion, and NOT an error!

The Convert Class

The `Convert` class handles conversions between otherwise unrelated types that a simple cast can't bridge, like turning a string into a number — casting only works between numerically related types, not between a string and an int.

string input = "25";
int age = Convert.ToInt32(input);
Console.WriteLine(age + 5);

// Convert also handles bool, DateTime, and more
bool flag = Convert.ToBoolean("true");
string backToString = Convert.ToString(42);

Parse & TryParse

`Parse` (called on the target type itself, like int.Parse) throws an exception if the string isn't a validly formatted value of that type. `TryParse` is the safer alternative — it returns `true`/`false` to indicate success instead of throwing, storing the actual result in an `out` parameter. This distinction matters enormously when handling real, untrustworthy user input.

string userInput = "abc";

if (int.TryParse(userInput, out int result))
{
    Console.WriteLine($"Parsed: {result}");
}
else
{
    Console.WriteLine("Invalid number.");
}

A full comparison of when to reach for each conversion mechanism:

Boxing and Unboxing

Boxing is the process of wrapping a value type (like an int) inside an object reference, so it can be treated as a reference type — necessary when passing a value type somewhere that expects the general-purpose object type. Unboxing reverses this, extracting the original value type back out. Both involve real, measurable performance overhead compared to working with the value type directly, since boxing allocates new memory on the heap.

int number = 42;
object boxed = number;       // boxing — number is wrapped in an object on the heap
int unboxed = (int)boxed;    // unboxing — explicit cast required
Console.WriteLine(unboxed);  // 42

Checked and Unchecked Contexts

By default, C# arithmetic overflow (like adding 1 to int.MaxValue) wraps around silently rather than throwing — an "unchecked" context, which is the implicit default for performance reasons. Wrapping code in an explicit checked block makes C# throw an OverflowException instead, trading a small amount of performance for safety.

int max = int.MaxValue;

int wrapped = max + 1; // unchecked (default) — silently wraps to a very negative number
Console.WriteLine(wrapped); // -2147483648

checked
{
    int willThrow = max + 1; // throws System.OverflowException
}

Common Beginner Mistakes

FAQs

Key Takeaways

Summary

Type conversion in C# ranges from fully automatic and safe (implicit) to explicit and risky (casting) to defensively safe (TryParse) — choosing the right mechanism for the right situation is a hallmark of careful, production-quality code. Next, you'll learn the operators C# uses to actually compute and compare these values.