A procedure is referred to as "built-in" if
it shipped with its programming language. To make your job a little easier,
the Visual Basic language is equipped with many procedures that you can use right
away in your program. Based on this, before creating your own procedure,
first check whether the functionality you are looking for is already
implementing in one of the available procedures because those that ship
with the Visual Basic language are highly reliable and should be preferred.

Before using a built-in procedure, you must of course
be familiar with it. This comes either by consulting the documentation or
by experience. This means that you must know its name, its argument(s),
its return value, and its role. The Visual Basic programming language provides one of the richest
libraries you will ever see. In fact, it is the richest of the .NET-based languages, giving
you access to functions that are not directly available to other languages
such as C# or C++/CLI. Because there so many of those functions, we will
review only the most usually used. Eventually, when necessary, in other
lessons, we may introduce new ones.

Conversion Functions

You may recall that when studying data types, we saw
that each had a corresponding function used to convert a string value or
an expression to that type. As a reminder, the general syntax of the conversion functions is:

ReturnType = FunctionName(Expression)

The Expression could be of any kind. For example, it
could be a string or expression that would produce a value such as the result of a calculation. The conversion function would take such a value, string, or
expression and attempt to convert it. If the conversion is successful,
the function would return a new value that is of the type specified by
the ReturnType in our syntax.

The conversion functions are as follows:

Function

Name

Return
Type

Description

CBool

Boolean

Converts an expression into a
Boolean value

CByte

Byte

Converts an expression into Byte
number

CDbl

Double

Converts an expression into a
floating-point number with double precision

CDec

Decimal

Converts an expression into a
decimal number

CInt

Integer

Converts an expression into an
integer (natural) number

CLng

Long

Converts an expression into a
long integer (a large natural) number

CObj

Object

Converts an expression into an
Object type

CSByte

SByte

Converts an expression into a
signed byte

CShort

Short

Converts an expression into a
short integer

CSng

Single

Converts an expression into a
floating-point number with single precision

CUInt

UInt

Converts an expression into an
unsigned integer

CULng

ULong

Converts an expression into an
unsigned long integer

CUShort

UShort

Converts an expression into an
unsigned short integer

These functions allow you to convert a known value to a
another type. Besides these functions, the Visual Basic language provides a
function named CType. Its syntax is:

CType(expression, typename)

As you can see, the CType() function takes two
arguments. The first argument is the expression or the value that you want to
convert. An example could be name of a variable or a calculation:

CType(250.48 * 14.05, ...)

The second argument is the type of value you want to convert
the first argument to. From what have learned so far, this second argument can
be one of the data types we reviewed in Lesson 3. Here is an example:

CType(250.48 * 14.05, Single)

If you choose one of the Visual Basic language's data types,
the expression produced by the first argument must be able to produce a value
that is conform to the type of the second argument:

The conversion from the first argument to the type of the second argument
must be possible: the value produced by the first must be convertible to the
second arguments. For example, if the first argument is a calculation, the
second argument must be a number-based data type. In the same way, you
cannot convert a date to a number-based type

If the first argument is a number or the result of a calculation, its
resulting value must be lower than or up to the range of values of the
second argument. Here is an example:

If the first argument is a number or the result of a calculation that
produces an integer or a floating-point number, its resulting value must be
convertible to an integer or a floating point number up to the range of
values of the second argument. Here is an example:

If the first argument is a number or the result of a calculation that
produces an integer or a floating-point number, the second argument is a
number-based data type but whose range cannot hold the resulting value of
the first argument, the conversion would not be allowed (the conversion will
fail):

After the CType() function has performed its
conversion, it returns a value that is the same category as the second argument.
For example, you can call a CType() function that converts an expression
to a long integer. Here is an example:

Public Module Exercise
Public Function Main() As Integer
Dim Number As Long
Number = CType(7942.225 * 202.46, Long)
Return 0
End Function
End Module

The function can also return a different type, as long as
its type can hold the value produced by the expression. Here are two examples:

Public Module Exercise
Public Function Main() As Integer
Dim Number As UInteger
Number = CType(7942.225 * 202.46, Long)
Return 0
End Function
End Module

Or

Public Module Exercise
Public Function Main() As Integer
Dim Number As Single
Number = CType(7942.225 * 202.46, Long)
Return 0
End Function
End Module

If you try storing the returned value into a variable that
cannot hold it, you would receive an error: