DEBUGGING FEATURESOF VISUAL STUDIO

1. LITERATURE SURVEY

1.1 INTRODUCTION
In the software development life cycle, testing and defect fixing take more time than
actually code writing. In general, debugging is a process of finding out defects in the program
and fixing them. Defect fixing comes after the debugging, or you can say they are co-related.
When you have some defects in your code, first of all you need to identify the root cause of
the defect, which is called the debugging. When you have the root cause, you can fix the
defect to make the program behaviour as expected.
How to debug the code? Visual Studio IDE gives us a lot of tools to debug our
application. Sometimes debugging activity takes a very long time to identify the root cause.
But VS IDE provides a lot of handy tools which help to debug code in a better way.
Debugger features include error listing, adding breakpoints, visualize the program flow,
control the flow of execution, data tips, watch variables and many more. Many of them are
very common for many developers and many are not. In this article, I have discussed all the
important features of VS IDE for debugging like Breakpoint, labelling and saving
breakpoints, putting conditions and filter on breakpoints, DataTips, Watch windows,
Multithreaded debugging, Thread window, overview of parallel debugging and overview of
IntelliTrace Debugging. I hope this will be very helpful for beginners to start up with and for
becoming an expert on debugging. Please note, targeted Visual Studio version is Visual
Studio 2010. Many things are common in older versions, but many features such as Labelling
breakpoint, Pinned DataTip, Multithreaded Debugging, Parallel debugging and IntelliTrace
are added in VS 2010.

1.2 History
Visual Studio 2008 features include an XAML-based designer (codenamed Cider),
workflow designer, LINQ to SQL designer (for defining the type mappings and object
encapsulation for SQL Server data), XSLT debugger, JavaScript Intellisense support,
JavaScript Debugging support, support for UAC manifests, a concurrent build system, among
others. It ships with an enhanced set of UI widgets, both for Windows Forms and WPF. It
also includes a multithreaded build engine (MS Build) to compile multiple source files (and
build the executable file) in a project across multiple threads simultaneously. It also includes
support for compiling PNG compressed icon resources introduced in Windows Vista. An
updated XML Schema designer will ship separately sometime after the release of Visual
Studio 2008.
The Visual Studio debugger includes features targeting easier debugging of multi-
threaded applications. In debugging mode, in the Threads window, which lists all the threads,
hovering over a thread will display the stack trace of that thread in tooltips. The threads can
directly be named and flagged for easier identification from that window itself. In addition, in
the code window, along with indicating the location of the currently executing instruction in
the current thread, the currently executing instructions in other threads are also pointed out.
[82][83] The Visual Studio debugger supports integrated debugging of the .NET 3.5
Framework Base Class Library (BCL) which can dynamically download the BCL source

1
DEBUGGING FEATURESOF VISUAL STUDIO

code and debug symbols and allow stepping into the BCL source during debugging.[84] As
of 2010 a limited subset of the BCL source is available, with more library support planned for
later.

Visual Studio 2010 includes tools for debugging parallel applications. The new tools
allow the visualization of parallel Tasks and their runtime stacks.[92] Tools for profiling
parallel applications can be used for visualization of thread wait-times and thread migrations
across processor cores.[93] Intel and Microsoft have jointly pledged support for a new
Concurrency Runtime in Visual Studio 2010[94] and Intel has launched parallelism support
in Parallel Studio as an add-on for Visual Studio.[95]
Visual Studio Ultimate 2010 also includes a Historical Debugger for managed
code called IntelliTrace. Unlike the current debugger, that records only the currently-active
stack, IntelliTrace records all events like prior function calls, method parameters, events,
exceptions etc. This allows the code execution to be rewound in case a breakpoint wasn't set
where the error occurred. IntelliTrace will cause the application to run slower than the current
debugger, and will use more memory as additional data needs to be recorded. Microsoft
allows configuration of how much data should be recorded, in effect allowing developers to
balance speed of execution and resource usage. 

2. How to Start

To start debugging from the Debug menu of VS IDE, From the Debug Menu, select "Start
Debugging" or just press F5 to start the program. If you have placed breakpoints in your
code, then execution will begin automatically.

