Understanding Type Casting:

In C#, type casting is broadly categorized into two types: Implicit and Explicit.

Implicit Casting:

Implicit casting is also known as widening conversion, where the conversion happens automatically without the need for any explicit code. It is generally considered safe as it involves converting a smaller data type to a larger one. For example:

int integerNumber = 42;
double doubleNumber = integerNumber; // Implicit casting from int to double

Explicit Casting:

Explicit casting, or narrowing conversion, requires the developer to explicitly specify the type of conversion. It is riskier than implicit casting as it involves converting a larger data type to a smaller one, potentially leading to loss of data. The syntax for explicit casting involves placing the target type in parentheses before the variable. For example:

double doubleNumber = 42.56;
int integerNumber = (int)doubleNumber; // Explicit casting from double to int

Type Casting in Action:

Let's move into a practical example to illustrate the use of typecasting. Consider a scenario where you need to calculate the average of three numbers, but the result should be an integer. Without type casting, the division operation would yield a floating-point number. Here's how typecasting comes to the rescue:

using System;

class Program
{
    static void Main()
    {
        int num1 = 10;
        int num2 = 20;
        int num3 = 30;

        double average = (double)(num1 + num2 + num3) / 3; // Explicit casting for accurate division

        Console.WriteLine($"The average is: {average}");
    }
}

Output:

The average is: 20

In this example, explicit casting ensures that the division result is double, preventing data loss and providing an accurate average.