Subs, Functions and Events 1

Outline Introduction VB.NET Procedures Sub Procedures Function Procedures Methods Argument Promotion Value Types and Reference Types Passing Arguments: Pass-by-Value vs. Pass-by-Reference Duration of Identifiers Scope Rules Events

VB.NET Procedures Framework Class Library Provides a rich collection of “prepackaged” classes and methods for performing many operations Mathematical calculations String manipulations Character manipulations Input/output operations

VB.NET Procedures Programmer-defined procedures FCL cannot provide every conceivable feature that a programmer could want Three types of procedures Sub procedures Function procedures Event procedures A procedure is invoked by a procedure call

Payment.vb Program Output Console application uses a Sub procedure (invoked from the application’s Main procedure) to print a worker’s payment information. 1 ' Fig. 6.2: Payment.vb 2 ' Sub procedure that prints payment information. 3 4 Module modPayment 5 6 Sub Main() 7 8 ' call Sub procedure PrintPay 4 times 9 PrintPay(40, 10.5) 10 PrintPay(38, 21.75) 11 PrintPay(20, 13) 12 PrintPay(50, 14) 13 14 Console.ReadLine() ' prevent window from closing 15 End Sub ' Main 16 17 ' print amount of money earned in command window 18 Sub PrintPay(ByVal hours As Double, ByVal wage As Decimal) 19 20 ' pay = hours * wage 21 Console.WriteLine("The payment is {0:C}", hours * wage) 22 End Sub ' PrintPay 23 24 End Module ' modPayment Payment.vb Program Output PrintPay receives the values of each argument and stores them in the parameters variables hours and wage The payment is $420.00 The payment is $826.50 The payment is $260.00 The payment is $700.00 Notice that PrintPay appears within modPayment. All procedures must be defined inside a module or a class

Sub Procedures The program contains two procedure definitions: Sub procedure Main, which executes when the console application is loaded. Sub procedure PrintPay, which executes when it is invoked, or called, from another procedure, in this case Main.

Sub Procedures Format of a procedure definition Sub procedure-name(parameter-list) declarations and statements End Sub Procedure header: ByVal: specifies that the calling program should pass a copy of the value of the argument in the procedure call to the parameter, which can be used in the Sub procedure body. Procedure-name Directly follows the Sub keyword Can be any valid identifier Procedure body The declarations and statements in the procedure definition form the procedure body

Common Errors Declaring a variable in the procedure’s body with the same name as a parameter variable in the procedure header is a syntax error. Although it is allowable, an argument passed to a procedure should not have the same name as the corresponding parameter in the procedure definition. This distinction prevents ambiguity that could lead to logic errors. Defining a procedure inside another procedure is a syntax error—procedures cannot be nested. The procedure header and procedure calls all must agree with regard to the number, type and order of parameters.

Function Procedures Similar to Sub procedures One important difference: Function procedures return a value to the caller, whereas Sub procedures do not.

Console application uses Function procedure Square to calculate the squares of the Integers from 1–10. 1 ' Fig. 6.3: SquareInteger.vb 2 ' Function procedure to square a number. 3 4 Module modSquareInteger 5 6 Sub Main() 7 Dim i As Integer ' counter 8 9 Console.WriteLine("Number" & vbTab & "Square" & vbCrLf) 10 11 ' square numbers from 1 to 10 12 For i = 1 To 10 13 Console.WriteLine(i & vbTab & Square(i)) 14 Next 15 16 End Sub ' Main 17 18 ' Function Square is executed 19 ' only when the function is explicitly called. 20 Function Square(ByVal y As Integer) As Integer 21 Return y ^ 2 22 End Function ' Square 23 24 End Module ' modSquareInteger The For structure displays the results of squaring the Integers from 1-10 Square is invoked with the expression Square(i) The Return statement terminates execution of the procedure and returns the result of y ^ 2

Program Output Number Square 1 1 2 4 3 9 4 16 5 25 6 36 7 49 8 64 9 81   1 1 2 4 3 9 4 16 5 25 6 36 7 49 8 64 9 81 10 100

Function Procedures Format of a Function procedure definition Function procedure-name(parameter-list) As return-type declarations and statements End Function Return-type: Indicates the data type of the result returned from the Function to its caller Return expression Can occur anywhere in a Function It returns exactly one value Control returns immediately to the point at which that procedure was invoked

Common Errors If the expression in a Return statement cannot be converted to the Function procedure’s return-type, a runtime error is generated. Failure to return a value from a Function procedure (e.g., by forgetting to provide a Return statement) causes the procedure to return the default value for the return-type, often producing incorrect output.

