Type Casting or Type Conversion in .Net

Type Conversions

 

Conversion is based on type compatibility and data compatibility.

 

There are two types of conversions:

 

1.  Implicit Conversion

2.  Explicit Conversion

                   

 

Implicit Conversion

 

In implicit conversion the compiler will make conversion for us without asking.

 

char -> int -> float is an example of data compatibility.

 

Complier checks for type compatibility at compilation.  

 

Practical demonstration of implicit conversion

 

using System;

 

namespace implicit_conversion

{

    class Program

    {

        static void Main(string[] args)

        {

            int num1 =20000;

            int num2 =50000;

            long total;

            // In this the int values are implicitly converted to long data type;

            //you need not to tell compiler to do the conversion, it automatically does.

            total = num1 + num2;

 

            Console.WriteLine("Total is : " + total);

            Console.ReadLine();

        }

    }

}

 

Below table shows the implicitly type conversions that are supported by C#:

 

From	To
sbyte	short, int, long, float, double, decimal
byte	short, ushort, int, uint, long, ulong, float, double, decimal
short	int, long, float, double, decimal
ushort	int, uint, long, ulong, float, double, decimal
int	long, float, double, decimal
uint	long, ulong, float, double, decimal
long	float, double, decimal
ulong	float, double, decimal
float	double
char	ushort, int, uint, long, ulong, float, double, decimal

 

Explicit Conversion

 

In explicit conversion we specifically ask the compiler to convert the value into another data type.

 

CLR checks for data compatibility at runtime.

 

Explicit conversion is carried out using casts. When we cast one type to another, we deliberately force the compiler to make the transformation.

 

You should never expect that the cast would give you best or correct result. Casts are potentially unsafe. Casting of big data type into small may lead to loosing of data.

 

Practical demonstration of explicit conversion

 

using System;

 

namespace explicit_conversion

{

    class Program

    {

        static void Main(string[] args)

        {

            int num = 65;

           

            char alpha;

            alpha = (char)num;

            // In this the int values are explicitly converted to char data type;

            //you have to tell compiler to do the conversion, it uses casting.

           

            Console.WriteLine("alphabet is: " + alpha);

            Console.ReadLine();

        }

    }

}

 

Note: You can also use Explicit Cast Operator () and unboxing for explicit conversion.

 

Microsoft .NET provides three ways of type conversion:

 

1.  Parsing

2.  Convert Class

3.  Explicit Cast Operator ()

 

Parsing

 

Parsing is used to convert string type data to primitive value type. For this we use parse methods with value types.

 

Practical demonstration of parsing

 

using System;

 

namespace parsing

{

    class Program

    {

        static void Main(string[] args)

        {

            //using parsing

 

            int number;

            float weight;

 

            Console.Write("Enter any number : ");

            number = int.Parse(Console.ReadLine());

 

            Console.Write("Enter your weight : ");

            weight = float.Parse(Console.ReadLine());

 

            Console.WriteLine("You have entered : " + number);

            Console.WriteLine("You weight is : " + weight);

 

            Console.ReadLine();

        }

    }

}

 

Convert Class

 

One primitive type to another primitive type.

 

This class contains different static methods like ToInt32(), ToInt16(), ToString(), ToDateTime() etc used in type conversion.

 

Practical demonstration of Convert class

 

using System;

 

namespace convert_conversion

{

    class Program

    {

        static void Main(string[] args)

        {

            // example of using convert class

 

            string num = "23";

            int number = Convert.ToInt32(num);

 

            int age = 24;

            string vote = Convert.ToString(age);

 

            Console.WriteLine("Your number is : " + number);

            Console.WriteLine("Your voting age is : " + age);

 

            Console.ReadLine();

        }

    }

}

 

Explicit Cast Operator ()

 

In general this operator is used with non-primitive types to up level or down level casting. But it can also used with any type having type compatibility and data type compatibility.

 

using System;

 

namespace explicit_cast_conversion

{

    class Program

    {

        static void Main(string[] args)

        {

            int num1, num2;

            float avg;

            num1 = 10;

            num2 = 21;

            avg = (float)(num1 + num2) / 2;

 

            Console.WriteLine("average is : " + avg);

            Console.ReadLine();

        }

    }

}

 

Boxing and unboxing

 

Boxing and unboxing is an important concept in C# type system. With Boxing and unboxing one can link between value-types and reference-types by allowing any value of a value-type to be converted to and from type object.

 

Boxing  

• Boxing is a mechanism in which value type is converted into reference type.
• It is implicit conversion process in which object type (super type) is used.
• In this process type and value both are stored in object type

Unboxing  

• Unboxing is a mechanism in which reference type is converted into value.
• It is explicit conversion process.

Program to show boxing and unboxing:

 

using System;

 

namespace boxing

{

    class Program

    {

        static void Main(string[] args)

        {

            int i = 10;

            object o = i;             // boxing

            int j = (int)o;          // unboxing

 

            Console.WriteLine("value of o object : " + o);

            Console.WriteLine("Value of j : " + j);

 

            Console.ReadLine();

        }

    }

}