TypeCasting
Tags: typeconversion, implicit, explicit, casting
Published: 2020-09-16 17:10:15

#Implicit Casting vs. Explicit Casting in C-sharp

[GitHub Link](https://github.com/TECHCareers-by-Manpower/how-to-write-effective-documentation-TECHCareers-HARPREET.git)

**Type conversion:**
* After a variable is declared, it cannot be declared again or assigned a value of another type unless that type is implicitly convertible to the variable's type.
  
 **Example:**

```
bool result;
result = “Hello”;
```
```
Output: Cannot implicitly convert type 'string' to 'bool'

```
* To copy a value into a variable or method parameter of another type or to assign a class variable to a variable of an interface type, these kinds of operations are called Type Conversions. 

**Type Casting:** In C#, there are two types of casting:
* Implicit Casting
* Explicit Casting

#Implicit Casting

* Implicit type casting means conversion of data types without losing its original meaning.

* In Implicit Casting, no special syntax is required because the conversion always succeeds and no data will be lost, this is the safest type of casting.


 **Example:**
```
// C# program to demonstrate the Implicit Type Conversion
using System; 
namespace Casting
{ 
 class Program 
  { 
        // Main Method 
        public static void Main(String []args) 
        { 
            int i = 57;  
            // automatic type conversion 
            long l = i;  
            // automatic type conversion 
            float f = l; 
            // Display Result 
            Console.WriteLine("Int value "  +i); 
            Console.WriteLine("Long value "  +l); 
            Console.WriteLine("Float value "  +f); 
         } 
     } 
  }   
```  
```
Output:
Int value 57
Long value 57
Float value 57

```

* During conversion, strict rules for type conversion are applied. If the operands are of two different data types, then an operand having lower data type is automatically converted into a higher data type.

* This type of typecasting is essential when you want to change data types without changing the significance of the values stored inside the variable.
* Implicit type conversion happens automatically when a value is copied to its compatible data type.
* Implicit type conversion is also called standard type conversion. Converting from a smaller data type into larger data type is also called a type promotion.
**Example:**
char -> int -> long -> float -> double

**We cannot perform implicit type casting on the data types which are not compatible with each other such as:**
* Converting float to an int will truncate the fraction part hence losing the meaning of the       value.
* Converting double to float will round up the digits.
* Converting long int to int will cause dropping of excess high order bits.
 
#Explicit Casting

* If a conversion cannot be made without a risk of losing information, the compiler requires that you perform an explicit conversion, which is called a cast.  A cast is a way of explicitly informing the compiler that you intend to make the conversion and that you are aware that data loss might occur, or the cast may fail at runtime.

* To force the type conversion in such situations, we use explicit type casting. It requires a type casting operator. The general syntax for type casting operations is as follows:

     **(type-name) expression**

* To perform a cast, specify the type that you are casting to in parentheses in front of the value or variable to be converted.

**Example:**
The following program casts a double to an int. The program will not compile without the cast.
```
// C# program to demonstrate the Explicit Type Conversion
            class Test
            { 
            static void Main()
              {
                double x = 1234.7;
                int a;
                // Cast double to int.
                a = (int)x;
                Console.WriteLine("x:" + x);
                Console.WriteLine("a:" + a);
               }
             }   
```                                                                                          
```
Output:
x:1234.7
a:1234

```


#Summary
* Typecasting is also called type conversion.
* It means converting one data type into another.
* Converting a smaller data type into a larger one is also called type promotion.
* 'C' provides an implicit and explicit way of type conversion.
* Implicit type conversion operates automatically when the compatible data type is found.
* Explicit type conversion requires a type casting operator.
* Implicit type casting means conversion of data types without losing its original meaning whereas Explicit conversion cannot be made without a risk of losing information.
 
**Keep in mind the following rules for programming practice when dealing with different data type to prevent from data loss :**
* Integers types should be converted to float.
* Float types should be converted to double.
* Character types should be converted to integer.