2

IntroductionMajor Error Types

Syntax errors Run time errors Logical Errors

Debugging Debugging using Breakingpoints Debugging using Watchs Debugging using Locals

Error handlingTry … Catch in VB .NETUsing Structured Error Handling

3

Bug is to mean an error. Debug is the process of removing errors from a program

Debugging is an essential part of any development project, as it helps you find errors in your code and in your logic.

Unless you write perfect code every time, there's no getting away from debugging.

However, no matter how good your code is, there are always going to be some unexpected circumstances that will cause your code to fail.

If you do not anticipate and handle errors, your users will see a default error message about an unhandled exception, which is provided by the common language run - time package. Default error message is not user-friendly it does not clearly inform

users About what is going on How to correct it

Visual Studio 2008 has a sophisticated debugger built right into the development environment. It also provides common structured error - handling functions that are used across all languages.

4

Error types can be broken down into three major categories: syntax (design time), execution, and logic.

Syntax errorsThese occur when the environment you're programming in

doesn't understand your code. These are easy to track down in VB.NET, because you get a blue wiggly line pointing them out. If you try to run the programme, you'll get a dialogue box popping up telling you that there were Build errors.

Runtime errors Are those which occur when the program is running. They are

harder to track down. Example

Trying to access a file that doesn't exist. Runtime errors usually cause your programme to crash. If and when that happens, you get the blame. After all, you're the programmer, and you should write code to trap runtime errors.

If you're trying to open a database in a specific location, and the database has been moved, a Runtime error will occur. It's your job to predict a thing like this, and code accordingly.

5

Logic errors Are those which cause your code behave in

different way than you thought it would. These errors also occur when the program is running.

A classic example is creating an infinite loop of the type "Do While x is greater than 10".

If x is always going to be greater than 10, then the loop has no way to exit, and just keeps going round and round.

Logic errors tend not to crash your program. But they will ensure that it doesn't work properly.

6

VB.net 2008 provides two ways to correct errors in a given program.1. Instant syntax checking of variables and objects2. Error List windowInstant syntax checking of variables and objects and lets you

know immediately when you have a syntax error. Visual Studio 2008 underlines syntax errors with a blue wavy

line. If the IDE can automatically correct the syntax error, you’ll see

a little gray rectangular box at the end of the blue wavy line.When you hover (move) your mouse over the code in

error, you ’ ll receive a tooltip, telling you what the error is, and a small gray box with a red circle and a white exclamation point.

If you move your mouse into the gray box, a down arrow appears to let you know that a dialog box is available with some suggested error correction options.

7

Clicking the down arrow or pressing Shift+Alt+F10 causes the Error Correction Options dialog box to appear as shown in the figures below.

This dialog box presents one or more choices to you for correcting the error. In this instances, three and one choice(s) to correct the syntax error as shown in the dialog boxes below.

Note that the dialog box shows you how your code can be corrected:

8

Another option available for reviewing all the errors in your code is the Error List window.

This window displays a grid with all the errors ’ descriptions, the files they exist in, and the line numbers and column numbers of the error.

If your solution contains multiple projects, it also displays the project that each error exists in.

The Error List can be accessed by clicking the Error List tab at the bottom of the IDE if it is already displayed in the IDE or by clicking the View Error List menu item.

When the Error List window is displayed, you can double - click any error to be taken to that specific error in your code.

9

The IDE also provides IntelliSense to assist in preventing syntax errors.

IntelliSense provides a host of features such as providing a drop - down list of members for classes, structures, and namespaces.

IntelliSense initially displays a list of all members for the object being worked with, and as soon as you start typing one or more letters the list of members is shortened to match the letters that you have typed

These IntelliSense features provide two major benefits.First, you do not have to remember all the available members for the

class. You simply scroll through the list to find the member that you want to work with or you type the first letter or two of the member to have the list of members reduced to the relevant members.

Second, the features help you prevent syntax errors because you are less likely to misspell member names or try to use members that do not exist in the given class.

