{"id":30824,"date":"2020-12-02T09:00:02","date_gmt":"2020-12-02T16:00:02","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/dotnet\/?p=30824"},"modified":"2020-12-03T09:59:36","modified_gmt":"2020-12-03T16:59:36","slug":"improving-debug-time-productivity-with-source-link","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/improving-debug-time-productivity-with-source-link\/","title":{"rendered":"Improving Debug-time Productivity with Source Link"},"content":{"rendered":"

How many times have you been in the debugger tracking down a bug, stepping through code, looking at what local variable values changed, when you hit a wall — the value isn’t what you expected, and you can’t step into the method that produced it because it’s from a library or .NET framework itself? Or you set a conditional breakpoint waiting to examine how some value got set, then noticing a call stack that’s mostly greyed out, not letting you see what happened earlier in the call stack? Wouldn’t it be great if you could easily step into, set breakpoints, and use all the debugger’s features on NuGet dependencies or the framework itself?<\/p>\n

.NET development practices in 2020 are a lot different and better in many ways than they were ten years ago. The biggest change is that the .NET platform is open source and maintained on GitHub. Many of the NuGet libraries that we all use on a daily basis are also maintained on GitHub. That means that the source I’d really like to see in my debugger is just one HTTPS GET away. We could have this wonderfully productive ecosystem where we could all debug with source, for all our dependencies, all the time. That would be nice! In fact, the Source Link project, which was started by Cameron Taggart, realized this, and built an experience that did just that. Let me tell you about it.<\/p>\n

With Source Link-enabled libraries, the debugger can download the underlying source files as you step in, and you can set breakpoints\/tracepoints like you would with any other source. Source Link-enabled debugging makes it easier to understand the full flow of your code from your code down to the runtime. Source Link is language-agnostic, so you can benefit from it for any .NET language and for some native libraries.<\/p>\n

Debugging the framework<\/h3>\n

Let’s look at an example. Sometimes you want to step into the framework to see what’s going on, especially if something is happening that you didn’t expect. With Source Link, you can step into framework methods just like you can with your own code, inspect all variables, and set breakpoints.<\/p>\n

If you tried it without Source Link, here’s what you’d see, before and after hitting F11 to step in.<\/p>\n

\"At\n\"Debugger<\/p>\n

The debugger does not step into Console.WriteLine<\/code> because there are no symbols or source for it. Once we configure Source Link, when we step in, we get a different result:<\/p>\n

\"Debugger<\/p>\n

You can see that Visual Studio has downloaded the matching source and stepped into the method. If you look at the Autos<\/code> window, it shows the local variables passed in. You can step into, over, and out of the framework code as much as you’d like.<\/p>\n

Debugging a dependency<\/h3>\n

Often, the issue you’re trying to solve is in a dependency. Wouldn’t it be great if you could step into the source for your dependencies too? If the dependency added Source Link information during its build, you can! Here’s an example with Newtonsoft.Json<\/code>. Because Newtonsoft.Json<\/code> was built with Source Link information, you can step into its code:<\/p>\n

\"Debugger\n\"Prompt\n\"Debugger<\/p>\n

When I stepped in, the debugger skipped a couple of methods that were marked with DebuggerStepThrough<\/code> and stopped on the next statement in the CreateDefault<\/code> method. Since the source comes from the internet (GitHub, in this case), you’re prompted to allow it, either for just a single file or for all files.<\/p>\n

Exceptions<\/h3>\n

Source Link helps you with exceptions that come from the framework or dependencies. How many times have you seen this message and what you really want is to examine the variables?<\/p>\n

\"Debugger\n\"Debugger\n\"Debugger<\/p>\n

With Source Link, the debugger will take you to the spot where the exception is thrown where you can then navigate the call stack and investigate.<\/p>\n

Enabling Source Link<\/h2>\n

As Source Link downloads source files from the internet, it’s not enabled by default. Here’s how to enable it:<\/p>\n

Visual Studio<\/h3>\n

There are a couple steps to enable it:<\/p>\n

    \n
  1. Go to Tools<\/strong> > Options<\/strong> > Debugging<\/strong> > Symbols<\/strong> and ensure that the ‘NuGet.org Symbol Server’ option is checked. Specifying a directory for the symbol cache is a good idea to avoid downloading the same symbols again.\n\"Dialog\nIf you’d like to step into the .NET framework code, you’ll also need check the ‘Microsoft Symbol Servers’ option.<\/li>\n
  2. Disable Just My Code<\/code> in Tools<\/strong> > Options<\/strong> > Debugging<\/strong> > General<\/strong> since we want the debugger to attempt to locate symbols for code outside your solution.\n\"Dialog\nVerify that Enable Source Link support<\/code> is checked (it is by default). If you’d like to step into .NET Framework code, you’ll also need to check Enable .NET Framework source stepping<\/code>. This is not required for .NET Core.<\/li>\n<\/ol>\n

    Visual Studio Code<\/h3>\n

    Visual Studio Code has debugger settings configured per project in the launch.json<\/code>:<\/p>\n

    \"justMyCode\": false,\r\n\"symbolOptions\": {\r\n    \"searchMicrosoftSymbolServer\": true,\r\n    \"searchNuGetOrgSymbolServer\": true\r\n},\r\n\"suppressJITOptimizations\": true,\r\n\"env\": {\r\n    \"COMPlus_ZapDisable\": \"1\",\r\n    \"COMPlus_ReadyToRun\": \"0\"\r\n}\r\n<\/code><\/pre>\n
    Visual Studio for Mac<\/h3>\n
    To enable Source Link in Visual Studio for Mac, go to Visual Studio > Preferences\u2026 > Projects > Debugger<\/strong> and ensure that the Step into external code<\/code> option is checked. Click OK to save your changes.<\/p>\n
    \"Image<\/a><\/p>\n
    In Visual Studio for Mac, support for symbol servers doesn’t exist yet, so Source Link only works with NuGet packages that contain their own debug symbols. If you’re interested in symbol server support, please add your vote to the symbol server suggestion<\/a> on the Visual Studio Developer Community site.<\/p>\n
    Notes<\/h2>\n
    A few notes:<\/p>\n
      \n
    1. Not every library on nuget.org will have their .pdb files indexed. If you find that the debugger cannot find a PDB file for an open-source library you are using, please encourage the open-source library to upload their PDBs (see here for instructions<\/a>).<\/li>\n
    2. Most libraries on nuget.org are not<\/strong> ahead-of-time compiled, so if you are only trying to debug into this library and not the .NET Framework itself, you can likely omit the env section from above. Using an optimized .NET Framework will significantly improve performance in some cases.<\/li>\n
    3. Only Microsoft provided libraries will have their .pdb files on the Microsoft symbol server, so you can disable that option if you are only interested in an OSS library.<\/li>\n<\/ol>\n
      In a future post we’ll show you how to create libraries and applications with Source Link enabled so your users can benefit.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Improve your debug-time productivity by using Source Link to step into framework and dependency code.<\/p>\n","protected":false},"author":42867,"featured_media":31153,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[685,196,7196],"tags":[4,9,7201,322,7202],"class_list":["post-30824","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dotnet","category-dotnet-core","category-debugging","tag-net","tag-net-core","tag-debug-time","tag-debugging","tag-source-link"],"acf":[],"blog_post_summary":"
      Improve your debug-time productivity by using Source Link to step into framework and dependency code.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/30824","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/42867"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=30824"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/30824\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/31153"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=30824"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=30824"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=30824"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}