EX1- Maximum Number 1 ' Fig. 6.4: Maximum.vb 2 ' Program finds the maximum of three numbers input. 3 4 Public Class FrmMaximum 5 6 ' obtain values in each text box, call procedure Maximum 7 Private Sub btnMaximum_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnMaximum.Click 8 Dim value1, value2, value3 As Double 9 10 value1 = txtFirst.Text 11 value2 = txtSecond.Text 12 value3 = txtThird.Text 13 14 lblMaximum.Text = Maximum(value1, value2, value3) 15 End Sub ' cmdMaximum_Click 16 17 ' find maximum of three parameter values 18 Function Maximum(ByVal valueOne As Double, ByVal valueTwo As Double, ByVal valueThree As Double) As Double 19 20 Return Math.Max(Math.Max(valueOne, valueTwo), valueThree) 21 End Function ' Maximum 22 23 End Class ' FrmMaximum Event handler btnMaximum_Click Handles the event in which Button btnMaximum is clicked

EX2- Sorting Array Bubble Sort (a.k.a. sinking sort) Smaller values “bubble” their way to the top of the array, (i.e. toward the first element) Larger values “sink” to the bottom of the array, (i.e. toward the end) The bubble sort is easy to program, but runs slowly Becomes apparent when sorting large arrays

Sub BubbleSort Sub Swap Sub cmdCreate_Click Sub cmdSort_Click 1 Public Class FrmBubbleSort 2 Dim array As Integer() = New Integer(9) { } 3 ' sort array using bubble sort algorithm 4 Sub BubbleSort(ByVal sortArray As Integer()) 5 Dim pass, i As Integer 6 7 For pass = 1 To sortArray.GetUpperBound(0) 8 9 For i = 0 To sortArray.GetUpperBound(0) - 1 10 11 If sortArray(i) > sortArray(i + 1) Then 12 Swap(sortArray, i) 13 End If 14 Next 15 Next 16 End Sub ' BubbleSort 17 18 Sub Swap(ByVal swapArray As Integer(), ByVal first As Integer) 19 Dim hold As Integer 20 hold = swapArray(first) 21 swapArray(first) = swapArray(first + 1) 22 swapArray(first + 1) = hold 23 End Sub ' Swap Sub BubbleSort Sub Swap Sub cmdCreate_Click Sub cmdSort_Click

25 ' creates random generated numbers 24 25 ' creates random generated numbers 26 Private Sub cmdCreate_Click(ByVal sender As System.Object, _ 27 ByVal e As System.EventArgs) Handles cmdCreate.Click 28 29 Dim output As String 30 Dim randomNumber As Random = New Random() 31 Dim i As Integer 32 txtSorted.Text = "“ 33 ' create 10 random numbers and append to output 34 For i = 0 To array.GetUpperBound(0) 35 array(i) = randomNumber.Next(100) 36 output &= array(i) & vbCrLf 37 Next 38 39 txtOriginal.Text = output ' display numbers 40 cmdSort.Enabled = True ' enables cmdSort button 41 End Sub ' cmdCreate_Click txtOriginal.Text txtSorted.Text cmdCreate cmdSort

42 ' randomly generated numbers 44 Private Sub cmdSort_Click(ByVal sender As System.Object, _ 44 ByVal e As System.EventArgs) Handles cmdSort.Click 45 46 Dim output As String 47 Dim i As Integer 48 49 ' sort array 50 BubbleSort(array) 51 52 ' creates string with sorted numbers 53 For i = 0 To array.GetUpperBound(0) 54 output &= array(i) & vbCrLf 55 Next 56 57 txtSorted.Text = output ' display numbers 58 cmdSort.Enabled = False 59 End Sub ' cmdSort_Click 60 61 End Class ' FrmBubbleSort

EX3- Searching Arrays: Linear Search The process of locating a particular element value in an array Linear Search Simple searching technique Works well for small or unsorted arrays

Compares each element of the array with a search key Function LinearSearch Sub cmdCreate_Click Sub cmdSearch_Click 1 Public Class FrmLinearSearchTest 2 3 Dim array1 As Integer() = New Integer(19) {} 4 ' iterates through array 5 6 Function LinearSearch(ByVal key As Integer, ByVal numbers As Integer()) As Integer 7 8 Dim n As Integer 9 10 ' structure iterates linearly through array 11 For n = 0 To numbers.GetUpperBound(0) 12 13 If numbers(n) = key Then 14 15 Return n 16 End If 17 18 Next 19 20 Return -1 21 End Function ' LinearSearch Compares each element of the array with a search key If the search key is not found, the procedure returns –1, a non-valid index number