Another great feature of IntelliSense is that it provides a parameter list for the method that you are working with. IntelliSense lists the number, names, and types of the parameters required by the function.

10

Developers need to anticipate the possibility of execution errors and build appropriate error – handling logic.

Implementing the appropriate error handling does not prevent execution errors, but does allow you to handle them either by gracefully shutting down your application or bypassing the code that failed and giving the user the opportunity to perform that action again.

The best way to prevent execution errors is to try anticipating the error before it occurs and to use error handling to trap and handle the error. You must also thoroughly test your code before deploying it.

Dim Num1, Num2 As IntegerNum1 = 10Num2 = 0TextBox1.Text = CInt(Num1 / Num2)

11

Run the program and the following error will appear

Dim Num1, Num2 As IntegerNum1 = 10Num2 = 0If Num2<> 0 then TextBox1.Text = CInt(Num1 / Num2)Else msgBox(“duniminetetor is zero“)End If

12

Logic errors (or semantic errors ) give unexpected or unwanted results because you did not fully understand what the code you were writing did.

Private Sub PerformLoopExample()Dim intIndex As IntegerDo While intIndex < 10...perform some logicLoopEnd Sub

If the code inside the loop does not set intIndex to 10 or above, this loop just keeps going forever.

Logic errors can be the most difficult to find and troubleshoot, because it is very difficult to be sure that your program is completely free from logic errors.

13

Dim x As IntegerDim y As IntegerDim answer As Integerx = 10.5y = 3answer = x * yTextBox1.Text = answer What will happen if you run the above code fragment? You'd think that 10.5 multiplied by 3 would give you the answer 31.5.

Click your button. The answer that appears in your textbox is 30! This is a logic error: when you don't get the answer you thought

you'd get. The problem, if you were paying attention during the variable types sections, is that we are trying to put floating point numbers into an Integer variable type. The Integer variable only works with whole numbers. When you assign 10.5 to the variable x, the point 5 on the end gets chopped off. So only the 10 gets stored in x. 10 times 3 is thirty, and this is the answer that appears in the textbox.

But the point is that VB.NET did not raise a Design-time error. Nor did it raise a Runtime error. The programme executed, and did not "bug out" on us. It just didn't give you the answer you expected - it was a logic error.

14

Dim i As IntegerDim LetterCount As IntegerDim strText As StringDim letter As CharstrText = "Debugging"For i = 1 To strText.Length – 1 letter = strText.Substring(1)If letter = "g" Then LetterCount = LetterCount + 1End IfNextTextBox1.Text = "G appears " & LetterCount & " times" All the code does is to try and count how many times the letter "g"

appears in the word "Debugging". We're using a For loop, and Substring to get one letter at a time. This single letter is then placed inside the variable called letter. An If Statement is used to check if the letter is a "g". If it is, we increment the LetterCount variable. The answer we're expecting in the textbox is 3. Except, we don't get 3. We get zero:

There were no wiggly lines and therefore no Build errors. When the button was clicked, a Runtime exception did not crash the programme. So that leaves a logic error. But where is it?

15

There were no wiggly lines and therefore no Build errors. When the button was clicked, a Runtime exception did not crash the programme. So that leaves a logic error. But where is it?

To help you find out what went wrong, there is three tools in VB .NET namely Breakpoint, Watch Window and Locals window.

BreakpointThis allows you to set breakpoints, which temporarily halt the

program when the program executes the line with the breakpoint.

Halting your code with breakpoints and stepping through code allows you to see where the program may be having problems and also lets you check the values of the data the program is using while it executes.

To begin stepping through the code, press F11, and select the Step Into command from the Debug menu, or the Step Into button on the Debug toolbar.

You can also press F10 or use the Step Over command. Both allow you to step through your code one line at a time, pressing F10 or F11 to proceed with the next line.

The difference between the two is that Step Into steps into a function call, whereas Step Over executes a function at its call, but does not step into its code.

16

