Type casting in C# refers to converting a variable from one data type to another. It is a powerful concept that allows you to work with different types of data in a flexible manner. There are two main types of type casting in C#: implicit casting and explicit casting.

1. Implicit Casting (Widening Conversion)

Implicit casting occurs automatically when you assign a value of a smaller data type to a larger data type. This is called a widening conversion, as the smaller type can be safely converted to the larger type without losing any data.

Example:

int age = 25;
double ageInDouble = age;  // Implicit cast from int to double
Console.WriteLine(ageInDouble); // Output: 25.0

In this example, the int is automatically converted to a double because double can store larger values and decimal points without data loss.

Implicit Casting Rules:

• Smaller numeric types (e.g., byte, short, int) can be automatically converted to larger numeric types (e.g., long, float, double).
• char can be implicitly converted to numeric types (int, long, etc.).
• No data loss occurs in implicit casting.

2. Explicit Casting (Narrowing Conversion)

Explicit casting, or narrowing conversion, is the process of converting a value from a larger data type to a smaller data type. This requires an explicit cast, and there might be data loss or overflow if the conversion is not handled carefully.

Syntax:

targetType variableName = (targetType)sourceVariable;

Example:

double pi = 3.14159;
int piAsInt = (int)pi;  // Explicit cast from double to int
Console.WriteLine(piAsInt); // Output: 3 (data loss: decimals are truncated)

In this case, the double value is explicitly cast to an int. The decimal part of pi is truncated because int cannot hold decimal values.

Explicit Casting Rules:

• Larger numeric types (e.g., double, long) must be explicitly cast to smaller numeric types (e.g., int, short).
• Data loss may occur if the target type cannot represent the value.
• Overflow can happen if the source value is too large or too small for the target type.

3. Using Convert Class for Safe Casting

The Convert class provides methods to safely convert between different types. This approach is safer than explicit casting and can handle more complex conversions.

Example:

double temperature = 98.6;
int tempAsInt = Convert.ToInt32(temperature);  // Safe conversion from double to int
Console.WriteLine(tempAsInt); // Output: 99 (rounding occurs)

The Convert.ToInt32() method rounds the decimal number to the nearest integer, ensuring that you don’t lose data unexpectedly.

Example: Converting a String to a Numeric Type

string str = "123";
int num = Convert.ToInt32(str);  // Converts string to integer
Console.WriteLine(num); // Output: 123

If the string can’t be converted, Convert will throw an exception.

4. Handling Invalid Casts with Try-Catch

When performing explicit casting or using the Convert class, there may be times when the conversion fails (for example, trying to cast a non-numeric string to an integer). To handle such scenarios, C# provides error handling with try-catch blocks.

Example:

try
{
    string str = "ABC";
    int result = Convert.ToInt32(str);  // This will throw an exception
}
catch (FormatException e)
{
    Console.WriteLine("Conversion failed: " + e.Message);
}

This ensures that your program doesn’t crash if a cast fails, and you can provide a user-friendly message.

5. Casting Between Object and Specific Types

In C#, objects can be cast to specific types using either explicit casting or the as keyword. The as keyword is used for reference types and returns null if the cast is not possible, while explicit casting throws an exception.

Using as keyword:

object obj = "Hello, world!";
string str = obj as string;  // Safe cast to string
if (str != null)
{
    Console.WriteLine(str);  // Output: Hello, world!
}

Example of invalid cast using as:

object obj = 123;
string str = obj as string;  // Will return null instead of throwing an exception
if (str == null)
{
    Console.WriteLine("Invalid cast!");  // Output: Invalid cast!
}

Using Explicit Casting (Throws Exception):

object obj = 123;
string str = (string)obj;  // Throws InvalidCastException

6. Unboxing

Unboxing is the process of extracting a value type from an object. You can unbox a value type (e.g., int) from an object, but it requires an explicit cast.

Example:

object obj = 42; // Boxing the value
int number = (int)obj; // Unboxing
Console.WriteLine(number); // Output: 42

If you attempt to unbox an object to a wrong type, it will throw an InvalidCastException:

object obj = 42;
string str = (string)obj;  // InvalidCastException

7. Nullable Types and Casting

C# supports nullable types, which allow value types (like int, double, etc.) to hold null values. When casting nullable types, be careful to check if the value is null before performing operations.

Example:

int? nullableInt = 10;  // Nullable integer
int normalInt = nullableInt ?? 0;  // Use null-coalescing operator to provide default value
Console.WriteLine(normalInt);  // Output: 10

If the nullable type is null, using ?? allows you to assign a default value.

Conclusion

Type casting in C# enables you to convert variables from one type to another. You can perform implicit or explicit casting, depending on the situation. Implicit casting is safe and done automatically by the compiler, while explicit casting requires a manual conversion and may lead to data loss. The Convert class provides safer conversions, and error handling can be used to catch invalid casts. Understanding when and how to use casting ensures that your program can handle different data types efficiently and without errors.