Chapter 6: VB.

NET functions & sub procedures dedicated/specific task and it’s upon the programmer to
decide when to break the program into these small
6.1 Chapter objectives
manageable modules.
By the end of this topic, learners should be able to:
Different programming languages refer to these modules
a) Demonstrate understanding what modular using different terms. In C and C++, we call this small
programming is module functions, In Java, C# we call them methods while
b) Explain the benefits associated with in Visual Basic.NET, we call them sub
modular programming procedures/functions. Ideally, each of the module is
c) Demonstrate understanding on how to define and supposed to perform a specific function hence avoiding
invoke methods in functions and sub procedures in code duplication, simplifying program maintenance and
VB.NET debugging as well as promoting program portability
d) Understand the difference between an argument
and parameters.
e) Exhibit the different parameter passing techniques In the previous sections, we have encountered a
6.2 Introduction programming approach where all the code (statements) has
been written inside a single block e.g. a certain event handler
Modular programming is an art of software engineering
block. In the next sections we will learn how to program in a
whereby programmers/software engineers break large
modular way by writing additional user defined functions.
and complex programs into manageable portions known
as modules. Each of the module will perform a
6.3 Benefits associated with modular programming
i. Less code duplication since each module will do a
specific task.
ii. It’s also easy to maintain the program since the
programmer is working with small program
segments/module.
iii. Simplifies debugging since each program logic can
be verified separately
iv. Modules allow you to reusable the same code over
and again in different programs with less/little
code duplication
6.4 VB.NET function
In VB.NET, the function is a separate group of codes that are
used to perform a specific task when the defined function is
called/invoked in a program. It’s possible to create more
than one function in a program to perform various
functionalities. The function is also useful to code
reusability by reducing the duplicity of the code. For
example, if we need to use the same functionality at
multiple places in a program, we can simply create a
function and call it whenever required.
6.5 Defining a Function in VB.NET
The syntax to define a function in VB.NET is as follows :
[Access_specifier ] Function Function_Name [ (ParameterList) ]
As Return_Type
[ Block of Statement ]
Return return_val
End Function
Where,
▪ Access_Specifier: It defines the access level of the
function such as public, private, or friend, Protected
function to access the method.
▪ Function_Name: The function_name indicate the
name of the function that should be unique.
▪ ParameterList: It defines the list of the parameters
to send or retrieve data from a method.
 ▪ Return_Type: It defines the data type of the variable End Function
that returns by the function

The following are the various ways to define the function in

Example:
a VB.NET.
Write a program to find the sum and subtraction of two
Public Function example () As string
numbers using the function.
' Statement to be executed
We first define the two functions as shown below
End Function
Function Sum (ByVal x As Integer, ByVal y As Integer) As Integer
' Define the local variable.
Dim sum As Integer = 0
Private Function example(ByVal x As String) As double sum = x +y
Return sum
' Statement to be executed
End Function
End Function
Function Sub (ByVal x As Integer, ByVal y As Integer) As Integer
' Define the local variable.
Dim sub As Integer
Public Function example(ByVal username As x, ByVal y As
subtract =x - y
Integer) As integer Return sub
End Function
' Statement to be executed
6.6 Function call/invocation
Function definition is completely nothing since by itself it
does nothing unless instructed to execute. For a function to
execute, it needs to be called/invoked. The general syntax
for calling a function is as follows
Function_name (<argument list>)
For example, to call a function named sum and pass to it an
argument called number, we can use the following VB.NET
code
Dim x As Integer = txtFirst.Text
Dim y As Integer = txtSecond.Text
Result = Sum (x, y);
The above statement calls the function sum () and passes a
copy of the value stored in the variables x and y. When the
function is called/Invoked, computer memory is allocated
for the parameters, x and y, and the value passed is copied to
these memories.
The body of the function is executed and returns the value of
sum; x+y. This value is passed back to the calling block. The
memory allocated to the parameters and local variables is
then destroyed to free memory. The value returned is
assigned to the variable on the left-hand side, result, in the
expression used to call the function.
The net effect of executing the function in our example is that
the variable result has been assigned the value of the sum of
the two integers; x and y.
A function can be called any number of times from the same
or different parts of the program. It can be called with
different parameter values (though they must be of the
correct type).
The same syntax can be used to call the Sub() function
6.7 VB.NET Sub
A Sub procedure is a separate set of codes that are used in
VB.NET programming to execute a specific task but as
opposed to a function, it doesn’t return any values. The Sub The following are the different ways to define the types of
procedure is enclosed by the Sub and End Sub statement. Sub method.

6.8 Defining the Sub procedure Public Sub Example()

To define a sub procedure in VB.NET, we use the following ' Statement to be executed
syntax of the Sub procedure:
End Sub
[Access_Specifier ] Sub Sub_name [ (parameterList) ]

[ Block of Statement to be executed ]

Private Sub Example( ByVal x As String) As String
End Sub
' Statement to be executed
Where,
End Sub
o Access_Specifier: It defines the access level of the
procedure such as public, private or friend, Protected.
Public Sub Example( ByRef x As String, ByRef y As Integer)
o Sub_name: The Sub_name indicates the name of the
Sub that should be unique. ' Statement to be executed

