JetBrains dotMemory

https://www.jetbrains.com/help/dotmemory
Admin
dotMemory is a memory profiling tool for analyzing the memory usage of any .NET-based application,...
Tokens:93,358
Snippets:422
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### dotMemory Introduction and Getting Started

Source: https://www.jetbrains.com/help/dotmemory/Profile_Web_Application_on_IIS_Express

Provides an introduction to dotMemory and guides users on how to get started with the tool. It covers basic setup and initial usage.

```en
dotMemory
2025.2
Get Started with dotMemory
This section provides an introduction to dotMemory and guides users on how to get started with the tool. It covers basic setup and initial usage.
```

--------------------------------

### Get Started with dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Profile_WinRT_Application

A guide for new users to begin using JetBrains dotMemory. It covers initial setup and basic profiling tasks.

```APIDOC
Get Started with dotMemory:
  Purpose: An introductory guide for new users to begin profiling with dotMemory.
  Key Features:
    - Easy setup and installation.
    - Intuitive user interface.
    - Support for various .NET application types.
  Initial Steps:
    1. Download and install dotMemory from the JetBrains website.
    2. Launch dotMemory.
    3. Choose a profiling scenario (e.g., start new process, attach to running process).
    4. Follow the on-screen instructions to profile your application.
    5. Explore the analysis views to understand memory usage.
  Resources:
    - Tutorials and documentation available on the JetBrains website.
    - Community forums for support.
  Related Topics:
    - dotMemory Introduction
    - Analyzing Results
```

--------------------------------

### Get Started with dotMemory Tutorial

Source: https://www.jetbrains.com/help/dotmemory/Getting_Started_with_dotMemory

A tutorial to guide users through running dotMemory, capturing memory snapshots, and understanding basic profiling concepts. It uses a sample application for practical examples.

```en
Project: /websites/jetbrains_help_dotmemory

# Get Started with dotMemory
Last modified: 24 July 2024
> ### warning
> Disclaimer: This tutorial is created using dotMemory 2019.3. In the recent dotMemory versions, the user interface may have changed.
|   
---|---  
**Sample application** | 
  * [Game of Life](https://github.com/DarthWeirdo/GoL_dotMemory_Tutorial1)

  
|   
In this tutorial, we will learn how to run dotMemory and get memory snapshots. In addition, we will take a brief look at dotMemory's user interface and basic profiling concepts. Consider this tutorial as your starting point to dotMemory.
```

--------------------------------

### Get Started with dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Profile_Application_in_Docker_Container

A guide for new users to begin using JetBrains dotMemory. It covers initial setup and basic profiling tasks.

```en
Get Started with dotMemory: https://www.jetbrains.com/help/dotmemory/Getting_Started_with_dotMemory.html
```

--------------------------------

### Get Started with dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Profile-MAUI-application

An introductory guide to using JetBrains dotMemory. This section likely covers the basic features, setup, and initial steps for memory profiling.

```APIDOC
Get Started with dotMemory:
  Description: Provides an introduction to dotMemory, covering initial setup and basic profiling.
  Content:
    - Installation and setup.
    - Core features overview.
    - First profiling session.
  Related: dotMemory Introduction
```

--------------------------------

### Start Profiling New Application - dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Starting_Profiling_Process

Steps to start a profiling session for a new application using JetBrains dotMemory. This involves selecting a run configuration and specifying profiling options.

```APIDOC
Start Profiling New Application:
  1. Select or create a run configuration under 'Choose what you want to profile'.
  2. Specify profiling options under 'Choose how you want to profile it'.
  3. Click 'Start' under 'Run profiling'.
```

--------------------------------

### Start Profiling with API (Linux/macOS)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts MyApp and enables control of profiling via the dotMemory API.

```bash
./dotMemory.sh start --use-api ~/MyApp/MyApp
```

--------------------------------

### Start Application and Take Snapshot on Activation (Linux/macOS)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts an application and takes an immediate snapshot once the profiler is initialized. Supports an optional delay.

```Linux/macOS Shell
./dotMemory.sh start --trigger-on-activation ~/MyApp/MyApp
```

--------------------------------

### JetBrains dotMemory Command-Line Profiler Examples

Source: https://www.jetbrains.com/help/dotmemory/Profile_

Examples of using the dotMemory command-line profiler to capture memory snapshots from running applications or to start applications and take snapshots periodically.

```bash
dotMemory.exe get-snapshot MyApp --with-max-mem
```