txtInput txtData lblResult cmdSearch cmdCreate 22 ' creates random data 23 Private Sub cmdCreate_Click(ByVal sender As System.Object, _ 24 ByVal e As System.EventArgs) Handles cmdCreate.Click 25 26 Dim output As String 27 Dim randomNumber As Random = New Random() 28 Dim i As Integer 29 30 output = "Index" & vbTab & "Value" & vbCrLf 31 ' creates string containing 11 random numbers 32 For i = 0 To array1.GetUpperBound(0) 33 array1(i) = randomNumber.Next(1000) 34 output &= i & vbTab & array1(i) & vbCrLf 35 Next 36 37 txtData.Text = output ' displays numbers 38 txtInput.Text = "" ' clear search key text box 39 cmdSearch.Enabled = True ' enable search button 40 End Sub ' cmdCreate_Click txtData lblResult cmdSearch cmdCreate txtInput

41 ' searches key of element 42 Private Sub cmdSearch_Click(ByVal sender As System.Object, _ 43 ByVal e As System.EventArgs) Handles cmdSearch.Click 44 45 ' if search key text box is empty, display 46 ' message and exit procedure 47 If txtInput.Text = "" Then 48 MessageBox.Show("You must enter a search key.") 49 Exit Sub 50 End If 51 52 Dim searchKey As Integer = Convert.ToInt32(txtInput.Text) 53 Dim element As Integer = LinearSearch(searchKey, array1) 54 55 If element <> -1 Then 56 lblResult.Text = "Found Value in index " & element 57 Else 58 lblResult.Text = "Value Not Found" 59 End If 60 61 End Sub ' cmdSearch_Click 62 63 End Class ' FrmLinearSearch

Argument Promotion Coercion of arguments The forcing of arguments to be appropriate data type so that they can be passed to a procedure. Visual Basic supports both: Widening conversion Occurs when a type is converted to another type without losing data Narrowing conversion Occurs when there is potential for data loss during the conversion

Argument Promotion Fig. 6.8 Widening conversions.

Value Types and Reference Types All Visual Basic data types can be categorized as either: Variable of a value type Contains the actual data Used for a single piece of data the integral types (Byte, Short, Integer and Long), the floating-point types (Single and Double) and types Boolean, Date, Decimal and Char. Variable of a reference type Contains a location in memory where data is stored. Known as objects Arrays String.

Passing Arguments: Pass-by-Value vs. Pass-by-Reference The program makes a copy of the argument’s value and passes that copy to the called procedure changes to the called procedure’s copy do not affect the original variable’s value. Pass-by-reference The caller gives the called procedure the ability to access and modify the caller’s original data directly.

When number1 is passed, a copy of the value is passed to the procedure 1 ' Fig. 6.12: ByRefTest.vb 2 ' Demonstrates passing by reference. 3 4 Module modByRefTest 5 6 ' squares three values ByVal and ByRef, displays results 7 Sub Main() 8 Dim number1 As Integer = 2 9 10 Console.WriteLine("Passing a value-type argument by value:") 11 Console.WriteLine("Before calling SquareByValue, " & _ 12 "number1 is {0}", number1) 13 SquareByValue(number1) ' passes number1 by value 14 Console.WriteLine("After returning from SquareByValue, " & _ 15 "number1 is {0}" & vbCrLf, number1) 16 17 Dim number2 As Integer = 2 18 19 Console.WriteLine("Passing a value-type argument" & _ 20 " by reference:") 21 Console.WriteLine("Before calling SquareByReference, " & _ 22 "number2 is {0}", number2) 23 SquareByReference(number2) ' passes number2 by reference 24 Console.WriteLine("After returning from " & _ 25 "SquareByReference, number2 is {0}" & vbCrLf, number2) 26 27 Dim number3 As Integer = 2 28 When number1 is passed, a copy of the value is passed to the procedure A reference to the value stored in number2 is being passed

