C# Type Conversion: Casting, Parse, TryParse and Convert

Changing data from one type to another — safely, explicitly, and efficiently.

Imagine a user enters their age into a text box on a registration form.

Your application receives "29" — but that's a string, not a number. To calculate their birth year, you need to treat it as an integer. You need a way to convert "29" into 29.

This is the essence of type conversion: changing a value from one data type to another so you can work with it in a different way. It happens everywhere — reading user input, parsing JSON, calculating totals, formatting output, and storing data.

Understanding type conversion deeply helps you avoid runtime crashes, data corruption, and subtle bugs.

What Is It?

The Simple Explanation

Type conversion means taking a value of one type and producing a corresponding value of another type.

The Technical Definition

In C#, type conversion is the process of converting a value from one data type (source type) to another data type (target type). C# is a statically typed language, so the compiler enforces type compatibility at compile time. Conversions can be:

• Implicit — done automatically by the compiler when no data loss is possible.
• Explicit (casting) — done by the developer using (targetType) or operators; may lose data or throw exceptions.
• Parsing — converting a string representation into another type (e.g., int.Parse("29")).
• User-defined — you can define your own conversion operators for custom types.

Why Does It Exist?

The Problem

C# is statically typed, meaning every variable has a fixed type at compile time. But real-world data comes in different shapes:

• User input is always a string.
• Files and network streams give bytes.
• Calculations may require decimal for money, double for scientific values.
• APIs return JSON with mixed types.

If types never changed, you couldn't read a number from a text box and add it to another number. You'd be stuck.

The Solution

Type conversion provides the bridge between different type systems. It allows you to:

• Move data from one representation to another.
• Control whether a conversion is safe (implicit) or risky (explicit).
• Handle invalid input gracefully with TryParse.
• Define custom conversions for your own domain types (e.g., Money, Temperature).

Big Picture

Here's a visual mental model of how conversions flow in C#:

How It Works

Let's trace what happens when you perform different kinds of conversions.

Step 1 — Implicit conversion (safe widening)

int count = 10;
long bigCount = count;   // implicit: int → long
double precise = count;  // implicit: int → double

The compiler sees that long and double can represent all possible int values exactly (or with acceptable precision for double). It automatically inserts the conversion without requiring a cast.

Step 2 — Explicit conversion (potential data loss)

double price = 19.99;
int wholePrice = (int)price;   // explicit: 19, fractional part lost

This is a narrowing conversion. The compiler cannot guarantee safety, so it requires you to write the cast (int). You accept the risk that data will be lost.

Step 3 — Parsing string to number

string input = "42";
int age = int.Parse(input);      // throws FormatException if input is not numeric

Parse reads the string and attempts to produce a number. If the string is not a valid number, it throws an exception. A safer alternative is TryParse:

if (int.TryParse(input, out int age2))
{
    Console.WriteLine($"Age is {age2}");
}
else
{
    Console.WriteLine("Invalid age");
}

TryParse returns bool and never throws. It's the preferred method for user input.

Step 4 — Using Convert class

object obj = 123;
int number = Convert.ToInt32(obj);   // handles null and IConvertible

Convert is a static helper class that provides conversions between many types. It can handle null by returning default values for value types (e.g., 0 for int). It's useful when the source type is object or string.

Step 5 — User-defined conversion

public readonly struct Temperature
{
    public double Celsius { get; }
    public Temperature(double celsius) => Celsius = celsius;
    public static implicit operator Temperature(double c) => new(c);
    public static explicit operator double(Temperature t) => t.Celsius;
}

Temperature temp = 36.6;       // implicit
double c = (double)temp;       // explicit

This is advanced but powerful. It lets you define how your own types convert to and from others.

Simple Example

using System;

string input = "15";

// Convert string to int using TryParse (safe)
if (int.TryParse(input, out int quantity))
{
    double unitPrice = 2.50;
    double total = quantity * unitPrice;   // int implicitly converts to double
    Console.WriteLine($"Total: {total:C}");  // $37.50
}
else
{
    Console.WriteLine("Invalid quantity");
}

// Explicit narrowing example
double average = 7.9;
int floor = (int)average;      // 7
Console.WriteLine(floor);

Code → Meaning → Result

• int.TryParse — safely converts string to int without exceptions.
• quantity * unitPrice — int is implicitly converted to double so the multiplication works.
• (int)average — explicit cast truncates the decimal part.
• total:C — formats the double as currency using current culture.

Real-World Example

