dotTrace is a performance profiler for .NET applications that works right
in Visual Studio, provides great ways to visualize CPU usage and navigate through performance snapshots. Read on for more details

through performance snapshots. Read on for more details.

Top-Class technology support

dotTrace helps you locate performance bottlenecks in a variety of .NET applications, including
desktop applications, ASP.NET applications, Silverlight, WCF services, Windows services, Universal
Windows Platform applications, and unit tests.

Some of supported types of applications

On-demand profiling

You can take a snapshot of application performance anytime during its execution. dotTrace can be
attached to a running application for profiling, and detached as soon as profiling information is captured.

You can dynamically attach the profiler to and detach from an application

This minimizes overhead imposed by running an application under the profiler. More importantly, it
enables investigating performance issues in production environments where you just can't
afford to restart an application every time you need to profile it.

Versatile profiling modes

Depending on your needs, you can choose between several modes of performance profiling.

Sampling profiling is the fastest profiling method, but at the expense of lower accuracy. It is extremely
useful for quickly getting a general idea of your application's performance, and profiling for extensive
periods of time.

Tracing profiling is a very accurate way of profiling based on CLR notifications on entering and leaving
functions. It helps you learn precise timing information and the number of function calls.

Line-by-line profiling collects timing information per statement, letting you collect the most detailed
information about functions that perform significant algorithmic work. Use this method wisely though
as it imposes the greatest overhead on the application that is being profiled.

Timeline profiling records application events and writes data about how application state changed during
the profiling session. These includes not only temporal call stack and thread state data but also temporal data
about memory allocation, garbage collections, and I/O operations.

Code preview options

dotTrace provides a code preview area where you can see source code or decompiled code for the currently
highlighted function call.

Source preview area

Source code can be reconstructed from local PDB files or via symbol servers: for example, by connecting
the profiler to Microsoft Reference Source Server, you can preview the source code of .NET Framework when
you analyze the behaviour of library code in your snapshot. You can also choose to show preview of IL code
instead of source code.

If source code is not available, dotTrace can still decompile function code for your quick review.

Profiling SDK

dotTrace provides Profiling SDK for enabling custom profiling scenarios in your applications. SDK
allows an application to profile itself and gather performance metrics for future analysis.

Local or remote profiling

Most of the time, you're profiling local applications. However, what if you're faced with a lagging
application on a remote web server?

No worries: dotTrace can connect to a remote machine to profile a standalone or web application,
or a Windows service. You don't even have to install dotTrace there — just copy a couple of files.

Remote profiling

Server-scale snapshot support

dotTrace is able to profile huge applications and get snapshots of up to several hundred gigabytes in size
while still working at acceptable speed. That means, you can use dotTrace to profile complex desktop
and server applications

Convenient data representation

A number of informative views (Call Tree, Hot Spots, Threads Tree and more) allow insightful examination
of profiling results
. The importance of each function call is represented with descriptive icons, along with
precise execution times and other relevant information. You can open functions in individual tabs, easily

navigate views with keyboard shortcuts, and focus on relevant calls.

Snapshot view

Annotating snapshots

During performance analysis, you may want to leave a comment about a function and its behavior. dotTrace
provides textual annotations for functions that are saved with the snapshot and can be reviewed later.

Textual annotations

Search and navigation

You can quickly locate functions and navigate to their calls. When searching for a function, you can
type in its abbreviated name using CamelHumps, just like you do in ReSharper.

Find function

You can highlight all function occurrences in the current view and then navigate between them with
a simple press of a key.

Comparing snapshots

dotTrace is able to compare any two performance snapshots of the same application. It generates a
comparison snapshot which shows the difference in the number of calls and times consumed by each function.
Comparison snapshots can be viewed and analyzed the same way as regular performance snapshots.

Performance snapshot comparison

Quick function info

You can look up function statistics from different views that dotTrace provides. The lookup window provides
a summary of function information with, such as number of calls, and time taken by calls.

Integration with Visual Studio

You can launch profiling of your applications right from Visual Studio 2010, 2012, 2013, and 2015. In fact, in
recent versions of dotTrace you can manage your profiling sessions and view Timeline profiling results right in a
Visual Studio tool window.

dotTrace Timeline in Visual Studio

Profiling unit tests

If you have ReSharper installed in Visual Studio, you can easily start profiling unit tests from the code editor or
ReSharper's unit test runner

Profiling unit tests from ReSharper unit test runner in Visual Studio

Even if you don't have ReSharper installed, you can still profile a native unit test runner provided by NUnit, MSTest,
or xUnit.

Estimation of performance gains

Sometimes, after hours of optimizing a time-consuming function, developers are forced to start profiling from scratch
to see if their optimization actually worked.

Instant estimation (Adjust Time)

This is not a problem anymore. dotTrace can recalculate all function timings in a snapshot instantly, based on a time
adjustment that you set — without reprofiling your application. It's like asking the profiler: "what if I optimize this
function by 40%?"
Just specify the new time for a function or for all functions in a particular class. Time values for
the entire snapshots will be recalculated.

Filtering and formatting

dotTrace lets you hide irrelevant functions from a snapshot and highlight important ones. Filter out system calls
and other non-essential functions with a combination of different filters. To emphasize important functions or classes of
functions, use custom formatting rules.

Formatting important functions

Folding calls

In addition to filtering and formatting, dotTrace provides a few more options to focus on the most relevant profiling
results. For example, you can:

  • Hide functions that take 0% of root time
    You can hide functions that only call other functions but don't do any calculation on their own.
  • Fold filtered calls
    Chains of filtered calls can be set to be folded by default or folded/unfolded manually.
  • Fold recursive calls
    Recursive call chains can be folded to display the aggregate timings and call counts of all functions called

Manufacturer News

Manufacturer News

Support Center

For technical support email or call us on:

5 Best Sellers