ByVal indicates that value-type arguments should be passed by value 29 Console.WriteLine("Passing a value-type argument" & _ 30 " by reference, but in parentheses:") 31 Console.WriteLine("Before calling SquareByReference " & _ 32 "using parentheses, number3 is {0}", number3) 33 SquareByReference((number3)) ' passes number3 by value 34 Console.WriteLine("After returning from " & _ 35 "SquareByReference, number3 is {0}", number3) 36 37 End Sub ' Main 38 39 ' squares number by value (note ByVal keyword) 40 Sub SquareByValue(ByVal number As Integer) 41 Console.WriteLine("After entering SquareByValue, " & _ 42 "number is {0}", number) 43 number *= number 44 Console.WriteLine("Before exiting SquareByValue, " & _ 45 "number is {0}", number) 46 End Sub ' SquareByValue 47 48 ' squares number by reference (note ByRef keyword) 49 Sub SquareByReference(ByRef number As Integer) 50 Console.WriteLine("After entering SquareByReference" & _ 51 ", number is {0}", number) 52 number *= number 53 Console.WriteLine("Before exiting SquareByReference" & _ 54 ", number is {0}", number) 55 End Sub ' SquareByReference 56 57 End Module ' modByRefTest Enclosing arguments in parenthesis forces pass-by-value even if using ByRef ByVal indicates that value-type arguments should be passed by value ByRef gives direct access to the value stored in the original variable

Program Output Passing a value-type argument by value: Before calling SquareByValue, number1 is 2 After entering SquareByValue, number is 2 Before exiting SquareByValue, number is 4 After returning from SquareByValue, number1 is 2   Passing a value-type argument by reference: Before calling SquareByReference, number2 is 2 After entering SquareByReference, number is 2 Before exiting SquareByReference, number is 4 After returning from SquareByReference, number2 is 4 Passing a value-type argument by reference, but in parentheses: Before calling SquareByReference using parentheses, number3 is 2 After returning from SquareByReference, number3 is 2

Passing Arguments: Pass-by-Value vs. Pass-by-Reference Passing value-type arguments with keyword ByRef is useful when procedures need to alter argument values directly. However, passing by reference can weaken security, because the called procedure can modify the caller’s data. Reference-type variables passed with keyword ByVal are effectively passed by reference, as the value that is copied is the reference for the object. Although Visual Basic allows programmers to use keyword ByRef with reference-type parameters, it is usually not necessary to do so except with type String.

Duration of Identifiers Identifier’s duration: Period during which the identifier exists in memory Automatic duration Identifiers that represent local variables in a procedure have automatic duration Instance variable A variable declared in a class They exist as long as their containing class is loaded in memory Identifier’s scope: Portion of a program in which the variable’s identifier can be referenced

Scope Rules Possible scopes Class scope Module scope Namespace scope Begins at the class identifier after keyword Class and terminates at the End Class statement Module scope Variable declared in a module have module scope, which is similar to class scope Namespace scope Procedures defined in a module have namespace scope, which generally means that they may be accessed throughout a project Block scope Identifiers declared inside a block, such as the body of a procedure definition or the body of an If/Then selection structure, have block scope

1 ' Fig. 6.13: Scoping.vb 2 ' Demonstrates scope rules and instance variables. 3 4 Public Class FrmScoping 5 Inherits System.Windows.Forms.Form 6 7 Friend WithEvents lblOutput As System.Windows.Forms.Label 8 9 ' Windows Form Designer generated code 10 11 ' instance variable can be used anywhere in class 12 Dim value As Integer = 1 13 14 ' demonstrates class scope and block scope 15 Private Sub FrmScoping_Load(ByVal sender As System.Object, _ 16 ByVal e As System.EventArgs) Handles MyBase.Load 17 18 ' variable local to FrmScoping_Load hides instance variable 19 Dim value As Integer = 5 20 21 lblOutput.Text = "local variable value in" & _ 22 " FrmScoping_Load is " & value 23 24 MethodA() ' MethodA has automatic local value 25 MethodB() ' MethodB uses instance variable value 26 MethodA() ' MethodA creates new automatic local value 27 MethodB() ' instance variable value retains its value 28 29 lblOutput.Text &= vbCrLf & vbCrLf & "local variable " & _ 30 "value in CScoping_Load is " & value 31 End Sub ' FrmScoping_Load This variable is hidden in any procedure that declares a variable named value

32 ' automatic local variable value hides instance variable 34 Sub MethodA() 35 Dim value As Integer = 25 ' initialized after each call 36 37 lblOutput.Text &= vbCrLf & vbCrLf & "local variable " & _ 38 "value in MethodA is " & value & " after entering MethodA" 39 value += 1 40 lblOutput.Text &= vbCrLf & "local variable " & _ 41 "value in MethodA is " & value & " before exiting MethodA" 42 End Sub ' MethodA 43 44 ' uses instance variable value 45 Sub MethodB() 46 lblOutput.Text &= vbCrLf & vbCrLf & "instance variable" & _ 47 " value is " & value & " after entering MethodB" 48 value *= 10 49 lblOutput.Text &= vbCrLf & "instance variable " & _ 50 "value is " & value & " before exiting MethodB" 51 End Sub ' MethodB 52 53 End Class ' FrmScoping Automatic variable value is destroyed when MethodA terminates When MethodB procedure refers to variable value, the instance variable value (line 12) is used.