o ParameterList: It defines the list of the parameters End Sub

to send/retrieve data from a method.

Example: Write a simple program to pass the empty, a Sub Sum(ByVal x As Integer, ByVal y As Integer)
single or double parameter of Sub procedure in the VB.NET.
' Define the local variable.
Sub Welcome()
Dim sum As Integer = 0
MsgBox("Welcome")
sum = x+ y
End Sub
MsgBox(" Sum of two number is : {0}", sum)

End Sub

Sub circle(ByVal radius As Double)

Dim Area As Double

Sub SubT(ByVal x As Integer, ByVal y As Integer)
Const PI as Double = 3.14
' Define the local variable.
Area = PI * r * r
Dim sub As Integer
MsgBox(" Area Of circle is : {0}", Area)
sub = x - y
End Sub
MsgBox(" Subtraction of two number is : {0}", sub)

End Sub
 Sub Mul(ByVal x As Integer, ByVal y As Integer)
' Define the local variable.
Dim mult As Integer
mult = n1 * n2
MsgBox(" Multiplication of two number is : {0}", mult)
End Sub
6.9 Sub Procedure call/invocation
Sub procedure definition is completely nothing since by
itself it does nothing unless instructed to execute. For a sub
procedure to execute, it needs to be called/invoked. The
general syntax for calling a sub procedure is as follows
sub_procedure_name (<argument list>)
For example, to call a sub procedure named Mul and pass the
two arguments called x and y, we can use the following
VB.NET code
Dim x As Integer = txtFirst.Text
Dim y As Integer = txtSecond.Text
Mul (x, y);
The above statement calls the procedure Mul () and passes a
copy of the value stored in the variables x and y. When the
sub procedure is called/Invoked, computer memory is
allocated for the parameters, x and y, and the value passed is
copied to these memories.
The body of the sub procedure is executed and returns the
but doesn’t return a value back to the calling block. The
memory allocated to the parameters and local variables is
then destroyed to free memory.
Just like a function, a sub procedure can be called any
number of times from the same or different parts of the
program. It can be called with different parameter values
(though they must be of the correct type).
The same syntax can be used to call the other sub procedures
is the same as shown below
 parameter that do not affect the Sub procedure's formal
argument/parameter. The syntax is s follows
Welcome() ' call welcome() procedure
Sub Sub_method( ByVal parameter_name As datatype )
Sum (x,y) 'call Sum() procedure
[ Statement to be executed]
subtT (x,y) 'call subT() procedure
End Sub
circle(7)’calls the circle procedure
Example, let’s create a program to understand the concept
of passing parameter by value.

Dim num1, num2 As Integer

6.10 parameter passing mechanism
Num1=txtNumber1.Text
In the VB.NET programming language, we can pass
Num2=txtNumber2.Text
parameters in two different ways; pass by Value or pass by
reference LblNumber.Text=”Before swapping the value of 'num1' is {
0}", num
5.8.1 Passing parameter by Value
lblNumber2.Text=”" Before swapping the value of 'num2' i
It’s the default in VB.NET. we call a method , copies of the
s {0}", num2
actual value of an argument are passed for each parameter.
Therefore, any changes made to the main function's actual call swap function
 swap(num1, num2) Using this mechanism, we pass the reference (memory
address) of an argument in the calling function to the
LblNumber.Text=”Before swapping the value of 'num1' is {
corresponding formal parameter of the called function.
0}", num
Therefore, called function can modify the value of the
lblNumber2.Text=”" Before swapping the value of 'num2' is argument by using its reference passed in. The parameter
{0}", num2 and arguments share the same memory location as the
' swap () method actual parameters supplied to the method.

Sub swap(ByVal a As Integer, ByVal b As Integer) The syntax for the passing parameter by Reference:

' Declare a temp variable
Dim temp As Integer
temp = a ' save the value of a to temp
b = a ' put the value of b into a
b = temp ' put the value of temp into b
End Sub
5.8.2 Passing parameter by Reference
Sub Sub_method( ByRef parameter_name1, ByRef Parameter_na
me2 )
[ Statement to be executed]
End Sub
In the above syntax, the ByRef keyword is used to pass the
Sub procedure's reference parameters.
Let's create a program to swap the values of two variables
using the ByRef keyword. We use the above example to
demonstrate the concept of calling by reference
Dim num1, num2 As Integer Dim temp As Integer

Num1=txtNumber1.Text temp = a ' save the value of a to temp

Num2=txtNumber2.Text b = a ' put the value of b into a

LblNumber.Text=”Before swapping the value of 'num1' is { b = temp ' put the value of temp into b
0}", num
End Sub
lblNumber2.Text=”" Before swapping the value of 'num2' is
{0}", num2

call swap function

swap(num1, num2)

LblNumber.Text=”Before swapping the value of 'num1' is {

0}", num

lblNumber2.Text=”" Before swapping the value of 'num2' is

{0}", num2

' swap () method

Sub swap(ByRef a As Integer, ByRef b As Integer)

' Declare a temp variable