Start Debugging

3. Breakpoints

Breakpoint is used to notify debugger where and when to pause the execution of program.
We can put a breakpoint in code by clicking on the side bar of code or by just pressing F9 at
the front of the line. So before keeping a breakpoint, we should know what is going wrong in
our code and where it has to be stopped. When the debugger reaches the breakpoint, we can
check out what's going wrong within the code by using a different debugging tool.

2
DEBUGGING FEATURESOF VISUAL STUDIO

Set Breakpoint

4. Debugging with Breakpoints

We have already set a breakpoint in our code where we want to pause the execution. And
now start the program by pressing "F5". When the program reaches the breakpoint,
execution will automatically pause. Now we have several options to check our code. After
hitting the breakpoint, breakpoint line will show as yellow colour which indicates that this is
the line which will execute next.

Now you have several commands available in break mode, using which you can proceed for
further debugging.

Breakpoint Toolbar

5. Step Over

After debugger hits the breakpoint, you may need to execute the code line by line. "Step
Over" [F10] command is used to execute the code line by line. This will execute the
currently highlighted line and then pause. If you select F10 while a method call statement is
highlighted, the execution will stop after the next line of the calling statement. Step Over will
execute the entire method at a time.

Step Over - F10

3
DEBUGGING FEATURESOF VISUAL STUDIO

6. Step Into
This is similar to Step Over. The only difference is, if the current highlighted section is any methods
call, the debugger will go inside the method. Shortcut key for Step Into is "F11".

Step Into - F11

7. Step Out

This is related when you are debugging inside a method. If you press the Shift - F11 within
the current method, then the execution will complete the execution of the method and will
pause at the next statement from where it called.

8. Continue

It's like run your application again. It will continue the program flow unless it reaches the
next breakpoint. The shortcut key for continue is "F5".

4
DEBUGGING FEATURESOF VISUAL STUDIO

9. Set Next Statement

This is quite an interesting feature. Set Next Statement allows you to change the path of
execution of program while debugging. If your program paused in a particular line and you
want to change the execution path, go to the particular line, Right click on the line and
select "Set Next Statement" from the context menu. You will see, execution comes to that
line without executing the previous lines of code. This is quite useful when you found some
line of code may causing breaking your application and you don’t want to break at that time.
Shortcut key for Set Next Statement is Ctrl + Shift + F10.

Set Next Statement

10. Show Next Statement [ Ctrl+* ]

This line is marked as a yellow arrow. These lines indicate that it will be executed next when
we continue the program.

11. Labeling in Break Point

This is the new feature in VS 2010. This is used for better managing breakpoints. It enables
us to better group and filter breakpoints. It's kind of categorization of breakpoints. If you are
having different types of breakpoints which are related with a particular functionality, you
5
DEBUGGING FEATURESOF VISUAL STUDIO

can give their name and can enable, disable, filter based on the requirements. To understand
the whole functionality, let's assume that you have the below code block which you want to
debug.

class Program
{
static void Main(string[] args)
{
string[] strNames = { "Name1", "Name2", "Name3", "Name4", "Name5", "Name6" };

foreach (string name in strNames)

{
Console.WriteLine(name); // BreakPoint
}
int temp = 4;
for (int i = 1; i <= 10; i++)
{
if (i > 6)
temp = 5;
}
}

public static void Method1()

{
Console.WriteLine("Break Point in Method1"); // BreakPoint
}

public static void Method2()

{
Console.WriteLine("Break Point in Method2"); // BreakPoint
Console.WriteLine("Break Point in Method2"); // BreakPoint
}

public static void Method3()

{
Console.WriteLine("Break Point in Method3"); // Breakpoint
}
}

If you run the program, execution will pause on the first breakpoint. Now see the below
picture, where you have the list of breakpoints.

6
DEBUGGING FEATURESOF VISUAL STUDIO

Breakpoint List

In the given picture label column in blank. Now, see how you can set the label on break point
and what is the use of it. To set label for any breakpoint, you just need to right click on the
breakpoint symbol on the particular line or you can set it directly from breakpoint window.