Most of the time, stepping through the program in its entirety is very impractical because of the program's size.

Setting a breakpoint somewhere in the code allows the program to run normally until the breakpoint is reached.

This allows you to examine the data, check the logic, and so on, and then either continue execution by pressing F5 (or Start) again, or step through the code (F10 or F11).

To insert a breakpoint, place the cursor on the line of code where you want to break

the execution and press F9. You can also click on the margin to the left of your

code. If you want to remove a breakpoint, place the

cursor on the line with the breakpoint you want to remove and press F9 again, or click on the breakpoint symbol you want to remove.

17

You can display the Breakpoints window, if the tab is not shown, in the bottom - right of the IDE by clicking the Breakpoints icon on the Debug toolbar or by selecting Debug Windows Breakpoints.

The Breakpoints window shows what line of code the current breakpoint is at, any conditions it has, and the hit count if applicable.

You will also notice that each breakpoint listed in the window has a checkbox beside it. These give the option of activating or deactivating any breakpoint without actually having to physically remove the breakpoint from the code view pane.

Some more advanced features are also available. Select any one of the breakpoints in the Breakpoints window and right click on it. Here you can set a condition for the breakpoint.

Click the Condition button and you will see the dialog box. In this dialog box, we can specify any Boolean condition to determine

whether the breakpoint should be enabled or disabled. If you click the Hit Count button from the Breakpoint

properties dialog box, you can specify how many times the breakpoint must be hit before it is automatically enabled.That is The Breakpoint Hit Count dialog box allows you to define the

number of executions of a loop should be performed before the IDE stops execution of your code and puts it into break mode.

Watches provide us with a mechanism where we can interact with the actual data that is stored in our programs at runtime.

They allow us to see the values of variables and the values of properties on objects. In addition to being able to view these values, you can also assign new values.

This can be very handy while stepping through your code because you can see what would happen if a variable had a different value at a specific point in time.

In order to use the Watch window, the application must be in break mode.

Lets develop a simple application which takes two numbers from a user and calculates the sum, difference, product and quotients of the numbers.

Add two text boxes and a button on form you get by launching a new project.

Double click the button and add the following code1. Dim fn, sn, sum, prod As Integer2. Dim output As String3. fn = Val(txtfn.Text)4. sn = Val(txtsn.Text)5. sum = fn + sn6. prod = fn * sn7. output = "Sum = " + sum.ToString + vbCrLf +

"Product = " + prod.ToString8. MsgBox(output) Add breakpoint at line 7 and run the application

and click on the button

To display the quickWatch window, make you application in break mode, then click debug menu---QuickWatch

Place(click) the cursor on one of the variables (for example sum) and choose debug Quickwatch…

A QuickWatch window will appear showing the variables name, value and type.

You can watch the values and types of variables by typing the variable name at the expression text box and click Reevalute button.To see more than one variables’ values and type at the same time you can use watch window. Click Add Watch from QuickWatch window or choose Debug window watch while your application is running

The Locals window is similar to the Watch window, except that it shows all variables and objects for the current function or procedure.

The Locals window also lets you change the value of a variable or object. The text for a value that has just changed also turns red, making it easy to spot the variable or object that has just changed.

The Locals window is great if you want a quick glance at everything that is going on in a function or procedure, but it is not very useful for watching the values of one or two variables or expressions.

The reason for this is that the Locals window contains all variables and objects in a procedure or function- you have to scroll through the window constantly to view the various variables and objects.

Open Locals window by clicking debug menu--- windows ---- Locals (recall that your application must be in break mode)

22

Error handling is an essential part of any good code.In Visual Basic 2008 the error mechanism is based

on the concept of exceptions that can be thrown to raise an error and caught when the error is handled.

If you do not provide any type of error handling and an error occurs, your user receives a message about an unhandled exception, which is provided by the CLR (Common Language Runtime ), and then the program may terminate, depending on the type of error encountered.

This is not a user - friendly message and does not inform the user about the true nature of the error or how to resolve it.

