Implicit And Explicit Type Casting In C#

Introduction

 

Imagine you have 3 containers of different sizes. Say a small-container, medium-container & large-container. 

 

Let's try to fit containers one into another, the order that we must follow is: small > medium > large. Which means smaller container can be fit inside medium & medium container can be easily fit inside a larger container.

 

This same concept is called type casting in programming. 

 

In C# we have different kinds of data-types - (Containers), which have different sizes. The following table represents the different sizes of data-type in C#.

 

DataType	Size in Byte(s)
byte	1
sbyte (signed byte)	1
short	2
ushort (unsigned)	2
int	4
uint (unsigned)	4
float	4
double	8
long	8
ulong (unsigned)	8
bool	2
char	2
string (object)	4
object type	4
DateTime	8
decimal	24

 

As per the table, let's try to fit small data-types into bigger ones.

 

Printing different kinds of data-types in C#.

using System;

namespace LeranCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            byte thisIsByte = 1;
            Console.WriteLine("byte: "+ thisIsByte);
            sbyte thisIsSignedByte = -1;
            Console.WriteLine("sbyte: " + thisIsSignedByte);
            short thisIsShort = -2;
            Console.WriteLine("short: " + thisIsShort);
            ushort thisIsUnsignedShort = 2;
            Console.WriteLine("ushort: " + thisIsUnsignedShort);
            int thisIsInt = -4;
            Console.WriteLine("int: " + thisIsInt);
            uint thisIsUnsignedInt = 4;
            Console.WriteLine("uint: " + thisIsUnsignedInt);
            float thisIsFloat = 8;
            Console.WriteLine("float: " + thisIsFloat);
            double thisIsDouble = 10.5;
            Console.WriteLine("double: " + thisIsDouble);
            long thisIsLong = -123456;
            Console.WriteLine("long: " + thisIsLong);
            ulong thisIsUnsignedlong = 123456;
            Console.WriteLine("ulong: " + thisIsUnsignedlong);
            bool thisIsBool = true;
            Console.WriteLine("bool: " + thisIsBool);
            char thisIsChar = 'c';
            Console.WriteLine("char: " + thisIsChar);
            string thisIsString = "string";
            Console.WriteLine("string: " + thisIsString);
            object thisIsObject = new object();
            Console.WriteLine("object: " + thisIsObject);
            DateTime thisIsDateTime = new DateTime();
            Console.WriteLine("DateTime: " + thisIsDateTime);
            decimal thisIsDecimal = 1234567890;
            Console.WriteLine("decimal: " + thisIsDecimal);
        }
    }
}

The output of the above program:

 

 

So now that we are clear on different kinds of data types, let's understand what typecasting means.

 

It allows assigning the value of one data-type to other data-type, either implicitly or explicitly.

• Implicit type casting: assigning the value of the smaller type to the larger type. i.e. fitting smaller containers into bigger ones. but both data types have to be compatible with one another. (you can not convert bool into string datatype, because they both are not compatible with each other.)
• This table will explain to you that what are possible types of implicit conversions for a few datatypes.

byte	short, int, long, float, double : all numeric types
short	int, long, float, double : can not convert into byte as it is a smaller container.
int	long, float, double : same reason as above.
long	float, double : same reason as above.
float	double : same reason as above.
char	int, long, float, double

 

So we get sequence like this: byte > short > char > int > long > float > double

 

Let's take one example of float & double.

 

First, an implicit conversion.

 

Just use equal to operator, and that's that.

Console.WriteLine("---------- Conversions -----------");
Console.WriteLine("---------- Impilcit double -----------");
thisIsDouble = thisIsFloat;
Console.WriteLine("double: " + thisIsDouble);

Let's see if double is assigned with float value.

 

Yes! it does.

 

Now when we try to convert the larger container into smaller ones, the compiler won't allow us.

 

 

The compiler not only gives us an error but it also suggests some solutions. here it is asking us to perform explicit type conversion. let's do that then.

thisIsFloat = (float)thisIsDouble;
Console.WriteLine("float: " + thisIsFloat);

Here, in order to explicitly convert, just follow the above syntax. i.e. put the type into parentheses and see if this works.

 

 

Who are we kidding, of course, it works.

 

There is one more way to perform the explicit conversion. we can parse types.

thisIsFloat = float.Parse(thisIsDouble.ToString());
Console.WriteLine("float: " + thisIsFloat);

If I tell you there is one more way to perform the explicit conversion. would you believe it?

 

You can use conversion methods. Let's try to convert char to int, but this time with convert methods.

char thisIsChar = 'A';
Console.WriteLine("char: " + thisIsChar);

thisIsInt = Convert.ToInt32(thisIsChar);
Console.WriteLine("int: " + thisIsInt);

This conversion will print ASCII code for a specific character. In this case, we have capital A, so it should print 65.

 

 

 Alright, so far so good.

 

 Let's see what different kinds of conversion methods C# provides.

using System;

namespace LeranCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            Convert.ToBoolean(1);
            //Converts a type to a Boolean value, where possible.
            //converts any number into True, except string or char. returns false for 0

            Convert.ToByte(2);
            //Converts a type to a byte.

            Convert.ToChar(5);
            //Converts a type to a single Unicode character.

            Convert.ToDateTime(new DateTime(2020, 5, 2));
            //Converts a type (integer or string type) to date-time structures.

            Convert.ToDecimal(10);
            //Converts a floating-point or integer type to a decimal type.

            Convert.ToDouble(15);
            //Converts a type to a double type.

            Convert.ToInt16(5);
            //Converts a type to a 16-bit integer.

            Convert.ToInt32(15);
            //Converts a type to a 32-bit integer.

            Convert.ToInt64(25);
            //Converts a type to a 64-bit integer.

            Convert.ToSByte(5);
            //Converts a type to a signed byte type.

            Convert.ToSingle(22);
            //Converts a type to a small floating point number.

            Convert.ToString(22);
            //Converts a type to a string.

            Convert.ToUInt16(20);
            //Converts a type to an unsigned int type.

            Convert.ToUInt32(18);
            //Converts a type to an unsigned long type.

            Convert.ToUInt64(16);
            //Converts a type to an unsigned big integer.

        }
    }
}

Conclusion

 

Now we know what different types of datatypes used in C#, and how we can easily convert one into another, as well as the different techniques for an explicit conversion.

 

I hope this article has been helpful to you for understanding typecasting. Please apply them whenever necessary.

 

Thank you so much. Keep coding.