Consider an e-commerce API that receives an order as JSON. The JSON string contains numbers as text:

{
  "orderId": "1024",
  "total": "249.99"
}

Your C# code must convert these strings into appropriate types for processing:

string orderIdJson = "1024";
string totalJson = "249.99";

if (int.TryParse(orderIdJson, out int orderId)
    && decimal.TryParse(totalJson, System.Globalization.NumberStyles.Currency,
                        System.Globalization.CultureInfo.InvariantCulture,
                        out decimal total))
{
    // Now we can do arithmetic safely
    decimal tax = total * 0.08m;
    decimal grandTotal = total + tax;
    Console.WriteLine($"Order {orderId}: {grandTotal:C}");  // Order 1024: $269.99
}

Why TryParse here? Because JSON data is untrusted and may be malformed. TryParse lets us handle errors without throwing exceptions. We also specify InvariantCulture to ensure the decimal point is interpreted correctly regardless of server locale.

Analogy

Under the Hood

What happens inside the CLR and compiler when you convert types?

Common Confusion

1. Implicit vs Explicit

Many beginners think all conversions are the same. The difference is:

• Implicit: compiler does it automatically; no syntax required; safe (widening).
• Explicit: developer must write a cast; may lose data; risky (narrowing).

2. Convert vs Parse vs TryParse

3. Casting vs as

For reference types, as operator attempts a conversion and returns null if it fails, whereas a cast throws InvalidCastException.

object obj = "hello";
string? s = obj as string;     // safe, returns string or null
if (s is not null) { ... }

string s2 = (string)obj;       // throws if obj is not string

4. Boxing vs Unboxing

Boxing is implicit when a value type is assigned to object. Unboxing is explicit and must match the exact original type.

int x = 42;
object boxed = x;          // boxing
int y = (int)boxed;        // unboxing to exact type

5. Culture and Parsing

Parsing numbers and dates depends on culture. In some cultures, "1,234.56" uses comma as thousands separator; in others, comma is decimal separator. Always specify culture or use InvariantCulture for data from external systems.

Common Mistakes

Mistake 1 — Using Parse on untrusted input

Wrong: int age = int.Parse(userInput); — if user enters "abc", the app crashes.

Correct: Use int.TryParse(userInput, out int age) and handle failure.

Mistake 2 — Relying on default culture for data parsing/formatting

decimal.Parse("1.99") may fail on a German system because dot is not the decimal separator.

Use CultureInfo.InvariantCulture for data interchange: decimal.Parse("1.99", CultureInfo.InvariantCulture).

Mistake 3 — Ignoring overflow and precision loss

long big = long.MaxValue; int small = (int)big; — overflows silently, produces -1.

Use checked context to detect overflow: int small = checked((int)big); or checked { int small = (int)big; }.

Mistake 4 — Unboxing to the wrong type

object obj = 123.45; int x = (int)obj; — throws InvalidCastException because the original was double.

Unbox to the exact original type first, then convert: int x = (int)(double)obj;.

Mistake 5 — Using Convert where TryParse is better

Convert.ToInt32 throws if the string is invalid or if the value is too large. For user input, TryParse is safer and faster (no exception throwing).

When Should I Use It?

Use implicit conversion when:

• You are assigning a smaller integer type to a larger one (int → long).
• You are mixing numeric types in arithmetic and no data loss is expected (int → double).
• You have defined a custom implicit operator for a type that is a safe superset.

Use explicit cast when:

• You are converting from a larger numeric type to a smaller one (double → int).
• You are converting between reference types in an inheritance hierarchy (downcasting).
• You accept the risk of data loss or overflow.

Use Parse / TryParse when:

• Converting strings to numbers, dates, enums, etc.
• Parsing JSON, CSV, or user input.
• Always prefer TryParse for external input to avoid exceptions.

Use Convert class when:

• The source type is object or may be null.
• You need a quick conversion between primitive types with built-in null handling.
• You are working with database values (DBNull).

When conversion might be unnecessary:

• If you can keep the same type throughout, you avoid unnecessary allocations and potential errors.
• For high-performance loops, avoid boxing/unboxing by using generic types or spans.

Mental Model

Key Takeaway

Check Your Understanding

You've seen how type conversion works, why explicit and implicit matter, and how to parse safely. Let's see if you can apply this knowledge.

double d = 9.99;
int x = (int)d;
Console.WriteLine(x);

You now understand type conversion — the bridge between data types that keeps your applications flexible and safe.