Answer.

In Visual Basic, the issue of type conversion has been present since the early versions of the language and became particularly relevant with the advent of strict typing and multiple class hierarchies in .NET.

The main task is to ensure safe and explicit conversion between compatible data types, taking into account runtime and the possibility of errors.

The solution is that VB.NET provides the following key casting operators: CType, DirectCast, TryCast.

CType performs conversions between any compatible types and can invoke the implementation of the IConvertible interface.
DirectCast strictly requires type compatibility in the inheritance hierarchy, does not perform type conversion, but only reference casting.
TryCast returns Nothing if the cast is not possible, without throwing an exception (suitable only for reference types).

Code example:

Class Animal : End Class
Class Dog
    Inherits Animal
End Class

Dim a As Animal = New Dog()
Dim d1 As Dog = CType(a, Dog)
Dim d2 As Dog = DirectCast(a, Dog)
Dim d3 As Dog = TryCast(a, Dog) ' d3 — Dog object or Nothing

Key features:

CType is the most universal but may throw exceptions when conversion is not possible.
DirectCast only checks for strict type reference compliance.
TryCast does not throw exceptions but simply returns Nothing.

Trick questions.

Can TryCast be used for value types?

No, TryCast works only with reference types. Attempting to use it on a struct will result in a compilation error.

What is the difference between CInt(obj) and CType(obj, Integer)?

They are similar; both attempt to convert obj to Integer. However, CInt is stricter with string format definitions, and it is preferable to use CType for explicit conversions.

When is it better to use DirectCast instead of CType?

When it is known that objects are related through inheritance or implement one interface, and no custom type conversion is required. DirectCast is more efficient because it does not invoke conversion logic.

Common mistakes and anti-patterns

Incorrect type casting leads to InvalidCastException
Using TryCast where conversion failure handling is required
Using CType for casting to unrelated types

Real-life example

Negative case

In the project, CType is always used for any conversions, resulting in unhandled exceptions when types are incompatible.

Pros:

Simple and versatile.

Cons:

Increased likelihood of runtime errors and application crashes.

Positive case

The team uses different operators: DirectCast for reference structures, TryCast when working with unknown objects. Handling of Nothing for TryCast is added.