.NET Memory Analysis in Production

10 posts · Jun 2013 – Jul 2015

What this trail covers

Visual Studio 2013 and later versions provide enhanced tools for diagnosing .NET memory issues in production. This includes the ability to analyze .NET memory dumps to identify memory leaks and inefficient memory usage. Recent enhancements allow developers to navigate directly from memory analysis to the source code definition of objects and find all references to those objects within their project, streamlining the debugging process. Update 2 adds the ability to inspect values of objects and in

All Microsoft trails

Jul 2015Debugging .NET Native Windows Universal AppsThis post details debugging .NET Native Windows Universal Apps. It explains that the default Debug configuration uses the .NET Core runtime for fast iteration, but Release builds use the .NET Native tool chain for production. To debug .NET Native specific issues, it recommends disabling code optimizations by creating a new build configuration. It also highlights differences in inspecting runtime types, specifically the '[Native Implementation]' node for Windows Runtime objects, and the need to load symbols from Microsoft Public Symbol servers.
Apr 2015Diagnosing Event Handler Leaks with the Memory Usage Tool in Visual Studio 2015This post details the use of the Memory Usage tool in Visual Studio 2015 RC to diagnose memory leaks, specifically focusing on event handler leaks in .NET applications. It demonstrates how to take memory snapshots before and after exercising code paths, compare them using the Heap View, and inspect individual object instances to identify references preventing garbage collection. The walkthrough uses a sample WPF application to illustrate finding a leak caused by an ImagePage object subscribing to a ListView's SelectionChanged event without unsubscribing, and shows how to fix it by overriding the Window.OnClosed handler. The post also highlights the updated UI of the Memory Usage tool and the 'super-power' of instance inspection when snapshots are taken in a break state.
Nov 2014Memory Usage Tool while debugging in Visual Studio 2015Introduces a new Memory Usage tool integrated with the debugger in Visual Studio 2015. This tool allows for real-time memory profiling while debugging, offering a live graph of Private Bytes, simplified mode selection (managed, native, or both) based on the debugger type, improved mixed-mode snapshots showing both managed and native heap summaries, and a familiar heap analysis view. It builds upon the post-mortem Memory Usage tool from Visual Studio 2013 by enabling interactive debugging control during performance investigations.
May 2014.NET Memory Analysis: Go to Source in Visual Studio 2013 Update 3This post introduces an enhancement to the .NET memory dump analysis feature in Visual Studio 2013 Update 3. It adds 'Go to Definition' and 'Find All References' options to the context menu in the Debug Managed Memory analysis window. These options allow developers to directly navigate to the source code definition of a selected type or find all occurrences of its references within the opened source project, provided the corresponding source project is open. This streamlines the process of investigating memory issues by linking analysis directly to code.
Apr 2014Diagnosing memory issues with the new Memory Usage Tool in Visual StudioIntroduces the new Memory Usage tool within the Visual Studio 2013 Performance and Diagnostics hub for diagnosing memory issues in Windows Store and Windows Phone Store apps (C#/VB/C++ and XAML). The tool supports three profiling modes: Managed, Native, and Mixed. It provides a live graph of memory consumption, a memory threshold indicator for phone devices, and snapshot-based profiling. The post details how to use snapshots to analyze managed heap size, object counts, and identify leaks by examining GC roots and referenced objects. It also covers troubleshooting native memory issues and provides a concrete example of fixing a memory leak in a sample application by unregistering an event handler.
Advertisement
Feb 2014.NET Memory Analysis: Object InspectionIntroduced a new feature in Visual Studio 2013 Update 2 to inspect values of objects and instances within .NET memory dumps. This includes an 'Instance View' accessible from the type summary page, allowing for deeper inspection of dump data. Developers can edit default values shown by adding a DebuggerDisplayAttribute to their code. Hovering over items reveals DataTips for inspecting values, and objects can be expanded to inspect subfields. The feature also applies to the 'Paths to Root' and 'Referenced Objects' graphs. Navigation back to the type overview is available via breadcrumbs or the back button/backspace key.
Dec 2013Investigating Memory Leaks in Azure Web Sites with Visual Studio 2013This post details a scenario for investigating memory leaks in production Azure Web Sites using Visual Studio 2013. It covers setting up an Azure Web Site with Git deployment, obtaining deployment credentials, and then using PowerShell to call Diagnostics REST APIs to retrieve GCDump files. The post provides specific PowerShell commands and URIs for invoking the diagnostics/processes/0/gcdump endpoint. It also explains how to open the resulting .diagsession file in Visual Studio to analyze the managed heap and identify objects that are being kept alive. An update is mentioned that allows for comparing two diagsession files to more easily identify leaks.
Jun 2013Seeing function return values in the Visual Studio 2013 debuggerIntroduced the ability to see function return values in the Visual Studio 2013 debugger for .NET code. This feature allows developers to examine the return value of a function when stepping over or out of it, particularly useful when the returned value is not stored in a local variable. The return values are displayed in the 'Autos Window' and can be accessed using the pseudo-variable '$ReturnValue' in the Watch and Immediate windows. The post provides a C# console application example to demonstrate this functionality.
Jun 2013Using Visual Studio 2013 to Diagnose .NET Memory Issues in ProductionThis post details the introduction of a new feature in Visual Studio 2013 for diagnosing .NET memory issues in production using .dmp files. It explains common memory problems (leaks, inefficient use, unnecessary allocations) and their symptoms (crashes, poor performance). The post provides a step-by-step example of collecting data using Performance Monitor and ProcDump, and then analyzing the .dmp file in Visual Studio 2013's managed memory analysis view. It demonstrates how to identify objects consuming the most memory and their references, and how to improve memory efficiency by modifying database queries to retrieve only necessary data. It also introduces the comparison of dump files to identify memory leaks.