Type conversion and casting in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Type conversion and casting

Start with variable

↓

Check if implicit conversion possible?

No→Explicit cast needed

↓

Apply explicit cast

↓

Convert value

↓

Check cast success

↓

Use converted value

↓

End

Start with a variable, check if automatic conversion works; if not, use explicit cast, then use the converted value.

Execution Sample

C Sharp (C#)

int i = 100;
long l = i; // implicit conversion
int j = (int)l; // explicit cast
Console.WriteLine(j);

Converts int to long implicitly, then casts long to int explicitly, and prints the int value.

Execution Table

Step	Action	Variable	Value Before	Value After	Notes
1	Declare int i	i	undefined	100	Initialize i with 100
2	Implicit conversion int to long	l	undefined	100	No cast needed, long can hold int
3	Explicit cast long to int	j	undefined	100	Cast long to int explicitly
4	Print j	j	100	100	Output is 100
5	End	-	-	-	Program ends

💡 All conversions done, program ends after printing int value.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
i	undefined	100	100	100	100
l	undefined	undefined	100	100	100
j	undefined	undefined	undefined	100	100

Key Moments - 2 Insights

Why can int convert to long without a cast but long to int needs a cast?

Because long can hold all int values safely (implicit conversion), but converting long to int might overflow or lose data (narrowing), so C# requires an explicit cast (see steps 2 and 3 in execution_table).

What happens if you try to assign a long to an int without casting?

It causes a compile-time error because int might not hold the larger long value safely, so explicit cast is required to tell the compiler you accept possible data loss.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the value of variable 'l' after implicit conversion?

A undefined

B 0

C 100

D 100.0

💡 Hint

Check the 'Value After' column for variable 'l' at step 2 in execution_table.

At which step does the explicit cast happen?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look for the action mentioning 'Explicit cast' in execution_table.

If we remove the explicit cast from long to int, what will happen?

A Compile-time error due to missing cast

B Code compiles and runs fine

C Runtime error occurs

D Value of j becomes zero

💡 Hint

Recall C# rules for implicit vs explicit conversion shown in concept_flow and key_moments.

Concept Snapshot

Type conversion in C# can be implicit or explicit.
Implicit conversion happens when no data loss is possible.
Explicit casting is needed when data loss or narrowing may occur.
Syntax for explicit cast: (TargetType)variable.
Always ensure safe conversions to avoid errors.

Full Transcript

This lesson shows how C# converts types. First, an int variable 'i' is set to 100. Then it converts implicitly to a long variable 'l' because long can hold all int values safely. Next, 'l' is explicitly cast to an int 'j' because converting from long to int is narrowing and might cause overflow or data loss, so C# requires a cast. Finally, the int value is printed. The execution table tracks each step and variable value. Key points include when implicit conversion is allowed and when explicit casting is needed to avoid errors. The quiz tests understanding of these steps and rules.

Practice

1. What is the main difference between type conversion and casting in C#?

easy

A. Casting changes data to string only, conversion changes data to numbers only.

B. Casting is automatic, conversion always requires manual code.

C. Casting requires compatible types and uses parentheses, conversion can be safer and more flexible.

D. Casting works only with classes, conversion works only with structs.

Solution

1. Step 1: Understand casting in C#

   Casting uses parentheses and works only when types are compatible, like int to double or object to string.

2. Step 2: Understand conversion methods

   Conversion methods like Convert.ToInt32 or int.Parse are safer and can handle strings and other types more flexibly.

3. Final Answer:

   Casting requires compatible types and uses parentheses, conversion can be safer and more flexible. -> Option C

4. Quick Check:

   Casting vs Conversion = Casting requires compatible types and uses parentheses, conversion can be safer and more flexible. [OK]

Hint: Casting uses parentheses; conversion uses methods like Convert.ToInt32 [OK]

Common Mistakes:

• Thinking casting works with all types automatically
• Confusing conversion methods with casting syntax
• Assuming casting changes data format like conversion

2. Which of the following is the correct syntax to cast a double variable d to an int in C#?

easy

A. int i = (int)d;

B. int i = int(d);

C. int i = Convert.ToInt(d);

D. int i = d as int;

Solution

1. Step 1: Recall casting syntax in C#

   Casting uses parentheses with the target type before the variable, like (int)d.

2. Step 2: Check each option

   int i = (int)d; uses correct casting syntax. int i = int(d); is invalid syntax. int i = Convert.ToInt(d); uses wrong method name (should be Convert.ToInt32). int i = d as int; uses 'as' which works only with reference types.

3. Final Answer:

   int i = (int)d; -> Option A

4. Quick Check:

   Correct cast syntax = int i = (int)d; [OK]

Hint: Casting uses (type)variable syntax, not functions or 'as' keyword [OK]

Common Mistakes:

• Using 'as' keyword for value types
• Calling non-existent Convert.ToInt method
• Using function-like syntax for casting

3. What will be the output of the following C# code?

double d = 9.7;
int i = (int)d;
Console.WriteLine(i);

medium

A. Compilation error

B. 10

C. 9.7

D. 9

Solution

1. Step 1: Understand casting from double to int

   Casting double to int truncates the decimal part, it does not round.

2. Step 2: Apply casting to value 9.7

   Truncating 9.7 results in 9, so i = 9.

3. Final Answer:

   9 -> Option D

4. Quick Check:

   Double to int cast truncates decimals = 9 [OK]

Hint: Casting double to int drops decimals, no rounding [OK]

Common Mistakes:

• Assuming casting rounds the number
• Expecting a compilation error
• Confusing output with original double value

4. Identify the error in this C# code snippet:

string s = "123abc";
int num = Convert.ToInt32(s);
Console.WriteLine(num);

medium

A. FormatException at runtime due to invalid string format

B. num will be 0 because of invalid characters

C. Compilation error because Convert.ToInt32 does not exist

D. No error, code runs and prints 123

Solution

1. Step 1: Understand Convert.ToInt32 behavior

   Convert.ToInt32 tries to convert the whole string to an integer and throws an exception if format is invalid.

2. Step 2: Analyze string "123abc"

   String contains non-digit characters, so conversion fails and throws FormatException at runtime.

3. Final Answer:

   FormatException at runtime due to invalid string format -> Option A

4. Quick Check:

   Invalid string format causes FormatException [OK]

Hint: Convert.ToInt32 throws error if string has non-digit chars [OK]

Common Mistakes:

• Assuming partial conversion succeeds
• Expecting zero instead of exception
• Thinking Convert.ToInt32 is compile-time error

5. You have an object obj that holds an integer value. Which code safely converts obj to an int without risking an exception if obj is not an int?

hard

A. int i = Convert.ToInt32(obj);

B. int i = obj is int val ? val : 0;

C. int i = obj as int;

D. int i = (int)obj;

Solution

1. Step 1: Understand casting and conversion risks

   Direct cast (int)obj throws exception if obj is not int. Convert.ToInt32 may throw exceptions too. 'as' cannot be used with value types like int.

2. Step 2: Analyze safe pattern

   Using pattern matching with 'is' checks type safely and assigns value or default 0 if not int, avoiding exceptions.

3. Final Answer:

   int i = obj is int val ? val : 0; -> Option B

4. Quick Check:

   Pattern matching safely converts or defaults = int i = obj is int val ? val : 0; [OK]

Hint: Use 'is' pattern matching to safely cast without exceptions [OK]

Common Mistakes:

• Using 'as' with value types causing compile errors
• Casting without checking type causing exceptions
• Assuming Convert.ToInt32 always safe