Quickstart: Debug with C# or Visual Basic using the Visual Studio debugger

Article
03/18/2018

Applies to: Visual Studio Visual Studio for Mac

Note

This article applies to Visual Studio 2017. If you're looking for the latest Visual Studio documentation, see Visual Studio documentation. We recommend upgrading to the latest version of Visual Studio. Download it here

The Visual Studio debugger provides many powerful features to help you debug your apps. This topic provides a quick way to learn some of the basic features.

Create a new project

Open Visual Studio and create a new project.

From the top menu bar, choose File > New > Project. In the left pane of the New project dialog box, under Visual C#, choose .NET Core, and then in the middle pane choose Console App (.NET Core). Then, type a name like MyDbgApp and click OK.

If you don't see the Console App (.NET Core) project template, go to Tools > Get Tools and Features..., which opens the Visual Studio Installer. Choose the .NET Core cross-platform development workload, then choose Modify.

Visual Studio creates the project.

In Program.cs or Module1.vb, replace the following code

class Program
{
    static void Main(string[] args)
    {
    }
}

Module Module1
    Sub Main()
    End Sub
End Module

with this code:

class Program
{
    private static void doWork()
    {
        LinkedList<int> c1 = new LinkedList<int>();

        c1.AddLast(10);
        c1.AddLast(20);

        LinkedList<int> c2 = new LinkedList<int>(c1);
        int i = c2.First.Value;
        int j = c2.First.Value;
        Console.Write("The first element is ");
        Console.Write(i);
        Console.Write("\n");
        Console.Write("The second element is ");
        Console.Write(j);
        Console.Write("\n");

    }

    static int Main()
    {
        // using namespace std;
        doWork();
        return 0;

    }
}

Imports System.Collections.Generic

Namespace MyDbgApp
    Class Program
        Private Shared Sub doWork()
            Dim c1 As New LinkedList(Of Integer)()

            c1.AddLast(10)
            c1.AddLast(20)

            Dim c2 As New LinkedList(Of Integer)(c1)
            Dim i As Integer = c2.First.Value
            Dim j As Integer = c2.First.Value
            Console.Write("The first element is ")
            Console.Write(i)
            Console.Write(vbLf)
            Console.Write("The second element is ")
            Console.Write(j)
            Console.Write(vbLf)

        End Sub

        Public Shared Function Main() As Integer
            ' using namespace std;
            doWork()
            Return 0

        End Function
    End Class
End Namespace

Note

In Visual Basic, make sure the startup object is set to Sub Main (Properties > Application > Startup Object).

Set a breakpoint

A breakpoint is a marker that indicates where Visual Studio should suspend your running code so you can take a look at the values of variables, or the behavior of memory, or whether or not a branch of code is getting run. It is the most basic feature in debugging.

To set the breakpoint, click in the gutter to the left of the doWork function call (or select the line of code and press F9).
Now press F5 (or choose Debug > Start Debugging).

The debugger pauses where you set the breakpoint. The statement where the debugger and app execution is paused is indicated by the yellow arrow. The line with the doWork function call hasn't yet executed.

Tip

If you have a breakpoint in a loop or recursion, or if you have many breakpoints that you frequently step through, use a conditional breakpoint to make sure that your code is suspended ONLY when specific conditions are met. A conditional breakpoint can save time and it can also make it easier to debug issues that are hard to reproduce.

Navigate code

There are different commands to instruct the debugger to continue. We show a useful code navigation command that is available starting in Visual Studio 2017.

While paused at the breakpoint, hover over the statement c1.AddLast(20) until the green Run to click button appears, and then press the Run to click button.

Run to click

The app continues execution, calling doWork, and pauses on the line of code where you clicked the button.

Common keyboard commands used to step through code include F10 and F11. For more in-depth instructions, see First look at the debugger.

Inspect variables in a data tip

In the current line of code (marked by the yellow execution pointer), hover over the c1 object with your mouse to show a data tip.

The data tip shows you the current value of the c1 variable and allows you to inspect its properties. When debugging, if you see a value you don't expect, you probably have a bug in the preceding or calling lines of code.
Expand the data tip to look at the current property values of the c1 object.
If you want to pin the data tip so that you can continue to see the value of c1 while you execute code, click the small pin icon. (You can move the pinned data tip to a convenient location.)

Edit code and continue debugging

If you identify a change that you want to test in your code while in the middle of a debugging session, you can do that, too.

Click the second instance of c2.First.Value and change c2.First.Value to c2.Last.Value.
Press F10 (or Debug > Step Over) a few times to advance the debugger and execute the edited code.

F10 advances the debugger one statement at a time, but steps over functions instead of stepping into them (the code that you skip still executes).

For more information on using edit-and-continue and on feature limitations, see Edit and Continue.

Next steps

In this tutorial, you've learned how to start the debugger, step through code, and inspect variables. You may want to get a high-level look at debugger features along with links to more information.

First look at the debugger