Introduction
When should you use CType
and when should you use DirectCast
and which one performs better? The short answer is: DirectCast
is twice
as fast for value types (integers, etc.), but identical for reference types.
Background
The first thing to understand is that CType
and DirectCast
are not the same thing. Only CType
can convert the underlying object
to a new instance of an object of a different type. For example, you want to turn an integer into a string. Since an integer doesn't inherit a string, a new instance
of a String
object must be created in order to store the number as a string. CType
can do this, DirectCast
cannot. Note: There are other ways
to do this too such as the Convert.ToString
method or CStr()
.
Dim MyInt As Integer = 123
Dim MyString1 As String = CType(MyInt, String)
Dim MyString2 As String = DirectCast(MyInt, String)
What DirectCast
and CType
do have in common is their ability to convert an object to a new type based on inheritance or implementation.
For example, if you have a string but it is stored in a variable of type Object
, you can use DirectCast
or CType
to treat that variable
as an object of type String
because type String
inherits type Object
. In this case, the underlying data in memory is not actually changing,
nor is any processing happening on that data.
Dim MyObject As Object = "Hello World"
Dim MyString1 As String = CType(MyObject, String)
Dim MyString2 As String = DirectCast(MyObject, String)
The danger: You must know what type you are dealing with before using DirectCast
. If you have a variable of type Object
and you
use DirectCast
to treat it as a String
, you'd better be sure that variable actually contains a String
(or Nothing
).
If an integer somehow found its way into that variable, an exception will be thrown.
A way to check in code if DirectCast
will work is by using the TypeOf
operator:
If TypeOf MyObject Is String Then
So, assuming you are doing a conversion based on inheritance or implementation, you have a choice: DirectCast
vs. CType
. Which is better?
The Answer
DirectCast
. According to the .NET documentation: DirectCast
does not use the Visual Basic run-time helper routines for conversion, so it can provide somewhat better
performance than CType
.
The included project runs a performance test on each scenario: DirectCast
vs. CType
for value and reference types. Remember, reference types are types like Forms,
Controls, Strings, and custom classes, whereas Value types are types like integers, doubles, and custom structures. Here are the results; the numbers are in milliseconds
for 1 million iterations:
DirectCast
on a reference type:
8.7885
CType
on a reference type:
11.718
DirectCast
on a value type:
18.5535
CType
on a value type:
39.06
The verdict: DirectCast
out performs CType
for value types almost 2 to 1.
DirectCast
also out performs CType
for reference types albeit by a much slimmer margin.
Note: Subsequent tests produced very similar results; try for yourself.
Another reason to use DirectCast
is that it's not VB.NET specific and is therefore more portable to other languages. So C# and other programmers might have an easier
time reading their code if they encountered DirectCast
.