Difference between DirectCast() and CType() in VB.

Question

I am an experienced C/C++/C# programmer who has just gotten into VB.NET. I generally use CType (and CInt, CBool, CStr) for casts because it is fewer characters and was the first way of casting which I was exposed to, but I am aware of DirectCast and TryCast as well.

Simply, are there any differences (effect of cast, performance, etc.) between DirectCast and CType? I understand the idea of TryCast.

Answer 1

With CType you can write some thing like this Ctype("string",Integer). But with DirectCast the above statement would give compile time error.

 Dim a As Integer = DirectCast("1", Integer) 'Gives compiler error
 Dim b As Integer = CType("1", Integer) 'Will compile

Answer 2

DirectCast is more restrictive than CType.

For example, this will throw an error:

Sub Main()
    Dim newint As Integer = DirectCast(3345.34, Integer)
    Console.WriteLine(newint)
    Console.ReadLine()
End Sub

It will also be shown in the Visual Studio IDE.

This however, does not throw an error:

Sub Main()
    Dim newint As Integer = CType(3345.34, Integer)
    Console.WriteLine(newint)
    Console.ReadLine()
End Sub

Answer 3

The first thing to note is that VB.NET does not have a direct analog to C#'s (type)instance casting mechanism. I bring that up because it's useful to use that as a starting point in comparing the two VB.NET operators (and they are operators, not functions, even though they have function semantics).

DirectCast() is more strict than the C# casting operator. It only allows you to cast when the item being cast already is the type you are casting to. It won't do any conversion. So, for example, you can't cast from short to int, like you could with a C# (int) cast. But you can cast from an IEnumerable to an array, if your underlying IEnumerable object variable really is an Array. And of course you can cast from Object to anything, assuming that the type your object instance really is somewhere below your cast type in the inheritance tree.

This is desirable because that makes it faster. There's a little less conversion and type checking that needs to take place.

CType() is less strict than the C# casting operator. It will do things like convert a string to an integer that you can't just do with a simple (int) cast. It has as much power as calling Convert.To___() in C#, where the ___ is the target type of your cast. This is desirable because it's very powerful, but that power comes at the cost of performance — it's not as fast as DirectCast() or C#'s cast operator because there might be quite a lot of work to do to finish the cast.

Generally you should prefer DirectCast() when you can.

Finally, you missed one casting operator: TryCast(), which is a direct analog to C#'s as operator.