Classic Error Handling

	Classic Error Handling

Introduction

From its early stages, Microsoft Visual Basic has always made it a priority to deal with errors. Most or early errors occur in your code. The Visual Studio IDE can help you detect syntax errors and fix them. In fact, a feature almost unique to the Visual Basic IDE, which is not available in Visual C++ and some versions of Visual C#, is that its Code Editor detects problems immediately as soon as they appear in your code. In fact, in previous versions of Visual Basic and in VBA (Microsoft Access), a message box would display, prompting you to fix the problem. This has always made Visual Basic one of the friendliest programming environments around. When you think everything is fine, compile your code. If there is a syntax error that that the IDE did not signal or that you ignored when writing your code, the compiler will let you know. If there is no syntax error, the compilation will be over and the executable will be ready. You can then execute the application to see the result. If the user is not asked to provide value(s), you are less likely to get a run-time error.

A run-time error is one that occurs when using your application. Consider the following application:

Imports System.Drawing
Imports System.Windows.Forms

Module Exercise

    Public Class Starter
        Inherits Form

        Private lblNumber As Label
        Private txtNumber As TextBox
        Friend WithEvents btnCalculate As Button
        Private lblResult As Label
        Private txtResult As TextBox

        Dim components As System.ComponentModel.Container

        Public Sub New()
            InitializeComponent()
        End Sub

        Public Sub InitializeComponent()
            Text = "Calculations"

            lblNumber = New Label
            lblNumber.Location = New Point(17, 23)
            lblNumber.Text = "Number:"
            lblNumber.AutoSize = True

            txtNumber = New TextBox
            txtNumber.Location = New Point(78, 20)
            txtNumber.Size = New Size(83, 20)

            btnCalculate = New Button
            btnCalculate.Location = New Point(78, 45)
            btnCalculate.Text = "Calculate"
            btnCalculate.Size = New Size(83, 23)

            lblResult = New Label
            lblResult.Location = New Point(17, 75)
            lblResult.Text = "Result:"
            lblResult.AutoSize = True

            txtResult = New TextBox
            txtResult.Location = New Point(76, 72)
            txtResult.Size = New Size(83, 20)

            Controls.Add(lblNumber)
            Controls.Add(txtNumber)
            Controls.Add(btnCalculate)
            Controls.Add(lblResult)
            Controls.Add(txtResult)

        End Sub

        Private Sub CalculateClicked(ByVal sender As Object, _
                                     ByVal e As EventArgs) _
                                     Handles btnCalculate.Click
            Dim Number As Double
            Dim Result As Double

            Number = CDbl(txtNumber.Text)

            Result = Number * 24
            txtResult.Text = CStr(Result)
        End Sub
    End Class

    Function Main() As Integer

        Dim frmStart As Starter = New Starter

        Application.Run(frmStart)

        Return 0
    End Function

End Module

Here is an example of executing it:

The first aspect you should take into consider is to imagine what could cause a problem. If you think there is such a possibility, start by creating a label that could be used to transfer code if a problem occurs. Here is an example:

Private Sub CalculateClicked(ByVal sender As Object, _
                                              ByVal e As EventArgs) _
                                              Handles btnCalculate.Click
        Dim Number As Double
        Dim Result As Double

            Number = CDbl(txtNumber.Text)

        Result = Number * 24
        txtResult.Text = CStr(Result)

ThereWasAProblem:
        MsgBox("There was a problem when executing your instructions")
End Sub

If you create such a label, you should tell the compiler when to jump to that label. Otherwise, as in this case, the label section would always execute. Here is an example of running the above version:

In this case, we want the label section to execute only when we want it to. To prevent the compiler from reaching this section if not directed so, you can add an Exit Sub line above the label section:

Private Sub CalculateClicked(ByVal sender As Object, _
                                     ByVal e As EventArgs) _
                                     Handles btnCalculate.Click
        Dim Number As Double
        Dim Result As Double

            Number = CDbl(txtNumber.Text)

        Result = Number * 24
        txtResult.Text = CStr(Result)

        Exit Sub

ThereWasAProblem:
        MsgBox("There was a problem when executing your instructions")
End Sub

This time if you execute the program with an appropriate value, the label section would not be reached.

In Case Of Error, Jump To Label

The above program will compile fine. When executing it, imagine that the user types an inappropriate value such as 25$.85 instead of 25.85. In this case, the value is not a number, the program would "crash" and let you know that there was a problem:

With some experience, you would know what the problem was, otherwise, you would face a vague explanation. The short story is that the compiler could not continue because, in this case, it could not multiply 25$.85 by another number.

If a problem occurs when a person is using your program, the compiler may display a nasty and insignificant message to the user who would not know what to do with it. Therefore, you can start by creating an appropriate label as introduced above. An error normally occurs in a function. Therefore, to make your code easier to read, you should create a label that shows that it is made for an error instead of being a regular label. The label should also reflect the name of the function. Here is an example:

Private Sub CalculateClicked(ByVal sender As Object, _
                                              ByVal e As EventArgs) _
                                              Handles btnCalculate.Click
        Dim Number As Double
        Dim Result As Double

        Number = CDbl(txtNumber.Text)

        Result = Number * 24
        txtResult.Text = CStr(Result)

        Exit Sub

btnOperation_Click_Error:
        MsgBox("The operation could not be executed", _
               MsgBoxStyle.OkOnly, "Operation Error")
End Sub

When you think there will be a problem in your code, somewhere in the lines under the name of the function but before the line that could cause the problem, type On Error GoTo followed by the name of the label that would deal with the error. Here is an example:

Private Sub CalculateClicked(ByVal sender As Object, _
                                              ByVal e As EventArgs) _
                                              Handles btnCalculate.Click
        On Error GoTo btnOperation_Click_Error

        Dim Number As Double
        Dim Result As Double

        Number = CDbl(txtNumber.Text)

        Result = Number * 24
        txtResult.Text = CStr(Result)

        Exit Sub

btnOperation_Click_Error:
        MsgBox("The operation could not be executed", _
               MsgBoxStyle.OkOnly, "Operation Error")
End Sub

Here is an example of running the program:

When the On Error GoTo statement is used, this indicates to the compiler that if any type of error occurs while the code of this function is executed, transfer the compilation to the label. In this case, as soon as something bad happens, the compiler marks the area where the problem occurred, skips the normal code and jumps to the label indicated by the On Error GoTo line. After the section of that label is executed, the compiler returns where the error occurred. If there is nothing to solve the problem, the compiler continues down but without executing the lines of code involved. In this case, it would encounter the Exit Sub line and get out of the function.

In Case Of Error, Jump To Line #

Although the label is more explicit, it only indicates to the compiler what line to jump to in case of a problem. The alternative is to specify a line number instead of a label.

Resume

If a problem occurs in your code and you provide a label to display a friendly message as done above, the compiler would display the message and exit from the function. If this happens, as mentioned above, when the compiler returns where the problem occurred, you can provide an alternative. For example, in our program, if the user provides an inappropriate value that causes the error, you can provide an alternate value and ask the compiler to continue as if nothing happened. In this case, you want to compiler to "resume" its activity.

To indicate that the program should continue, you can use the Resume keyword. Here is an example:

Private Sub CalculateClicked(ByVal sender As Object, _
                                              ByVal e As EventArgs) _
                                              Handles btnCalculate.Click
        On Error GoTo btnOperation_Click_Error

        Dim Number As Double
        Dim Result As Double

        Number = CDbl(txtNumber.Text)

        Resume

        Result = Number * 24
        txtResult.Text = CStr(Result)

        Exit Sub

btnOperation_Click_Error:
        MsgBox("The operation could not be executed", _
               MsgBoxStyle.OkOnly, "Operation Error")
End Sub

When an error occurs, if you want the program to continue with an alternate value than the one that caused the problem, in the label section, type Resume Next. Here is an example:

Private Sub CalculateClicked(ByVal sender As Object, _
                                              ByVal e As EventArgs) _
                                              Handles btnCalculate.Click
        On Error GoTo btnOperation_Click_Error

        Dim Number As Double
        Dim Result As Double

        Number = CDbl(txtNumber.Text)

        Result = Number * 24
        txtResult.Text = CStr(Result)

        Exit Sub

btnOperation_Click_Error:
        MsgBox("The operation could not be executed", _
               MsgBoxStyle.OkOnly, "Operation Error")
        Resume Next
End Sub

In this case, since any numeric variable is initialized with 0, when the compiler returns to the line of code that caused the problem, it would use 0 as a substitute to the inappropriate value. Based on this, you can provide a new value to use in case of error. Here is an example:

Private Sub CalculateClicked(ByVal sender As Object, _
                                              ByVal e As EventArgs) _
                                              Handles btnCalculate.Click
        On Error GoTo btnOperation_Click_Error

        Dim Number As Double
        Dim Result As Double

        Number = CDbl(txtNumber.Text)

        Result = Number * 24
        txtResult.Text = CStr(Result)

        Exit Sub

btnOperation_Click_Error:
        MsgBox("The operation could not be executed", _
               MsgBoxStyle.OkOnly, "Operation Error")

        Number = 10
        Resume Next
End Sub

Here is one example of running the program:

Here is another example of running the same program:

The Err Object

To support error handling, the Visual Basic library provides a global variable named Err. This allows you to identify the error and its description. Because an error depends on what caused it and why, the values of the Err variable also depend and are not always the same.


Previous	Copyright © 2008 FunctionX, Inc.	Home