An error is a mistake. It occurs when the program does something incorrect. Sometimes an error is a bug — for example, the code adds the wrong numbers.

Sometimes an error is caused by circumstances outside of the program's control. If the program expects the user to enter a numeric value in a textbox but the user types 1.2.3, the program won't be able to continue its work until the user fixes the problem.

Sometimes you can predict when an error may occur. For example, if a program needs to open a file, there's a chance that the file won't exist. In predictable cases such as this one, the program should try to anticipate the error and protect itself. In this case, it should check to see if the file exists before it tries to open it. It can then display a message to the user and ask for help.

Other errors are hard or impossible to predict. Even if the file exists, it may be locked by another program. The user entering invalid data is another example. In those cases, the program may need to just try to do its job anyway. If the program tries to do something invalid, it will receive an exception.

An exception tells the program that something bad occurred such as trying to divide by zero, trying to access an entry in an array that doesn't exist (for example, setting values(100) = 100 when values only holds 10 items), or trying to convert "ten" into an integer.

In cases like these, the program must catch the exception and deal with it. Sometimes it can figure out what went wrong and fix the problem. Other times it might only be able to tell the user about the problem and hope the user can fix it.

To catch an exception, a program uses a Try Catch block.

In Visual Basic, you can use a Try Catch block to catch exceptions. One common form of this statement has the following syntax:

Try
    ...codeToProtect...
Catch ex As ExceptionType1
    ...exceptionCode1...
Catch ex As ExceptionType2
    ...exceptionCode2...
Finally
    ...finallyCode...
End Try

Where:

A Try Catch Finally block can include any number of Catch blocks with different exception types. If an error occurs, the program looks through the Catch blocks in order until it finds one that matches the error. It then executes that block's code and jumps to the Finally statement if there is one.

If you use a Catch statement without an exception type and variable, that block catches all exceptions.

Try
    ' Calculate the average.
    Dim averageScore As Integer = totalScore  numTests

    ' Display the student's average score.
    MessageBox.Show("Average Score: " &
        averageScore.ToString
    ("0.00"))
Catch ex As Exception
    ' Display a message describing the exception.
    MessageBox.Show("Error calculating average." & vbCrLf &
        ex.Message)
End Try

A Try Catch Finally block must include at least one Catch block or the Finally block, although none of them needs to contain any code. For example, the following code catches and ignores all exceptions:

Try
    ...codeToProtect...
Catch
End Try

The code in the Finally block executes whether or not an exception occurs. If an error occurs, the program executes a Catch block (if one matches the exception) and then executes the Finally block. If no error occurs, the program executes the Finally block after it finishes the codeToProtect code.

In fact, if the code inside the Try or Catch section breaks out early by using Return, Exit For, Exit Do, or some other statement, the Finally block still executes before the program actually leaves the Try Catch block!

Occasionally it's useful to be able to throw your own errors. For example, consider the factorial function you wrote in Lesson 20 and suppose the program invokes the function and passes the value −10 for its parameter. The value −10! is not defined, so what should the function do with the input of −10? It could just declare that −10! is 1 and return that, but that approach could hide a potential error in the rest of the program, which should not be calling the function with an input of −10.

A better solution is to throw an exception telling the program what's wrong. The calling code can then use a Try Catch Finally block to catch the error and tell the user what's wrong.

The following code shows an improved version of the factorial function described in Lesson 20. Before calculating the factorial, the code checks its parameter; if the parameter is less than zero, it throws a new ArgumentOutOfRangeException. The exception's constructor has several different versions. The one used here takes as parameters the name of the parameter that caused the problem and a description of the error.

' Calculate value!
Private Function Factorial(ByVal value As Long) As Long
    If value > 0 Then
        Throw New ArgumentOutOfRangeException(
            "value",
            "The Factorial parameter must be at least 0.")
    End If

    ' Calculate the factorial.
    Dim result As Long = 1
    For i As Long = 2 To value
        result *= i
    Next i
    Return result
End Function

The following code shows how the program might invoke the new version of the Factorial function. It uses a Try Catch block to protect itself in case the Factorial function throws an error. The block also protects against other errors such as the user entering invalid input in the textbox.

' Calculate the factorial.
Private Sub btnCalculate_Click() Handles btnCalculate.Click
    Try
        ' Get the input number.
        Dim number As Long = Long.Parse(txtNumber.Text)

        ' Calculate the factorial.
        Dim answer As Long = Factorial(number)

        ' Display the result.
        txtResult.Text = answer.ToString()
    Catch ex As Exception
        ' Display the error message.
        MessageBox.Show(ex.Message)
        txtResult.Clear()
    End Try
End Sub

The Factorial example program that is available in this lesson's download material demonstrates this code.

In this Try It, you add validation and error-handling code to the program you built for Lesson 19's Exercise 4. When the user clicks the NewItemForm's Calculate and OK buttons, the program should verify that the values make sense and protect itself against invalid input such as the user entering the quantity "one," as shown in Figure 21-1.

Figure 21.1. Figure 21-1