Setting Breakpoint Label

Right Click on Breakpoint, Click on the Edit Labels link, you can add the label for each and
every breakpoints. As per the sample code, I have given very simple understandable names
for all the breakpoints.

7
DEBUGGING FEATURESOF VISUAL STUDIO

Adding Breakpoint Label

Let's have a look at how this labeling helps us during debugging. At this time, all the break
points are enabled. Now if you don’t want to debug the method2, in a general case you need
to go to the particular method and need to disable the breakpoints one by one, here you can
filter/search them by label name and can disable easily by selecting them together.

Filter Breakpoint Using Labels

This is all about the Breakpoint labeling. The example I have shown to you is very basic, but
it is very much useful when you have huge lines of code, multiple projects, etc.

8
DEBUGGING FEATURESOF VISUAL STUDIO

12. Conditional Breakpoint

Suppose you are iterating through a large amount of data and you want to debug a few of
them. It means you want to pause your program on some specific condition. Visual Studio
Breakpoints allow you to put conditional breakpoint. So if and only if that condition is
satisfied, the debugger will pause the execution.

To do this, first of all you need to put the breakpoint on a particular line where you want to
pause execution. Then just "Right Click" on the "Red" breakpoint icon. From there you just
click on "Condition" .

Set Breakpoint Condition

By clicking on the "Condition" link from context menu, the below screen will come where
you can set the condition for breakpoints.

Breakpoint Condition Settings

9
DEBUGGING FEATURESOF VISUAL STUDIO

Let's assume that you have the following code block:

class Program
{
static void Main(string[] args)
{
string [] strNames = { "Name1","Name2", "Name3", "Name4", "Name5", "Name6"};

foreach(string name in strNames)

{
Console.WriteLine(name); // Breakpoint is here
}
}
}

You have a breakpoint on Console.WriteLine() statement. On running of the program,

execution will stop every time inside that for-each statement. Now if you want your code to
break only when name="Name3". What needs to be done? This is very simple, you need to
give the condition like name.Equals("Name3").

Set Breakpoint Condition

Check the Breakpoint Symbol. It should look like a plus (+) symbol inside the breakpoint
circle which indicates the conditional breakpoints.

Conditional Breakpoint Symbol

After setup of the condition of your breakpoint, if you run the application to debug it, you
will see execution of program is only paused when it satisfied the given condition with
breakpoint. In this case when name="Name3".

10
DEBUGGING FEATURESOF VISUAL STUDIO

Conditional Breakpoint hit

Intellisense In Condition Text Box: The breakpoint condition which I have demonstrated

here is very simple and can be written easily inside condition textbox. Sometimes, you may
need to specify too big or complex conditions also. For that, you do not need to worry, VS
IDE provide the intellisense within the condition textbox also. So whenever you are going to
type anything inside the condition box, you will feel like typing inside the editor itself. Have
a look into the below picture.

Intellisense in condition textbox

I have almost covered all about the conditional breakpoints except one thing. In condition
window you have seen that there are two options available:

1. Is True and
2. Has Changed

We have already seen what is the use of "Is True" option. "Has changed" is used when you
want to break the code if some value has changed for some particular value.

13. Import / Export Breakpoint

This is another interesting feature where you can save breakpoints and can use them in future.
Visual Studio saves breakpoints in an XML Format. To save the breakpoints, you just need to
click on the "Export" button in breakpoint window.

11
DEBUGGING FEATURESOF VISUAL STUDIO

Save Breakpoints

You can use the saved XML file for the future and you can pass the same to other developers.
You can also save breakpoints based on the search on labels. Let's have a quick look inside
the content of the XML File. The XML file is collection of BreakPoints tag
within BreakpointCollection. Each breakpoints tag contains information about the particular
breakpoint like line number,  is enabled, etc.

If you delete all the breakpoints from your code at any time, you can easily import them by
just clicking on the "Import" breakpoints button. This will restore all of your saved
breakpoints.

Note: Breakpoint Import depends on the line number where you have set your breakpoint
earlier. If your line number changed, breakpoint will set on the previous line number only, so
you will get breakpoints on unexpected lines.

14. Breakpoint Hit Count

Breakpoint Hit Count is used to keep track of how many times the debugger has paused at
some particular breakpoint. You also have some option like to choose when the debugger will
stop. "Breakpoint Hit Count" window having the following:

1. Break always
2. Break when the hit count is equal to a specified number
3. Break when the hit count is a multiple of a specified number
4. Break when the hit count is greater than or equal to a specified number.

12
DEBUGGING FEATURESOF VISUAL STUDIO

Breakpoint Hit Count

By default, it's set to always. So, whenever the breakpoints hits, hit count will increase
automatically. Now we can set some condition as earlier mentioned. So based on that
condition, breakpoint will hit and counter will be increased.

Breakpoint Hit Count Options

Let's explore it with the sample code block below:

for (int i = 0; i <= 10; i++)

{
Console.WriteLine(i.ToString()); // Breakpoint
}

If you want your code to break when hit count is a multiple of 2, you need to select the third
option from the dropdown list. After that, your code line should break only when the hit
count is 2, 4, 6... Etc.

13
DEBUGGING FEATURESOF VISUAL STUDIO

Hit Count Condition

Till now, I hope you are very much clear about breakpoints, labeling, hit count, etc. Now
have a look at what is "Breakpoint When Hit" option.

15. Data Tip

Data tip is kind of an advanced tool tip message which is used to inspect the objects or
variable during the debugging of the application. When debugger hits the breakpoint, if you
mouse over to any of the objects or variables, you can see their current values. Even you can
get the details of some complex object like dataset,datatable, etc. There is a "+" sign
associated with the dataTip which is used to expand its child objects or variables.

DataTips During Debugging

16. Pin Inspect Value during Debugging

While debugging in Visual Studio, we generally used mouse over on the object or variable to
inspect the current value. This shows the current data items held by the inspected object. But
14
DEBUGGING FEATURESOF VISUAL STUDIO

this is for a limited time, as long as the mouse is pointed to that object those value will be
available. But in Visual Studio 2010 Beta 2, there is a great feature to pin and unpin this
inspected value. We can pin as many of any object and their sub object value also. Please
have a look into the below picture:

Pin Inspect Value During Debugging

When you mouse over on the inspect object, you will get pin icon with each and every
object's properties, variable. Click on that pin icon to make it pinned. Unless you manually
close these pinned items, they will be visible in the IDE.

17. Drag-Drop Pin Data Tip

You can easily Drag and Drop the data tip inside the Visual Studio IDE. This is quite
helpful when you need to see some object value list in the bottom section of code. You can
easily drag those pinned data tips over there.
Drag Drop Data Tips

15
DEBUGGING FEATURESOF VISUAL STUDIO

18. Adding Comments

You can add comments on the pinned data tip. For providing comments, you need to click on
“Expand to see the comments” button. This will brings up an additional textbox to add
comments.

Comments in DataTip

Below is some demonstration of Adding comments on pinned inspect value:

Adding Comments for Datatips

19. Watch Windows

You can say it is an investigation window. After breakpoint has been hit, the next thing you
want to do is to investigate the current object and variables values. When you mouse hover
on the variable, it shows the information as a data tip which you can expand, pin, import
which I have already explained. There are various types of watch windows like Autos, Local,
etc. Let's have a look into their details.

19.1. Locals

It automatically displays the list of variables within the scope of current methods. If your
debugger currently hits a particular breakpoint and if you open the "Autos" window, it will
show you the current scope object variable along with the value.

16
DEBUGGING FEATURESOF VISUAL STUDIO

Local Variables

19.2. Autos
These variables are automatically detect by the VS debugger during the debugging. Visual
Studio determines which objects or variables are important for the current code statement and
based on that, it lists down the "Autos" variable. Shortcut key for the Autos Variable
is "Ctrl + D + A".

Autos - Ctrl+D, A

19.3. Watch
Watch windows are used for adding variables as per requirement. It displays variables that
you have added. You can add as many variables as you want into the watch window. To add
variables in the watch window, you need to "Right Click" on variable and then select "Add
To Watch".

Autos - Ctrl+D, W

17
DEBUGGING FEATURESOF VISUAL STUDIO

You can also use Drag and Drop to add variables in watch windows. If you want to delete
any variable from watch window, just right click on that variable and select"Delete Watch".
From the debug window, you can also edit the variable value at run time.

There are 4 different watch windows available which you can use parallelly.

Multiple Watch Window

If any of the row variables of the above window holds the object instance, you can have
a "+" symbol with the variable to explore the properties and member of that object variable.

Expanding Watched Variable

18
DEBUGGING FEATURESOF VISUAL STUDIO

20. Immediate Window

Immediate window is very much common and a favorite with all developers. It's very much
helpful in debug mode of the application if you want to change the variable values or execute
some statement without impacting your current debugging steps. You can open the
Immediate window from menu Debug > Window > Immediate Window { Ctrl + D, I / Alt
+ Ctrl - I }. Immediate window has a set of commands which can be executed any time
during debugging. It also supports Intellisense. During Debug mode, you can execute any
command or execute any code statement from here.

Basic Immediate Window

These are very much common features for all the developers, so I am not going into details of
each and every command of Immediate window.

21. Call Stack

These features also improve the productivity during debugging. If you have multiple method
calling or nested calling all over your application and during debugging, you want to check

19
DEBUGGING FEATURESOF VISUAL STUDIO

from where this method has invoked, "Call Stack" comes into the picture. The Call Stack
Window shows that current method call nesting.

Call Stack

In Call Stack window if you clicked on any of the rows, it will point you to the actual code of
line of Visual Studio Code Editor. You can also customize the call stack row view by
selecting different types of columns. To customize, Right Click on the "Call Stack" window,
and from the context menu, you can select or deselect the option.

Call Stack Customization

Call stack is very much important when you have multiple methods call all across the
application and one particular method throwing an exception on some particular case. At that
time, you can use call stack to see from where this method is getting invoked, based on that
you can fix the defect.

22. Debugging Multithreaded Program

As of now, what I have discussed is all about fundamentals of debugging, knowing

debugging tools and their uses. Now let's have a look into the multithreaded scenarios. Here

20
DEBUGGING FEATURESOF VISUAL STUDIO

you will see how to work with multithreaded program debugging, where is your current
thread, what is the thread execution sequence, what is the state of thread. Before continuing
with the demo, let's consider you have the following piece of code which you want to debug.

class ThreadTest
{
static void Main()
{
Thread t = new Thread(new ThreadStart(Go));
t.Name = "Thread 1";
Thread t1 = new Thread(new ThreadStart(Go));
t1.Name = "Thread 2";
t.Start();
t1.Start();
Go();
}
static void Go()
{
Console.WriteLine("hello!");
}
}

In the sample code, you have three different threads - Main Thread, Thread 1, Thread 2. I
have given a thread name to make you understand better. Now set a breakpoint
inside "Go()" and run the application. When debugger hits the breakpoint,
Press Ctrl+D,T or Navigate through Debug > Window > Threads. Threads window will
appeared on the screen.

23. Exploring Threads Window

After selecting the thread window from debug menu, the following screen will come:

Detail view of Thread window

21
DEBUGGING FEATURESOF VISUAL STUDIO

By default thread window having ID, Managed ID, Category, Name, Location and Priority
column. At the start, execution pauses at "Main Thread". "Yellow Arrow" indicates the
current executable thread. Category column indicates the category of threads, like main
thread or worker thread. If you check the thread location, it is nothing
but Namespace > Class > Method name. In the diagram, it is showing that the Main
Thread will be executed next. Now to explore the next step by just pressing "F5" and see
what are the changes in thread window.

Detail view of Thread window - For Next Steps

24. Debugging Parallel Program

