Type Conversions in C#
In this article, we will talk about how we can make type conversions (casting) with implicit and explicit keywords.
C# language is one of the strongly typed programming languages. In other words, if we want to assign an object to an object that we produce from a different type, we will get a compile time error. Let’s take a look at how we can avoid this situation with implicit and explicit keywords.
Implicit Conversions
If we want to assign an object belonging to class X to an object belonging to class Y in C# language, our code will not be compiled. In spite of this information, how can we assign the following int type object to a long type object?
int integerValue = 42;
long longValue = integerValue;The keyword that allows us to do this conversion is implicit. implicit conversions are transform types that will not generate errors. It indicates that the types are related to each other. In this way, an int object can be assigned to a long object. We do not receive errors during this type of conversion.
Explicit Conversions
Can we assign an object of type long to an object we define as int? The answer is both yes and no. If we look at the code block below, we can see that we cannot make a direct assignment as in the previous example.
long longValue = 42;
int intValue = (int) longValue;The reason we are unable to assign directly is because there is no guarantee that this conversion will be error-free. The limits of the values that long type can take are wider than the int object. For this reason, OverflowException may occur during conversion, or we may not see the expected value in the int value due to data loss. For this reason, we cannot apply implicit conversions. Since both values are numbers, this conversion can be done, but to be aware of this risk, an automatic conversion is not done by the language as in implicit conversions. Instead, with (), the software developer is expected to make an explicit conversion, being aware of the situation.
In short, we call the type conversions we make unconsciously implicit, and we call the type conversions we do consciously as explicit conversion.
Usage Scenerio
There were many value objects such as UserId, ProjectId, UserPassword in a project that I tried to develop by using the DDD concept. Most of these were structures with values such as Guid and string. While creating these value objects, I was first creating an object of Guid type as in the example below. Then I was generating an object of UserId type by giving the value to my constructor method.
To avoid this situation, we can use the implicit transformation operator as in the example below. In this way, we can assign the Guid object directly to the UserId object.
Bonus
In scenarios where we do unconscious type conversion, we also do a similar operation to method overload. For example, let’s assume that we have a method that takes an object of UserId type and manipulates it. We can also call this method with an object of Guid type. The reason for this is the C# language’s ability to activate the method by automatically converting the Guid object to the UserId type.
I hope it has been a useful post. You can click on this link to browse my other articles.
