Debugging refers to the process of trying to track down errors in your programmes.
It can also refer to handling potential errors that may occur. There are three
types of errors that we'll take a look at:
Design-Time errors are easy enough to spot because the C# software will underline them with a wavy coloured line. You'll see three different coloured lines: blue, red and green. The blue wavy lines are known as Edit and Continue issues, meaning that you can make change to your code without having to stop the programme altogether. Red wavy lines are Syntax errors, such as a missing semicolon at the end of a line, or a missing curly bracket in an IF Statement. Green wavy lines are Compiler Warnings. You get these when C# spots something that could potentially cause a problem, such as declaring a variable that's never used.
This is an Edit and Continue error. It's been flagged because the form doesn't
have a control called textBox2 - it's called textBox1. We can simply delete
the 2 and replace it with a 1. The programme can then run successfully. Holding
your mouse over the wavy underline gives an explanation of the error. Some of
these explanations are not terribly helpful, however!
In the code below, we've missed out the semicolon at the end of the line:
Holding the mouse pointer over the red wavy line gives the following message:
It's telling us that a semicolon ( ; ) is expected where the red wavy underline
is.
In the next image, we've missed out a round bracket for the IF Statement:
Holding the mouse pointer over the green underlines gives the following message:
C# is flagging this because we have set aside some memory for the variable,
but we're not doing anything with it.
This one is easy enough to solve, but some Compiler Errors can be a bit of a nuisance, and the messages not nearly as helpful as the one above!
Whatever the colour of the underline, though, the point to bear in mind is this: C# thinks it has spotted an error in your code. It's up to you to correct it!
The programme itself reports no problems when it is started up, and there's
no coloured wavy lines. When we click the button, however, we get the following
error message (Visual Studio 2012 will have a plainer error message):
Had we left this in a real programme, it would just crash altogether ("bug
out"). But if you see any error message like this one, it's usually a Run-Time
error. Here's another one. In the code below, we're trying to open a file that
doesn't exist:
As the message explains, it can't find the file called "C:/test10.txt".
Because we didn't tell C# what to do if there was no such file, it just crashes.
Look out for these type of error messages. It does take a bit of experience to work out what they mean; but some, like the one above, are quite straightforward.
Logical error
When the code is run, however, it gives an answer of zero. The programme runs
OK, and didn't produce any error message or wavy lines. It's just not the correct
answer!
The problem is that we've made an error in our logic. The startLoop variable should be 1 and the endLoop variable 11. We've got it the other way round, in the code. So the loop never executes.
Logic errors can be very difficult to track down. To help you find where the problem is, C# has some very useful tools you can use. To demonstrate these tools, here's a new programming problem. We're trying to write a programme that counts how many times the letter "g" appears in the word "debugging".
Start a new C# Windows Application. Add a button and a textbox to your form. Double click the button, and then add the following code:
The answer should, of course, be 3. Our programme insists, however, that the
answer is zero. It's telling us that there aren't and g's in Debugging. So we
have made a logic error, but where?
C# .NET has some tools to help you track down errors like this. The first one we'll look at is called the BreakPoint.
In the image above, we clicked in the margins, just to the left of line 21.
A reddish circle appears. Notice too that the code on the line itself gets highlighted.
To see what a breakpoint does, run your programme and then click your button. C# will display your code:
There will be a yellow arrow on top of your red circle, and the line of code
will now be highlighted in yellow. (If you want to enable line numbers in your
own code, click Tools > Options from the C# menus at the top. On the
Options box, click the plus symbol next to Text Editor, then C#.
Click on General. On the right hand side, check the box for Line Numbers,
under the Display heading.)
Press F10 on your keyboard and the yellow arrow will jump down one line. Keep pressing F10 until line 28 in your code is highlighted in yellow, as in the image below:
Move your mouse pointer over the letter variable and C# will show you
what is currently in this variable:
Now hold your mouse over strText to see what is in this variable:
Although we haven't yet mentioned anything about the Substring method, what
it does is to grab characters from text. The first 1 in between the round brackets
means start at letter 1 in the text; the second 1 means grab 1 character. Starting
at letter 1, and grabbing 1 character from the word Debugging, will get you
the letter "D". At least, that's what we hoped would happen!
Unfortunately, it's grabbing the letter "e", and not the letter "D". The problem is that the Substring method starts counting from zero, and not 1.
Halt your programme and return to the code. Change your Substring line to this:
This time, the correct letter is in the variable. Halt your programme again.
Click your Breakpoint and it will disappear. Run the programme once more and
it will run as it should, without breaking.
So have we solved the problem? Is the programme counting the letter g's correctly?
No! The letter count is still zero! So where's the error? To help you track it down, there's another tool you can use - the Locals Window.
- Design-time errors
- Run-Time errors
- Logical errors
Errors at Design-Time
Design-Time errors are ones that you make before the programme even runs. In fact, for Design-Time errors, the programme won't run at all, most of the time. You'll get a popup message telling you that there were build errors, and asking would you like to continue.Design-Time errors are easy enough to spot because the C# software will underline them with a wavy coloured line. You'll see three different coloured lines: blue, red and green. The blue wavy lines are known as Edit and Continue issues, meaning that you can make change to your code without having to stop the programme altogether. Red wavy lines are Syntax errors, such as a missing semicolon at the end of a line, or a missing curly bracket in an IF Statement. Green wavy lines are Compiler Warnings. You get these when C# spots something that could potentially cause a problem, such as declaring a variable that's never used.
Blue Wavy Lines
In the image below, you can see that there's a blue wavy line under textBox2 (later versions of Visual Studio may have red wavy lines, instead of blue ones):Red Wavy Lines
These are Syntax errors. (Syntax is the "grammar" of a programming language, all those curly brackets and semicolons. Think of a Syntax error as the equivalent of programming spelling mistake.)In the code below, we've missed out the semicolon at the end of the line:
In the next image, we've missed out a round bracket for the IF Statement:
Green Wavy Lines
These are Compiler Warnings, the C# way of alerting you to potential problems. As an example, here's some code that has a green wavy underline:This one is easy enough to solve, but some Compiler Errors can be a bit of a nuisance, and the messages not nearly as helpful as the one above!
Whatever the colour of the underline, though, the point to bear in mind is this: C# thinks it has spotted an error in your code. It's up to you to correct it!
Run Time Errors in C# .NET
Run-Time errors are ones that crash your programme. The programme itself generally starts up OK. It's when you try to do something that the error surfaces. A common Run-Time error is trying to divide by zero. In the code below, we're trying to do just that:Look out for these type of error messages. It does take a bit of experience to work out what they mean; but some, like the one above, are quite straightforward.
Logical error
Logic errors are ones where you don't get the result you were
expecting. You won't see any coloured wavy lines, and the programme generally
won't "bug out" on you. In other words, you've made an error in your
programming logic. As an example, take a look at the following code, which is
attempting to add up the numbers one to ten:
The problem is that we've made an error in our logic. The startLoop variable should be 1 and the endLoop variable 11. We've got it the other way round, in the code. So the loop never executes.
Logic errors can be very difficult to track down. To help you find where the problem is, C# has some very useful tools you can use. To demonstrate these tools, here's a new programming problem. We're trying to write a programme that counts how many times the letter "g" appears in the word "debugging".
Start a new C# Windows Application. Add a button and a textbox to your form. Double click the button, and then add the following code:
C# .NET has some tools to help you track down errors like this. The first one we'll look at is called the BreakPoint.
Breakpoints in C# .NET
The first debugging tool we'll look at is the Breakpoint. This
is where you tell C# to halt your code, so that you can examine what is in your
variables. They are easy enough to add.
To add a Breakpoint, all you need to do is to click in the margins to the left
of a line of code:To see what a breakpoint does, run your programme and then click your button. C# will display your code:
Press F10 on your keyboard and the yellow arrow will jump down one line. Keep pressing F10 until line 28 in your code is highlighted in yellow, as in the image below:
Unfortunately, it's grabbing the letter "e", and not the letter "D". The problem is that the Substring method starts counting from zero, and not 1.
Halt your programme and return to the code. Change your Substring line to this:
letter = strText.Substring(0, 1);
So type a zero as the first number of Substring instead of a 1. Now run your
code again:So have we solved the problem? Is the programme counting the letter g's correctly?
No! The letter count is still zero! So where's the error? To help you track it down, there's another tool you can use - the Locals Window.
0 comments:
Post a Comment