```bash
dotMemory.exe start --trigger-timer=30s c:\MyApp\MyApp my-app-arg1
```

--------------------------------

### Start Profiling with API (Windows)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts MyApp.exe and enables control of profiling via the dotMemory API.

```bash
dotMemory.exe start --use-api C:\MyApp\MyApp.exe
```

--------------------------------

### Start Application and Take Snapshot on Activation (Windows)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts an application and takes an immediate snapshot once the profiler is initialized. Supports an optional delay.

```Windows Command Line
dotMemory.exe start --trigger-on-activation C:\MyApp\MyApp.exe
```

--------------------------------

### Start Profiling Running Application - dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Starting_Profiling_Process

Instructions for profiling an already running application with JetBrains dotMemory. This includes selecting the target process and configuring profiling settings.

```APIDOC
Start Profiling Running Application:
  1. Under 'Choose what you want to profile', select the running process.
     - Click 'Show All Processes' if the desired process is not listed.
  2. Specify profiling options under 'Choose how you want to profile it'.
  3. Click 'Start' under 'Run profiling'.
```

--------------------------------

### Start Profiling with Service Output (Linux/macOS)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts MyApp and enables service output messages to stdout for monitoring profiling progress. Requires the --service-output option.

```bash
./dotMemory.sh start --service-output ~/MyApp/MyApp
```

--------------------------------

### Start Profiling Session from Visual Studio

Source: https://www.jetbrains.com/help/dotmemory/Controlling_Profiling_Process

Guide on initiating a dotMemory profiling session directly from Visual Studio.

```en
Start Profiling Session from Visual Studio
https://www.jetbrains.com/help/dotmemory/Starting_Local_Profiling_Session_VS.html
```

--------------------------------

### Start Application with Memory Increase Snapshots (Linux/macOS)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts an application and takes snapshots when memory consumption increases by a specified percentage. Includes an optional delay to skip the startup phase.

```Linux/macOS Shell
./dotMemory.sh start --trigger-mem-inc=50% --trigger-delay=5s ~/MyApp/MyApp
```

--------------------------------

### Profiling Startup Project with dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Starting_Local_Profiling_Session_VS

Steps to profile the startup project of your .NET solution using dotMemory integrated into Visual Studio. This involves selecting a menu option, configuring settings, and starting the profiling session.

```APIDOC
APIDOC:
  Method: ReSharper | Profile | Run Startup Project Memory Profiling
  Description: Initiates memory profiling for the currently active startup project in Visual Studio.
  Steps:
    1. Navigate to the Visual Studio menu: ReSharper -> Profile -> Run Startup Project Memory Profiling.
    2. The 'Profile Startup Project' window will appear.
    3. Configure profiling settings as detailed in the 'Configure Profiling Session' documentation.
    4. Click the 'Start' button to begin the profiling session.
```

--------------------------------

### Start Application with Periodic Snapshots (Linux/macOS)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts an application under profiling and takes snapshots at a specified time interval. The interval is set using the `--trigger-timer` argument.

```Linux/macOS Shell
./dotMemory.sh start --trigger-timer=30s ~/MyApp/MyApp my-app-arg1
```

```Linux/macOS Shell
./dotMemory.sh start --trigger-timer=30s ~/MyApp/MyApp -- -my-app-arg1
```

--------------------------------

### Start Application with Memory Increase Snapshots (Windows)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts an application and takes snapshots when memory consumption increases by a specified percentage. Includes an optional delay to skip the startup phase.

```Windows Command Line
dotMemory.exe start --trigger-mem-inc=50% --trigger-delay=5s C:\MyApp\MyApp.exe
```

--------------------------------

### Start Profiling with Service Output (Windows)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts MyApp.exe and enables service output messages to stdout for monitoring profiling progress. Requires the --service-output option.

```bash
dotMemory.exe start --service-output C:\MyApp\MyApp.exe
```

--------------------------------

### dotMemory Command-Line Profiler Usage

Source: https://www.jetbrains.com/help/dotmemory/Profile_

Examples of using the dotMemory command-line profiler to get snapshots of running applications or start applications and take periodic snapshots.

```bash
./dotMemory.sh get-snapshot MyApp --with-max-mem
```

```bash
./dotMemory.sh start --trigger-timer=30s ~/MyApp/MyApp my-app-arg1
```

--------------------------------