The unhandled error could also cause users to lose the data that they were working with or leave the user and the data in an unknown state.

23

Visual Studio 2008 provides structured error - handling statements that are common across all languages.

Structured error handling is a way to organize blocks of code in a structure that handles errors.

Structured error handling in Visual Studio 2008 is incorporated with the Try . . . Catch . . . Finally block.

You execute the code that might throw an exception in the Try block, and you handle anticipated errors in the Catch block.

The Finally block, which is optional, is always executed, if present, and allows you to place any cleanup code there regardless of whether an error has occurred.

Therefore, it is important to try to anticipate all possible errors for the code that is contained in the Try block.

24

Try . . . Catch . . . Finally statement has the following syntax.

Try[try statements][Exit Try]

Catch exceptionvariable As exceptiontype[catch statements][Exit Try]

[Additional Catch blocks]Finally

[finally statements]End Try

WhereThe try statements are the statements to be

executed that may cause an error.

25

The exceptionvariable can be any variable name. It will be set to contain the value of the error that is thrown.

The exceptiontype specifies the exception class type that the exception belongs to. If this type is not supplied, your Catch block handles any exception defined in the System.Exception class. This argument allows you to specify the type of exception that you maybe looking for. An example of a specific exception is IOException , which is used when performing any type of IO (input/output) against a file.

The catch statements handle and process the error that has occurred.

The finally statements are executed after all other processing has occurred.

The optional Exit Try statement allows you to completely break out of a Try . . . Catch . . . Finally block and resume execution of code immediately following the Try . . . Catch . . . Finally block.

26

You can have multiple Catch blocks, meaning that you can test for multiple errors with different exception types within the same Try block.

When an error occurs among the try statements, control is passed to the appropriate Catch block for processing.

When you define a Catch block, you can specify a variable name for the exception and define the type of exception you want to catch.Example

Catch IOExceptionErr As IOException...code to handle the exception goes here...

27

lstData.Items.Add(“String variable data:”)Try

If strData.Length > 0 ThenlstData.Items.Add(strData)

End IfCatch nre As NullReferenceException

strData = “String now initialized”lstData.Items.Add(strData)

End Try The error that you want to trap is a NullReferenceException , and that

exception is specified in the Catch block. When a NullReferenceException occurs, strData variable is initialized to

a string constant and then added the contents of that variable to the list box on your form.

What happened if the following code fragment is executed? OverFlowException is thrown.

Tryquot = fn / sn

Catch divisionbyzero As Exception MsgBox(" Division by zero") End Try

By providing a catch block without a brackets or arguments, we can catch all exceptions occurred inside a try block.

Even we can use a catch block with an Exception type parameter to catch all exceptions happened inside the try block since in VB.NET, all exceptions are directly or indirectly inherited from the Exception class.

Class MyClient Public Shared Sub Main() Dim x As Integer = 0 Dim div As Integer = 0 Try div = 100 / x

msgBox("Not executed line") Catch //Catch e As Exception then in new line msgbox(“ ….”) End Try msgBox("("Result is {0}", div) End Sub 'MainEnd Class 'MyClient

29

There are two types of exceptions: Exceptions generated by an executing program and Exceptions generated by the common language runtime.

System.Exception is the base class for all exceptions in VB.NET.

Several exception classes inherit from this class including ApplicationException and SystemException.

These two classes form the basis for most other runtime exceptions.

Other exceptions that derive directly from System.Exception include IOException, WebException etc.

The common language runtime throws SystemException. A user program rather than the runtime throws the

ApplicationException. The SystemException includes the

ExecutionEngineException, StackOverFlowException etc.

30

It is not recommended that we catch SystemExceptions nor is it good programming practice to throw SystemExceptions in our applications.

System.NullReferenceException Syste.InvalidCastException Syste.ArrayTypeMismatchException System.IndexOutOfRangeException System.ArithmeticException System.DevideByZeroException System.OverFlowException