Click here to Skip to main content
Click here to Skip to main content

DirectCast vs. CType

, 8 Apr 2007 CPOL
Rate this:
Please Sign up or sign in to vote.
When to use DirectCast vs. CType.

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) ' This will not work

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) ' This will work

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.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Tim Greenfield
Software Developer (Senior)
United States United States
I am a software architect and engineer who has been working in the industry since 1994. Although I officially started writing software many years earlier at age 11 by authoring games, graphics demos, or whatever I found interesting. I even landed my first consulting job at age 16 implementing a newly invented mathimatical algorithm for a team of researchers at the local University.
 
I've designed and implemented hundreds if not thousands of applications: client, web, and hybrid of all scales and was a contributing author to the Black Belt programming column of Visual Basic Programmer's Journal.
 
My goals when coding are always to write clean, reusable and optimized code using the latest and technology, tools and techniques.

Comments and Discussions

 
GeneralMy vote of 4 Pinmemberpldakob31-Jan-13 5:04 
GeneralMy vote of 5 PinmemberHarry von Borstel17-Dec-12 23:16 
GeneralMy vote of 4 Pinmemberlloyd_100630-Sep-12 21:03 
GeneralMy vote of 5 PinmemberRobert J. Good4-Sep-12 13:47 
GeneralMy vote of 5 PinmemberLisa Z. Morgan11-Feb-11 7:30 
GeneralA better "safe" means of using DirectCast PinmemberYoooder12-Mar-09 11:23 
GeneralRe: A better "safe" means of using DirectCast Pinmemberaspdotnetdev8-Jun-10 9:54 
QuestionOverhead Pinmemberstixoffire9-Apr-07 16:13 
AnswerRe: Overhead PinmemberTim Greenfield16-Apr-07 19:09 
Even with CType you'd still have to know that the source type is of a type that can be converted to your destination type or you'd get an exception all the same. So even in a scenario where you need to check the type with TypeOf before hand, DirectCast would still be faster.
 
The only scenario I can think of where CType might not be slower is if you had an object of an unknown type but you knew that type could always be CType'd to the destination type. In this case, you could call CType without evaluating TypeOf first whereas DirectCast could only be used after evaluating TypeOf. Even so, CType is probably be calling TypeOf under the hood and therefore I wouldn't expect to see any performance gain.
 
Regardless, nine out of ten times I already know the source type I'm dealing with, in which case an explicit check before hand is not necessary. For example, imagine you needed to use System.Xml.Serialization.XmlSerializer to create an instance of your class from some xml. So you might add a shared function to your class...
 
Public Class Class1
Shared Function Load(ByVal XmlReader As Xml.XmlReader) As Class1
Dim XmlSerializer As New Xml.Serialization.XmlSerializer(GetType(Class1))
Return DirectCast(XmlSerializer.Deserialize(XmlReader), Class1)
End Function
End Class
 
Here, XmlSerializer.Deserialize returns type object. Yet we know XmlSerializer is incapable of producing an object of any other type than Class1 because we told it so in it's constructor. Therefore checking the return value of Deserialize before casting to Class1 is completely uncessary. I find this to be far more the rule than the exception but it probably depends on what you're up to.
 
I will admit that the performance gains of DirectCast over CType are modest and hardly worth consideration unless you're repeating the task over many iterations; in which case, twice as fast can add up.
 
Tim Greenfield
Software Architect and Engineer

GeneralRe: Overhead Pinmemberstixoffire16-Apr-07 21:51 
GeneralAnother reason to use DirectCast... PinmemberSteven Campbell9-Apr-07 8:40 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.141220.1 | Last Updated 8 Apr 2007
Article Copyright 2007 by Tim Greenfield
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid