Create A .NET Core Development Environment Using Visual Studio Code - Part Four

This is the fourth article in my "Create a .NET Core Development Environment using Visual Studio Code" series. You can read my previous articles in the series from the following links.

• Create a .NET Core Development Environment using Visual Studio Code
• Create a .NET Core Development Environment using Visual Studio Code - Part 2
• Create a .NET Core Development Environment using Visual Studio Code - Part 3

In this article, I will be talking about debugging .NET Core applications using Visual Studio Code. As we all know, debugging is an indispensable part of programming. Most of our programming time is devoted to debugging the code written by us or others. So, it is really necessary that programmers need a very smooth debugging experience while coding. Most of the IDEs provide excellent debugging options. Visual Studio's debugging capabilities are so powerful that it provides a lot of features like breakpoints, code stepping, variable inspection, call stack, debug console window etc. 

In this article, we will see how to bring a smooth debugging experience while developing .NET Core applications in Visual Studio Code. For debugging .NET Core applications in Visual Studio Code we need to install C# extension for VS Code. You can refer to my first article in the series for more information on this.

So, for the debugging demonstration, we shall be creating a .NET Core Web API project.

• Create a folder named DebuggingExample and open that folder in Visual Studio Code.
  
  
• Open the terminal and enter the command
  
  dotnet new webapi --name DebuggingExampleApi
  
  This shall create a .NET Core Web API project in the folder.
  
  
• Open the ValuesController.cs file in the Controllers folder. This will make the C# extension display a prompt which will offer to generate build tasks and launch configurations for your project. (See the below figure)
  
  
   

• Click Yes, and VS Code will create a folder name .vscode in the project directory. The directory contains two files - launch.json and tasks.json. These two files are important for VS Code as these are the configuration files required for building our project and debug it.
• tasks.json is used to configure what command line command is executed to build your project, and launch.json configures the type of debugger you want to use, and what program should be run under that debugger.
  
  
• launch.json configures VS Code to run the build task from tasks.json so that your program is automatically up-to-date each time you go to debug it. For learning about advanced debugging configurations, you can visit here.

• Now, let’s make a small change in the Get() method in the ValuesController that returns an ActionResult<IEnumerable<string>>. We shall change the inline return function and assign the returned value to a variable. This will help to inspect the variable values during debugging.
  

  public ActionResult<IEnumerable<string>> Get()
  {
      var texts = new List<string>();
  
      texts.Add("value1");
      texts.Add("value2");
  
      return texts;
  }

• Now, set a breakpoint on this method. Similar to Visual Studio, we can set a line breakpoint in source code by clicking in the left margin of a source code file, or by putting the cursor on a line of code and pressing F9. The breakpoint appears as a red dot in the left margin of the editor.
  
  
• For starting the debugging, press F5. This will start the application by automatically attaching the debugger to our application. This will also open the start page in our default browser.
  
  
• Now, call the controller method on which we have set our breakpoint from the browser. Type localhost:5001/api/values in the address bar and press enter. We can see that the execution is stopped at the breakpoint we have set, which helps us in knowing the current program state while debugging.
  
  

We can see that the Debug view of VS Code is opened on the left side of the editor. The Debug view displays all information related to debugging. We can also notice that a debug toolbar has appeared on the top of the editor. The debug toolbar can be used for code navigation options while debugging. Following options are available in the debug toolbar.

• Continue / Pause (F5)
• Step Over (F10)
• Step Into (F11)
• Step Out (Shift+F11)
• Restart (Ctrl+Shift+F5)
• Stop (Shift+F5)

The debug view contains the following sections,

• Variables
  This section shall list out all the variables and their values in the debug session. In our example, we can see that our texts variable is listed in this section with the default value of null. When we step over the lines of code, we can notice that the variable values are changed when each string is added to the list. We can even modify the variable values in this section.

• Watch
  This section is similar to the Variables section. Here we can watch a particular variable we wish to debug. Just add the variable name to the expression list of the watch window to start watching that variable.

• Breakpoints
  This section displays all the breakpoints we had set in the source code for debugging.

Summary

In this article, I have explained how to debug .NET Core applications in Visual Studio Code. Even though the debugging capabilities of Visual Studio Code is not up to the level of Visual Studio, it actually does a lot of work most of the developers need. For more details about debugging features provided by Visual Studio Code visit this link.

Visual Studio Code is a powerful text editor from Microsoft which can be supercharged by an awesome collection of extensions created by the community. The community is so great that we can expect a lot more cool extensions and features coming to VS Code which will make .NET Core application in this lightweight, cross-platform editor more smooth and fun.