### Start Application with Periodic Snapshots (Windows)

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Starts an application under profiling and takes snapshots at a specified time interval. The interval is set using the `--trigger-timer` argument.

```Windows Command Line
dotMemory.exe start --trigger-timer=30s C:\MyApp\MyApp.exe MyAppArg1
```

```Windows Command Line
dotMemory.exe start --trigger-timer=30s C:\MyApp\MyApp.exe -- -MyAppArg1
```

--------------------------------

### Service Output Messages

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Examples of service messages sent to stdout by dotMemory indicating the start of a profiling session or saving of a snapshot.

```json
##dotMemory["connected", {pid: 1234}]
```

```json
##dotMemory["workspace-saved", {path: "..."}]
```

--------------------------------

### Profile MAUI Application with dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Profile_Windows_Service

Guide for profiling .NET MAUI applications using JetBrains dotMemory.

```APIDOC
Profile MAUI Application:
  Start profiling:
    1. Launch dotMemory.
    2. Select 'Start Profiling'.
    3. Choose 'Local' or the appropriate target platform (e.g., 'Windows', 'Android', 'iOS').
    4. Specify the path to your MAUI application's executable or deployment package.
    5. Click 'Start'.

  Attach to a running MAUI application:
    1. Open dotMemory.
    2. Click 'Attach to Process'.
    3. Locate the process for your MAUI application on the target device or emulator.
    4. Click 'Attach'.

  Related Topics:
    - Profile .NET Core or .NET Application
    - Profile WinRT Application
```

--------------------------------

### Local Profiling of IIS Hosted Web App with dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Profile_ASP_Web_Site

Steps to profile a web application hosted on an IIS server using JetBrains dotMemory. This involves installing dotMemory, configuring a run profile for the IIS application, setting profiling options, starting the session, collecting snapshots, and analyzing the data.

```en
1. Install dotMemory on the server.
2. Run dotMemory as a standalone application.
3. Add a run configuration:
    - Choose 'IIS' in the New Run Configuration wizard.
    - Specify the URL of the profiled application in 'Open URL'.
    - Optionally, specify the browser in 'in browser'.
    - Optionally, specify environment variables in 'Set environment variables'.
    - Click 'Save'.
4. Select the created run configuration.
5. Specify profiling options:
    - Collect allocation data: 'Sampled' or 'Full'.
    - Specify other profiling options if required.
6. Click 'Start' to begin the profiling session.
7. Reproduce application workflows or memory issues.
8. Collect memory snapshots using the 'Get Snapshot' button.
9. Detach the profiler or close the application.
10. Analyze the collected snapshots.
```

--------------------------------

### Profile Standalone Application with dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Profile_Windows_Service

Instructions on how to profile a standalone .NET application using JetBrains dotMemory. This includes starting the profiler and attaching it to the application process.

```APIDOC
Profile Standalone Application:
  Start profiling:
    1. Launch dotMemory.
    2. Select 'Start Profiling'.
    3. Choose 'Local' as the target type.
    4. Specify the path to your application's executable.
    5. Click 'Start'.

  Attach to a running application:
    1. Launch dotMemory.
    2. Select 'Attach to Process'.
    3. Find your application's process in the list.
    4. Click 'Attach'.

  Related Topics:
    - Profile Windows Service
    - Profile Running Process
```

--------------------------------

### Download and Setup dotMemory Profiler in Container

Source: https://www.jetbrains.com/help/dotmemory/Profile_Application_in_Docker_Container

Downloads, unzips, and makes the dotMemory command-line profiler executable within a Debian-based Linux container. It uses wget for downloading and unzip for extraction.

```bash
apt-get update -y && apt-get install -y wget && \
wget -O dotMemoryclt.zip https://www.nuget.org/api/v2/package/JetBrains.dotMemory.Console.linux-x64 && \
apt-get install -y unzip && \
unzip dotMemoryclt.zip -d ./dotMemoryclt && \
chmod +x -R dotMemoryclt/*
```

--------------------------------

### Profile Standalone Application in dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Profile_Running_Process

Guidance on profiling standalone .NET applications with JetBrains dotMemory. This involves launching the application through dotMemory to capture performance data from the start.

```APIDOC
Profile Standalone Application:
  Description: Launches a standalone .NET application under dotMemory's profiling.
  Steps:
    1. Launch dotMemory.
    2. Select 'Open Dump' or 'Start New Session'.
    3. Choose 'Standalone Application'.
    4. Specify the path to the application executable.
    5. Configure any necessary startup arguments or environment variables.
    6. Click 'Start'.
  Related:
    - Profile Running Process
    - Profile Application in Docker Container
```