Events An event is something that happens. Your birthday is an event. An event in programming terminology is when something special happens. These events are so special that they are built in to the programming language. VB.NET has numerous Events that you can write code for. And we’re going to explore some of them in this course. We’ll start with all that mysterious code for the Button’s Click Event.

The Click Event Buttons have the ability to be clicked on. When you click a button, the event that is fired is the Click Event. If you were to add a new button to a form, and then double clicked it, you would see the following code stub: Private Sub btnOutput_Click(ByVal sender As Object, _ ByVal e As System.EventArgs) Handles btnOutput.Click End Sub

The Click Event Private Sub btnOutput_Click(ByVal sender As Object, _ For example suppose we want the Button btnOutput to respond when clicked by showing a message box with the statement Button was clicked. Private Sub btnOutput_Click(ByVal sender As Object, _ ByVal e As System.EventArgs) Handles btnOutput.Click MessageBox.Show(“Button was clicked.") End Sub An event is a message sent by an object announcing that something has happened. When events occurs, information is passed to Event handlers ( Here it is btnOutput.Click).

The Click Event This is a Private Subroutine. The name of the Sub is btnOutput_Click. The Event itself is at the end: btnOutput.Click. The Handles word means that this Subroutine can Handle the Click Event of btnOutput. You can have this btnOutput_Click Sub Handle other things, too. It can Handle the Click Event of other Buttons, for example. Handles btnOutput.Click, Button2.Click

Event Handler Arguments Event handlers take two arguments: An Object (usually sender) : Instead of sender being an integer or string variable, the type of variable set up for sender is System.Object. This stores a reference to a control (which button was clicked, for example). 2. An event arguments object (e) : An instance of type EventArgs. Class EventArgs is the base class for objects that contain event information.

  Other Events Fig. 12.6 Events section of the Properties window.

Conclusion Experience has shown that the best way to develop and maintain a large program is to construct it from small, manageable pieces. This technique is known as divide and conquer. Visual Basic programs consist of many pieces, including modules and classes. Three types of procedures exist: Sub procedures, Function procedures and event procedures.

Conclusion The characteristics of Function procedures are similar to those of Sub procedures. However, Function procedures return a value to the caller. If a Function procedure body does not specify a Return statement, program control returns to the point at which a procedure was invoked when the End Function keywords are encountered.

Conclusion An event represents a user action, such as the clicking of a button. Widening conversion occurs when a type is converted to another type without losing data. Narrowing conversion occurs when there is potential for data loss during a conversion. Some narrowing conversions can fail, resulting in runtime errors and logic errors.

Conclusion Option Explicit, which is set to On by default, forces the programmer to declare all variables explicitly before they are used in a program. Forcing explicit declarations eliminates spelling errors and other subtle errors that may occur if Option Explicit is turned Off. Option Strict, which is set to Off by default, increases program clarity and reduces debugging time. When set to On, Option Strict requires the programmer to perform all narrowing conversions explicitly.

Conclusion All data types can be categorized as either value types or reference types. A variable of a value type contains data of that type. A variable of a reference type contains the location in memory where the data is stored.

Conclusion Arguments are passed in one of two ways: Pass-by-value and pass-by-reference. When an argument is passed by value, the program makes a copy of the argument’s value and passes that copy to the called procedure. Changes to the called procedure’s copy do not affect the original variable’s value. When an argument is passed by reference, the caller gives the procedure the ability to access and modify the caller’s original data directly. Pass-by-reference can improve performance, because it eliminates the need to copy large data items, such as large objects; however, pass-by-reference can weaken security, because the called procedure can modify the caller’s data.

Conclusion Value-type arguments enclosed in parentheses, (), are passed by value even if the procedure header declares the parameter with keyword ByRef. An identifier’s duration (also called its lifetime) is the period during which the identifier exists in memory. Identifiers that represent local variables in a procedure (i.e., parameters and variables declared in the procedure body) have automatic duration. Automatic-duration variables are created when program control enters the procedure in which they are declared, exist while the procedure is active and are destroyed when the procedure is exited.

Conclusion The scope of a variable, reference or procedure identifier is the portion of the program in which the identifier can be accessed. The possible scopes for an identifier are class scope, module scope, namespace scope and block scope.