This is another great feature added to Visual Studio 2010 to debug parallel program. Parallel
programming is the new feature coming with .NET 4.0.Now debugging the parallel program
is also a big topic. Here I will give you a basic overview to know about the debugging of
parallel program. To discuss about it, let's consider you have the following piece of code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ParalleTaskDebugging
{
class Program
{
static void Main(string[] args)
{
var task_a = Task.Factory.StartNew(() => DoSomeWork(10000));
var task_b = Task.Factory.StartNew(() => DoSomeWork(5000));
var task_c = Task.Factory.StartNew(() => DoSomeWork(1000));
Task.WaitAll(task_a, task_b, task_c);

22
DEBUGGING FEATURESOF VISUAL STUDIO

static void DoSomeWork(int time)

{
Thread.Sleep(time);
}
}
}

To understand the parallel program debugging, we need to be aware about two window
options: 

1. Parallel Tasks
2. Parallel Stacks

24.1. Parallel Task and Parallel Stacks

Before continuing with parallel tasks and parallel stacks, you have to know about Threads
Window which I have already covered. In the given code, you have three different tasks
which are doing something and after sometime, all the tasks are put on hold. This is done
intentionally to check the status of each task. To test, put a breakpoint
on DoSomeWork() method and run the application. You will see your program execution
paused on the breakpoint. After the program break, you can go to Debug > Window >
Open Parallel Tasks and Parallel Stacks window. I asked to open both at the same time
only because you can visualize what is going on.

Breakpoint Filter - Multithreaded Debugging

Parallel Task window will show you what are the different tasks that have been created for
the program and what is their current status. On the other hand, Parallel Stacks will show you
the graphical view of all thread creation, containing tasks, how they are related. If you click
on the thread from the Parallel Stacks, it will show you the code line related with the thread

23
DEBUGGING FEATURESOF VISUAL STUDIO

(as shown in the picture with a Green Arrow). To move ahead, press F5. Let's see what
comes next.

Parallel Program - Debugging

In the above diagram, you can find one of the tasks has been executed and the other two are
remaining. Current execution point is set to AsyncMethod_1, so if you continue, this method
will execute first and next time the others. When you are working with parallel programming,
there are many scenarios which will come like Deadlock, Dependency problem, etc. These
topics is very interesting and long to discuss. Please check further study section of the article
to know more details.

25. Debugging with IntelliTrace - Overview

This is another great feature of Visual Studio 2010 IDE. IntelliTrace Debugging is
sometimes called as historical Debugging. IntelliTrace operates in the background, records
what you are doing during debugging. When you want the information of previous event or
some particular event, you can easily get it from intelliTrace information, a past state of your
application. In this mode, you can navigate to various events, steps that are recorded. In this
section, I will give you a basic overview of how to use IntelliTrace.

Here I am using one sample program by which I will show you what IntelliTrace does. Below
is the sample code block:

class Program
{
static void Main(string[] args)
{
Console.WriteLine("IntelliTrackerTest");
CallTestMethod(5);
}

24
DEBUGGING FEATURESOF VISUAL STUDIO

public static void CallTestMethod(int TestValue)

{
Console.WriteLine("In CallTestMethod : " + TestValue.ToString());
Console.WriteLine("Last Statement....");
}
}

Run the program and Open IntelliTrace window from Debug menu, you will find the below
screen added in the right hand side of Visual Studio.

IntelliTracker First View

26. Conclusion

This report covers basic fundamentals of debugging procedure. It describes how to debug
an application using VS IDE. The usage of all important tools is explained. The main
shortcoming of the Visual Studio Debugger is its inability to trace into kernel-mode code.
However, this is possible using a free Visual DDK extension. Alternatively, kernel-mode
debugging of Windows is generally performed by using WinDbg, KD, or SoftICE. The
Visual Studio Debugger also has no ability to debug Lambda-Expressions or Linq. This is
because of the high complexity the debugger would grow to. Even though it doesn`t address
the above features, its wide range of application makes it as a powerful tool for debugging.

25
DEBUGGING FEATURESOF VISUAL STUDIO

References

1. Abhijit Jana, “Mastering Debugging in Visual Studio 2010 - A Beginner's Guide”.

2. Daniel Moth and Stephen Toub, “Debugging Task-Based Parallel Applications in

Visual Studio 2010”.

3. Microsoft Developer Networks, “Debugging with IntelliTrace”.

4. Scott, “VS 2010 Debugger Improvements”.

26