--------------------------------

### Limitations for Attaching to Running Processes - dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Starting_Profiling_Process

Details the limitations when attaching to running processes in JetBrains dotMemory, specifically regarding operating system and .NET version compatibility.

```APIDOC
Attaching to Running Processes Limitations:
  - Availability: Only on Windows.
  - .NET Framework: Requires .NET Framework 4.0 or later.
  - .NET Core: Requires .NET Core 3.0 or later.
  - .NET 5+: Requires .NET 5 or later.
```

--------------------------------

### Standalone dotMemory Launch

Source: https://www.jetbrains.com/help/dotmemory/Running_dotMemory

This describes running dotMemory as a standalone application, which is installed directly on the operating system. It is recommended when source code is not available or when avoiding IDE startup for profiling.

```APIDOC
Standalone Application:
  Launch dotMemory as a standalone application installed on your operating system.
  Installation via [JetBrains Toolbox](https://www.jetbrains.com/toolbox-app/) is strongly recommended.
  
  This method is suitable when you don't have the application's source code or prefer not to launch an IDE for profiling.
```

--------------------------------

### Profile Standalone Application

Source: https://www.jetbrains.com/help/dotmemory/Profile_WinRT_Application

Steps to profile a standalone .NET application using JetBrains dotMemory. This includes starting a new profiling session for a desktop application.

```APIDOC
Profile Standalone Application:
  Purpose: Provides instructions for profiling standalone .NET desktop applications.
  Steps:
    1. Open dotMemory.
    2. Select 'Start new process'.
    3. Browse to and select the executable of the standalone application.
    4. Configure any necessary profiling options (e.g., attach to process, sampling rate).
    5. Click 'Start' to launch the application under dotMemory's supervision.
    6. Perform actions within the application to gather memory data.
    7. Click 'Stop' in dotMemory to end the session and view the analysis.
  Considerations:
    - Ensure the target application is a .NET executable.
    - Administrator privileges may be required for some applications.
  Related Topics:
    - Profile Running Process
    - Profile Application in Docker Container
```

--------------------------------

### Profiling Session Configuration

Source: https://www.jetbrains.com/help/dotmemory/Getting_Started_with_dotMemory

Configuration options for a dotMemory profiling session for a standalone application. This includes specifying the application path and enabling memory allocation and traffic data collection from the start.

```text
Application: Specify the path to your application's executable.
Collect memory allocation and traffic data from start: Enable this option to collect allocation call stack data immediately upon application launch.
```

--------------------------------

### Profile Web Application on IIS Express

Source: https://www.jetbrains.com/help/dotmemory/Profile_WCF_Service

Instructions for profiling a web application hosted on IIS Express using JetBrains dotMemory. This covers the setup required to profile ASP.NET applications during development.

```APIDOC
Profile Web Application on IIS Express:
  Purpose: Profiling ASP.NET applications running on IIS Express.
  Configuration:
    - Ensure IIS Express is configured correctly.
    - Attach dotMemory to the IIS Express worker process.
  Related Topics:
    - Profile Web Application on IIS Server
    - Profile WCF Service
```

--------------------------------

### Profile Windows Service with dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Profile_Windows_Service

This guide explains how to profile a Windows Service using JetBrains dotMemory. It covers the necessary steps to attach the profiler to a running Windows Service or to profile it from startup.

```APIDOC
Profile Windows Service:
  Attach to a running Windows Service:
    1. Start the Windows Service.
    2. In dotMemory, select 'Attach to Process'.
    3. Find and select the process associated with your Windows Service.
    4. Click 'Attach'.

  Profile from startup:
    1. In dotMemory, select 'Open Snapshot' or 'Start Profiling'.
    2. Choose the 'Windows Service' profiling type.
    3. Specify the path to your Windows Service executable.
    4. Configure any necessary startup arguments.
    5. Click 'Start Profiling' or 'Run'.

  Related Topics:
    - Profile Standalone Application
    - Profile Running Process
    - Profile External .NET Process
```

--------------------------------

### Profile .NET Core or .NET Application

Source: https://www.jetbrains.com/help/dotmemory/Profile_WCF_Service

Guide on profiling .NET Core and .NET applications using JetBrains dotMemory. This covers the process of attaching the profiler to these modern .NET runtimes.

