TechPrufer
Get started
Microsoft
Microsoft logoMicrosoft · Feature trail

Asynchronous Code Debugging Enhancements

15 posts · Jun 2013 – Feb 2016

What this trail covers

Visual Studio debugger enhancements for asynchronous code across C++, JavaScript, and C#/VB. The Call Stack window provides additional stack frames to show the execution path leading up to an asynchronous task, improving the understanding of application flow and bug identification. For C++ and JavaScript, these frames are annotated with '[Async Call]'. For managed code (C#/VB), it shows methods awaiting the current asynchronous operation. This post introduces 'Just My Code' for JavaScript in Win

All Microsoft trails
  1. Using the DebuggerNonUserCode Attribute in Visual Studio 2015This post details a workaround for a performance improvement in Visual Studio 2015 that impacted exception behavior for the DebuggerNonUserCode attribute. The performance feature reduced overhead by not notifying the debugger of exceptions thrown and caught within attributed code when 'Just My Code' was enabled. The workaround involves a registry key modification to disable this performance feature, restoring the previous behavior of breaking on exceptions within DebuggerNonUserCode methods. It also clarifies the differences between DebuggerNonUserCode, DebuggerStepThrough, and DebuggerHidden attributes.
  2. Servicing Update Available for Visual Studio Update 1This post details a servicing update for Visual Studio 2015 Update 1 that fixes a crash issue occurring when editing C# or Visual Basic files during debugging. This update provides fixes for high-impact bugs between regular updates and will be rolled into future updates.
  3. Improvement to Debugging C++ Access Violations in Visual Studio 2015 Update 1Introduces an improvement to debugging C++ access violations in Visual Studio 2015 Update 1. When an access violation occurs on a line of code with multiple pointer dereferences, the Exception Dialog now directly indicates which variable was the nullptr, eliminating the need to manually break down the line into multiple statements for debugging.
  4. C++ EnC in Visual Studio 2015This post details the initial implementation of Edit and Continue (EnC) for C++ developers within the default debug engine in Visual Studio 2015 RC. Previously, native EnC required falling back to a legacy debug engine, disabling newer features. This update aims to integrate EnC into the current engine for both x86 and x64 targets, allowing developers to edit code during debugging without losing access to features like natvis, async call stacks, and the Diagnostic Tools window. The feature is opt-in in the RC release and has specific configurations for x86 and x64 debugging, with plans for a unified setting in the RTM release.
  5. Make Debugging Faster with Visual StudioThis post details how to improve the performance of debug sessions by addressing slow startup, slow entry into break state, and slow application execution when a debugger is attached. It covers optimizing build/deploy times, managing the Windows debug heap, handling function breakpoints, and optimizing symbol loading. For slow entry into break state, it discusses call stack walks, watch windows, and the impact of open debugger windows. For slow application execution, it touches on the overhead of debug heap and potential issues with certain debugger features.
  7. Performance Improvement When Debugging .NET Code With Visual Studio 2015This post details a significant performance improvement in Visual Studio 2015 when debugging .NET applications running on .NET 4.6 or newer. The improvement specifically addresses the overhead caused by handled exceptions occurring in non-user code (i.e., code excluded by the 'Just My Code' setting). By optimizing how the debugger handles these exceptions, the execution time for scenarios with many handled exceptions in external libraries can be reduced by up to 97%. This change is achieved by modifying how the .NET runtime notifies the debugger about exceptions thrown and handled outside of the user's code when 'Just My Code' is enabled. The post also notes that this change will prevent exceptions thrown and handled outside of user code from appearing in the IntelliTrace events view.
  8. Diagnostic Tools debugger window in Visual Studio 2015Introduces the new Diagnostic Tools window in Visual Studio 2015, unifying the Output window, IntelliTrace, and the Performance and Diagnostics hub. The window provides a timeline with graphs for break events, IntelliTrace events, CPU Usage, and Memory Usage. It allows for automatic time range selection based on debugging actions (breakpoints, stepping) and manual selection via clicking on events or dragging on the timeline. The IntelliTrace experience is enhanced to capture debug messages from the Output window and enable historical debugging. The Memory Usage tool is integrated into the debugging experience, allowing snapshots before and after debug actions. Debugger PerfTips are now visible in the Diagnostic Tools window, and CPU Usage graphs can be correlated with code running between breakpoints.
  9. Understanding Exceptions while debugging with Visual StudioThis post details the configuration of exception settings within the debugger to break on first chance exceptions, user-unhandled exceptions, and unhandled exceptions, with a focus on System.NullReferenceException as an example. It also highlights IntelliTrace as a tool for diagnosing issues without needing to reproduce the problem or reconfigure exception settings.
  10. Phone Debugging in Visual Studio 2013 Update 2This post details how Visual Studio 2013 Update 2 extends asynchronous debugging capabilities to Windows Phone 8.1 development. It highlights the ability to trigger process lifecycle management (PLM) events (Suspend, Resume, Suspend and Shutdown) from the Debug Location Toolbar, view aggregated async calls in the Call Stack window, inspect async tasks in the Tasks window, see function return values in the Autos Window, create minidumps with heap from phone apps for memory analysis, debug managed/native interop, and debug HTML/JS Store apps. It also covers diagnosing mobile websites on the phone/emulator and introduces profiling tools (CPU Usage, Memory Usage, Energy Consumption, XAML UI Responsiveness) for performance analysis.
  11. JSON Debugger Visualizer in Visual Studio 2013Introduced a JSON Visualizer for the Visual Studio debugger, which displays JSON encoded strings in a treeview control. This visualizer allows for meaningful user interaction such as search, highlight, copying key-value pairs, and copying paths. It handles invalid JSON formats by displaying an error message and the string in plain text. The visualizer works across all languages and project types supported by the Visual Studio debugger.
  12. Just My Code for ASP.NET in Visual Studio 2013Introduced Just My Code for JavaScript debugging in ASP.NET applications within Visual Studio 2013 when using Internet Explorer 11. This feature allows developers to avoid stepping into external libraries like jQuery and to automatically ignore first-chance exceptions that occur outside of the developer's own code, improving the debugging experience for web applications.
  13. Opening 64-bit Dumps of 32-bit Processes in Visual Studio 2013Visual Studio 2013 can now properly process 64-bit dumps of 32-bit processes that are collected using Task Manager on 64-bit versions of Windows, resolving a previous limitation where only 32-bit dumps of 32-bit processes could be debugged.
  14. Switching to Managed Compatibility Mode in Visual Studio 2013This post introduces the ability to switch to a legacy managed debug engine for specific scenarios not yet supported by the current engine, including .NET languages other than C#, VB, or F# with their own Expression Evaluators (like managed C++), and enabling Edit and Continue (EnC) for C++ projects during mixed-mode debugging. It details how to enable this 'Managed Compatibility Mode' globally, per project, during attach, or by manually editing project files.
  15. Just My Code for JavaScript Windows Store Apps in Visual Studio 2013Introduced the 'Just My Code' (JMC) feature for JavaScript debugging in Windows Store apps within Visual Studio 2013. This feature helps developers focus on their own code by abstracting framework implementation details. The post defines 'My Code', 'Libraries', and 'Unrelated' code classifications and explains their impact on debugger stepping, exception handling, and breakpoint behavior. It also details how to customize these classifications using a 'mycode.json' file.
  16. Debugging Asynchronous Code in Visual Studio 2013- Call Stack enhancementsThis post details enhancements to the Call Stack window in Visual Studio 2013 for debugging asynchronous code. It explains how the window now provides additional stack frames to show the execution path leading up to an asynchronous task, improving application flow understanding and bug identification. Examples are provided for C++, JavaScript, and C#/VB, including the '[Async Call]' annotation for C++ and JavaScript, and showing awaiting methods for C#. The post also mentions the 'Just My Code' feature for C++.