```APIDOC
Profile .NET Core or .NET Application:
  Purpose: Profiling applications built with .NET Core and .NET.
  Method:
    - Launch the .NET Core/.NET application with dotMemory attached.
    - Alternatively, attach dotMemory to a running .NET Core/.NET process.
  Related Topics:
    - Profile Standalone Application
    - Profile Application in Docker Container
```

--------------------------------

### Profile WCF Service

Source: https://www.jetbrains.com/help/dotmemory/Profile_WCF_Service

Instructions on how to profile a WCF service using JetBrains dotMemory. This guide covers the necessary steps to attach the profiler to a running WCF service or to start the service under the profiler's control.

```APIDOC
Profile WCF Service:
  Purpose: Guides users on profiling WCF services with dotMemory.
  Steps:
    1. Attach dotMemory to a running WCF service.
    2. Start the WCF service under dotMemory's control.
  Related Topics:
    - Profile Web Application on IIS Server
    - Profile .NET Core or .NET Application
```

--------------------------------

### dotMemory Command-Line Tool Usage

Source: https://www.jetbrains.com/help/dotmemory/dotMemory_Introduction

Information on how to use the dotMemory command-line tool for profiling .NET applications on Windows, macOS, and Linux.

```.NET
Refer to this page for more information: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler.html
```

--------------------------------

### Get Snapshot via Stdin

Source: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler

Sends a command to stdin to get a snapshot of a specified process PID or all profiled processes.

```json
##dotMemory["get-snapshot", {pid:1234}]
```

--------------------------------

### dotMemory Command-Line Tool Usage

Source: https://www.jetbrains.com/help/dotmemory/index

Information on how to use the dotMemory command-line tool for profiling .NET applications on Windows, macOS, and Linux.

```.NET
Refer to this page for more information: https://www.jetbrains.com/help/dotmemory/Working_with_dotMemory_Command-Line_Profiler.html
```

--------------------------------

### dotMemory Introduction

Source: https://www.jetbrains.com/help/dotmemory/Profile-MAUI-application

An overview of JetBrains dotMemory, its capabilities, and its role in .NET performance analysis. This provides a high-level understanding of the tool.

```APIDOC
dotMemory Introduction:
  Description: An overview of JetBrains dotMemory, a powerful .NET memory profiler.
  Key Features:
    - Memory profiling.
    - Leak detection.
    - Performance optimization.
    - Various profiling targets.
  Related: Get Started with dotMemory, Analyzing Results
```

--------------------------------

### JetBrains Rider Integration for dotMemory

Source: https://www.jetbrains.com/help/dotmemory/Running_dotMemory

This section details how to profile an existing project using dotMemory when it is opened within the JetBrains Rider IDE. It highlights the recommended usage scenario.

```APIDOC
JetBrains Rider Integration:
  Profile an existing project opened in JetBrains Rider.
  This is recommended for users who primarily work within the Rider IDE.
  
  For more information, see: [Memory profiling of .NET code](https://www.jetbrains.com/help/rider/Memory_profiling_of_.NET_code.html)
```

--------------------------------

### C# Photo Class Example

Source: https://www.jetbrains.com/help/dotmemory/Getting_Started_with_dotMemory

An example of a C# class named 'Photo' demonstrating how objects store data and reference other objects, forming an object graph. This illustrates the fundamental concept of memory allocation for application objects.

```C#
class Photo
{
    long _id;
    String _title;
    User _user;
    List<PhotoComment> _comments;
}
```

--------------------------------

### dotMemory Profiling Run Configurations

Source: https://www.jetbrains.com/help/dotmemory/What_s_New_in_dotMemory

dotMemory integrates with Visual Studio to offer enhanced profiling capabilities. Users can now profile not only the startup project but also any defined 'run configuration', which can be an arbitrary executable or a static method.

```APIDOC
dotMemory Visual Studio Integration:
  Profiling Capabilities
    Profile any 'run configuration' including:
      - Startup project
      - Arbitrary executable
      - Static method
```

--------------------------------

### dotMemory Command-Line Profiler: Start IIS Application

Source: https://www.jetbrains.com/help/dotmemory/Profile_ASP_Web_Site

Starts an IIS application pool under dotMemory profiling. It can automatically trigger snapshot collection based on a timer or URL access, and specify the browser to use.

```bash
dotMemory.exe start-iis --trigger-timer=30s --open-url=localhost/myapp --use-browser=Chrome
```
Tokens:
Raw