ReSharper Unified NuGet-based Installer. How?

Recently we published a post explaining some user-visible aspects of the ReSharper Ultimate unified installer. This post attracted lots of feedback regarding the underlying technologies that we used to build the installer. That was probably to be expected, as building a modern-looking installer is quite a hard task. You can either choose to use the standard .msi and accept its limitations and old-school UI, or build your own installer. Of course, the latter requires a lot of effort to re-implement all the standard functionality.
MSI or a custom installer?

In ReSharper, we chose the second way — ‘the road less traveled’ — with a view to a better user experience.

Before I get to the nitty-gritty details, let me formulate the task we set out to solve.

We desperately needed a common installer for our .NET lineup. One that would not only allow our customers to install several products (like ReSharper, ReSharper C++ and dotCover) in one click, but also simultaneously register these products in Visual Studio. For this purpose, we needed to physically share registered binaries of the products that a user chooses to install.

At some point we realized that the designed logic of maintaining product compatibility and performing updates goes far beyond .msi capabilities. We decided to go with the custom .exe installer. Initial design also included such features as automatic updates, support for ReSharper extensions, a lightweight web installer, support for pre-release versions, etc.

When we started working on the new installer, we’d already had some experience in working with NuGet for the ReSharper extensions gallery. That’s why we decided to use NuGet as a primary means for distributing product packages. But before distributing packages, you need to build them first! Previously we had built a bunch of DLLs using a dedicated MsBuild script for every product. The unified installer forced us to invert dependencies in our build system and create a new build script that could support composition.

Direct vs inverted dependencies

Unified Build System

MsBuild had many disadvantages that we wanted to overcome in our build system:

  1. Composability.
    Our build script should operate on folders and collect all parts of the product introspecting subfolders. During development, we needed to be able to work with an arbitrary subset of our products (including the ‘all products’ scenario).
  2. Isolation and control.
    A lot of problems were caused by the fact that MsBuild parametrization is exposed in a shared state. The lack of static typing and development tools support for build scripts also made us dislike the technology.
  3. Difficulties in creating custom steps.

We noticed that it was extremely easy for us to compile all our projects, which contained almost no custom build logic. The magic occurs when we already have the binaries and are, therefore, able to execute the code from these binaries. We used some features of our component model to express build steps right in the code of our projects. This script is responsible for building NuGet packages, packing installer standalone tools and many other tasks. To execute the script, we load the compiled assemblies and execute the application model similarly to the one we use in our products. This also implied creating custom annotations and a system of build steps that operate on build artifacts. As all the dependencies are inverted, the core build script contains generic operations which are extended in product-specific projects.

Artifact pipeline

An important part of the build system is its dependency on the folder layout. Special annotations are used to create packages encapsulating DLLs and other content.

Encapsulating DLLs and other content into NuGet packages

Our local and remote build infrastructure still uses .csproj files, but only to keep the ability to edit projects in Visual Studio. We are considering different ways to fully switch to file-system-based projects, and the approach used in the recently introduced .xproj project format looks very promising. Our build tool is capable of switching between source and binary dependencies, so you’re free to choose what project you want to be able to edit and what to keep only as a binary. MsBuild doesn’t have native support for this, so we use a set of hacks to make the switch possible.

Sharing the code of a build script and the production code was a great experience for us. Some results of build tasks could be serialized, saved into NuGet packages and used directly at run-time or in an installation script. For example, the component model (a set of classes marked with specific attributes) can be saved at build time and then used at application start-up. This allowed us to significantly reduce the time of the first start-up. In the build script, we also take advantage of using dependency injection and application model.

Installer. Packages and Introspection

Using our build system, we build packages and collect metadata for each package. These metadata are used by the installer to populate the list of products. More specifically, the data are used to expose Visual Studio registration options, product name, and some other options. The installer introspects either our Azure-hosted NuGet gallery (in case of the web-installer) or the local file-system-based gallery (in case of the full installer).

Installation Script

For the installation script, we employed the same approach used in our composite build system. Actually, the script restarts the machine-specific part of the build script extracted from the packages of a specific product. Machine-specific data are passed as an input parameter. The data include local installation directories, machine registry, specified isolation root-suffix and so on. The build script execution system is designed with respect to error isolation and is highly fault-tolerant. The same applies to the installer UI code. The build script is also designed to have no side effects. All temporary data are stored in memory and only the final step performs a limited number of operations on the file system and registry. These operations are stored for safe roll-back in case a user uninstalls the product.

Installation script

Visual Studio Registration

Visual studio has a lot of new MEF-based interfaces which make it easy to install an extension. Unfortunately, there are still some COM-based entities that require an additional effort to generate manifests or special resources. We use generation to avoid code duplication and get rid of potential errors. One of the most complex things is .cto files containing definitions for actions and menus. In ReSharper, we have our own elaborated action system, which also allows us to declare actions in the source code. Here is an example of how actions are defined in our code:

ReSharper action system code sample

Using our build script infrastructure, we load ReSharper actions of all installed products and issue an assembly that contains the .cto file generated specifically for the installed products.


ReSharper unified installer is a high-tech piece of software. Unfortunately, it is too bound to the ReSharper component model, metadata and application model, meaning we can’t share it without sharing our build system, project organization pattern and application model. Nevertheless, we hope that the underlying ideas like composite solutions, functional-style build system described in the application code, application-driven installation and NuGet-based deployment might see wider use at some point.

Posted in How-To's | Tagged , , | 7 Comments

Early Access to ReSharper 9.2, ReSharper C++ 1.1, dotTrace 6.2

Following our plan to deliver ReSharper Ultimate updates every 3-4 months, we are today opening an Early Access Program for ReSharper 9.2 and other ReSharper Ultimate tools. Specifically, this EAP encompasses ReSharper 9.2, ReSharper C++ 1.1, dotTrace 6.2, dotCover 3.2, dotMemory 4.4 and dotPeek 1.5.

Below is a quick overview of what this update has to offer today.

ReSharper 9.2 EAP

The initial build of ReSharper 9.2 EAP is mostly about bug fixes in TypeScript support, IntelliSense and C# code analysis.

  • TypeScript support has received a respectable bunch of fixes. For example, renaming and moving TypeScript code is now expected to be faster in most cases as search for dynamic references is disabled by default (RSRP-427718, RSRP-432856). In other news, ReSharper now draws the line between user code and included libraries/modules, which should positively impact code analysis, navigation and refactorings in multiple scenarios (RSRP-428775). More bug fixes cover the way how features such as Go to Type Declaration and Generate Missing Members handle TypeScript code. In addition to bug fixing, there’s an ongoing effort to provide final support for TypeScript 1.5, and the initial ReSharper 9.2 EAP build comes with support for TypeScript decorators (RSRP-435162).
  • In terms of code analysis, a set of false positives related to PCL usage with .NET Framework 4.5, with or without Xamarin, has been removed (RSRP-394695, RSRP-427743), in addition to several memory usage and performance optimizations (RSRP-437348, RSRP-436891, RSRP-428652). A number of fixes improve code analysis of string interpolation in C# 6 (RSRP-437019), as well as regular expressions (RSRP-440290, RSRP-439698, RSRP-441299).
  • Code completion is now properly case-sensitive again (RSRP-428005) and works a lot faster on extension methods (RSRP-434561)
  • Another notable set of changes is a usability boost to Go to Usages: a non-modal version of Find Usages. The Go to Usages pop-up now includes context of discovered usages, as well as a progress bar, which is handy when you’re looking at heavily used symbols (RSRP-420796).

See the entire list of fixes included in ReSharper 9.2 EAP build 1.

ReSharper C++ 1.1 EAP

ReSharper C++ 1.1 EAP is definitely more feature-packed than ReSharper 9.2.

First and foremost, it introduces a unit test runner for Google Test. This lets you invoke tests and test cases contextually from the text editor:
Invoke tests or test cases from a ReSharper C++ context menu
Similar to how the mainline ReSharper supports other unit testing frameworks, you have Unit Test Explorer and Unit Test Sessions tool windows to view, group, filter and run unit tests, as well as to create and manage unit test sessions.
ReSharper C++ 1.1 can run unit tests based on Google Test framework

At this point you can’t debug unit tests with ReSharper C++ but expect this to change soon.

In other news, ReSharper C++ 1.1 introduces a new refactoring, Introduce namespace alias, available via its Refactor This menu:

Introduce namespace alias refactoring

As soon as you invoke the refactoring, it suggests defining a scope that you want to introduce a namespace alias for:

Defining a scope to introduce a namespace alias

Rounding up a feature set for ReSharper C++ 1.1 is a new hierarchy view called Includes Hierarchy which, quite naturally, helps you visualize and figure out your #include dependencies:

Includes Hierarchy in ReSharper C++

Finally, ReSharper C++ 1.1 brings a whole set of bug and performance fixes in numerous subsystems, from code inspections to formatting, from quick-fixes to live templates: here’s the entire list of fixes included in ReSharper C++ 1.1 EAP build 1.

dotTrace 6.2 EAP

dotTrace 6.2 EAP introduces a new Incoming HTTP Requests event in Timeline mode that helps you indicate time intervals where your web application processes incoming HTTP requests. This includes the time between receiving a request by the server and sending a response. When the Incoming HTTP Requests event is selected, the Filters window contains two sub-filters: URL to determine how much time does a request to a particular URL take, and Method to check the distribution of time between requests with particular methods. You are encouraged to provide your feedback on this feature right here on the blog or in comments under feature request DTRC-10192.
Incoming HTTP Requests

See the entire list of fixes included in dotTrace 6.2 EAP build 1.

dotMemory, dotCover, dotPeek and SDK

EAP builds of dotMemory, dotCover and dotPeek haven’t received any notable updates so far but we expect this to change as the EAP progresses.

ReSharper SDK will be published later, along with one of the upcoming ReSharper EAP builds.

Download them!

Feel free to download EAP builds and let us know how this update is working for you.

Early Access is a great time for you to provide your feedback, so please feel free to submit any issues with EAP builds to issue trackers for ReSharper, ReSharper C++ and dotTrace.

What’s next?

Stay tuned for more EAP builds in coming weeks. Considering that Microsoft has just set Visual Studio 2015 release date to July 20th, we’ll be looking to wrap up this Early Access Program within a month and come up with ReSharper 9.2 RTM in August, as announced earlier.

Posted in News and Events | Tagged , , , , , , | 11 Comments

ReSharper 9.2 Expected in August, Will Support Visual Studio 2015 RTM, Windows 10

As we have recently released ReSharper 9.1.1 and more ReSharper Ultimate updates, you might be wondering what we have in store for the remainder of the year. This is even more important to know considering that Microsoft is expected to reach a couple of major milestones in upcoming months, specifically the final releases of Visual Studio 2015 and Windows 10.

First of all, as you might have noticed from recent releases coming out of JetBrains, we are making a habit of updating ReSharper Ultimate products every 3-4 months.

We want to keep this pace further on, which means that a new update to ReSharper (version 9.2) and other members the ReSharper Ultimate family is expected to release in August 2015.

Let’s see what we expect ReSharper 9.2 is to provide:

  • Support for Visual Studio 2015 RTM. That’s right: you don’t have to wait for a new major ReSharper release to enjoy full support for the final bits of Visual Studio 2015: ReSharper 9.2 will bring it to the table.
  • Support for Windows 10 universal applications. Windows 10 is set to release in coming months as well, and ReSharper 9.2 will work with Windows 10 universal applications and hopefully provide dedicated coding assistance to help with the adaptive coding pattern that is widely used in Windows 10 application development.
  • Solid support for ASP.NET 5 including the new tag helper syntax and getting the unit test runner to cope with DNX.
  • More improvements in terms of unit testing, C#6 and ECMAScript 6 support.

Speaking of other products that are part of the ReSharper Ultimate family, a significant point is that the upcoming ReSharper C++ update (1.1) will add an hierarchy view for include directives, improve support for C++11 and introduce a set of new refactorings.

We expect to open an Early Access Program for ReSharper 9.2, ReSharper C++ 1.1 and other ReSharper Ultimate tools by early July, so stay tuned!

Posted in News and Events | Tagged , , , , , | 13 Comments

Introducing Source Templates

ReSharper’s Live Templates are a very powerful way of generating code. Type the name of a template, hit Tab or select the template from the code completion list, and the text template is expanded and inserted into the editor. Any using statements are automatically added, the code is reformatted and you can tab between interactive, editable fields. To make them even more powerful, each field can be bound to a macro that will provide a code completion list of items that are generated dynamically, or taken from the surrounding context.

For example, the nguid template expands to a newly generated GUID, shown in several formats in a completion list. Other macros will invoke smart completion, suggest a variable name, return the name of the file and so on. Add to this support for multi-file templates, surround templates and the ability to save your own templates to a shared solution settings file, and it’s easy to see how Live Templates can help speed up writing code.

And now ReSharper 9.1 introduces Source Templates, to make it even easier to create your own templates – a Source Template is a Live Template that is defined in your own source code.

Example template definition

But why would we want to do this? Why create templates in source, when we can also create them in the Live Templates editor?

There are a couple of reasons. First, it’s very easy – you just define a Source Template as normal code, in a source file in your solution. This will automatically get picked up by ReSharper when checked in, and you don’t have to touch the .sln.dotSettings file. It doesn’t get any easier than that!

Second, the big difference from traditional Live Templates is that Source Templates are also extension methods. This means that your Source Template will be strongly typed – both ReSharper and the compiler will verify that the code is correct, doesn’t have typos, includes the right using statements, and of course you get all the usual ReSharper goodness while editing your template – code completion, inspections, navigation and best of all, the template is updated if code is refactored.

Making the Source Template an extension method has an interesting effect on how it’s invoked. Traditional Live Templates can only be invoked at certain places, usually at the start of a declaration, statement or expression. A Source Template is invoked as an extension method. That is, a Source Template will be available only after you press “ .” on a compatible expression – similar to the way the PostFix plugin’s functionality is invoked. For example, the traditional foreach Live Template is available only where you would normally enter a foreach statement (but not in an if statement, or inside a call to Console.Write). In contrast, the example foreach Source Template shown above is available as though it were an extension method, and appears in the completion list after typing “ .” following an expression or variable of type IEnumerable<T>. The expression used as the target of the extension method replaces all usages of the extension parameter in the template.

Example expanding source template

This opens up a very different use case for Source Templates as opposed to Live Templates. You can now create templates that are specific to a type – so the  foreach template will only apply to objects or expressions that implement IEnumerable<T>. Other Source Templates can be targeted at other types, simply by changing the type that the extension method extends. Think of templates that only operate on strings, or objects that implement INotifyPropertyChanged or  IObservable<T>, or make them available to all objects by extending System.Object.

So how do you create a Source Template? Once you’ve created an extension method, you’ll need to mark it with the [SourceTemplate] attribute. This is one of ReSharper’s annotation attributes, similar to [NotNull] and [CanBeNull] which ReSharper can use to to improve analysis inspections and suggestions.

The simplest way to get the annotations is to add a reference to the JetBrains.Annotations nuget package. This is the official JetBrains annotations package, and adds a .dll that contains all of the attributes that ReSharper understands. And don’t worry about adding extra binary dependencies! This package applies the [Conditional] attribute to the annotation attributes, which means that they don’t end up compiled into your assembly. You can deploy your code without copying JetBrains.Annotations.dll.

Once your extension method has been defined as a Source Template, you can also add fields and macros that you can edit and tab between. Fields can be defined as parameters on the extension method, and occurrences inside the method become editable when the template is invoked. You can bind a macro to the parameter with the [Macro] annotation attribute, using the Expression parameter to specify which macro to use (and of course ReSharper gives you code completion here). Alternatively, you can bind a macro to a variable in the extension method, which allows for a macro to suggest the name of a variable, for example, by specifying the Target parameter of the [Macro] attribute. And the Editable parameter allows control over which usage of the field in the method body is editable, even allowing the value to be marked as non-editable.

If you’re familiar with traditional Live Templates, you’ll be aware of the syntax of referring to fields (e.g. $value$) and the use of special predefined field names such as $END$ to specify the final location of the text caret after the template is fully expanded. Source Templates still support these special variables, and the field name syntax, as long as it remains valid C#. For example, you can set the final location of the text caret to be in a string literal: string.Format("$END$");. But to use the value of a field called foo in a variable name, you’d normally need to write var valueOf$foo$ = GetFoo();, which isn’t valid C#. In order to handle these cases, you can use an “expanding comment.” This is a special comment that begins with a dollar sign ( //$ … or /*$ … */). Any text that is inside one of these comments is inserted into the template when it’s invoked, and anything in the standard field syntax ( $foo$) is also expanded. For example, //$ var valueOf$foo$ = GetFoo();.

The help site contains more details on defining Source Templates, including how to specify which macro to bind to a field. And to help you get started writing your own templates, here are some samples:


Posted in ReSharper Tips&Tricks | Tagged , , , , | 4 Comments

JSDoc Support in ReSharper 9.1

Many JavaScript and TypeScript developers have requested JSDoc support in ReSharper, and we have answered their call with this release. Several subsystems in ReSharper 9.1 now work with JSDoc. Let’s take a look on how ReSharper helps workings with JSDoc.

1. Code highlighting

First, we’re now coloring JSDoc comments to make them easier for you to read. To enable color highlighting, go to ReSharper | Options | Code Inspection | Settings and select Color Identifiers check box.

JSDoc code highlighting in ReSharper 9.1

2. Quick documentation

Now you can quickly look at the documentation for any symbol by calling Quick Documentation (Ctrl+Q), similar to how it works in C# and VB.NET.

Quick documentation for JSDoc in ReSharper 9.1

3. Parameter Info and Tooltips

Parameter Info also shows documentation for every signature and parameter:Parameter info for JSDoc

And tooltips are shown too:

Tooltips in code completion for JSDoc in ReSharper 9.1

4. Writing and refactoring

To simplify JSDoc writing for you, we’ve added a new typing assist for generating relevant comments. It recognises “/**” and smartly handles new lines inside your comments. Keyword completion works as well, and what is more, you can start typing a keyword without the leading ‘@’:

Generating JSDoc comments with ReSharper 9.1

When you rename a parameter, ReSharper automatically updates the corresponding JSDoc:

Auto renaming JSDoc comments in ReSharper 9.1

All these features work in TypeScript as well.


Posted in How-To's | Tagged , , , | 4 Comments

Bug Fix Update to ReSharper Ultimate is Available

Hello everyone,

Right after Build 2015, we published ReSharper 9.1.1 Release Candidate with Visual Studio 2015 RC support, and today we invite you to download and try ReSharper 9.1.1 RTM along with ReSharper C++ 1.0.1 and corresponding updates to ReSharper Ultimate tools.

This maintenance update for ReSharper is mostly notable for:

  • Support for Visual Studio 2015 RC. If you’re among early adopters of the newest Visual Studio 2015 builds, please download ReSharper 9.1.1 and let us know if you encounter any problems.
  • Per-machine installation, that can be very handy when several users share a single machine and ReSharper should be available for all of them.
  • 100+ hot fixes in code completion, source templates and other areas. Here’s the full list of fixes and changes included in ReSharper 9.1.1 for your reference.

Please note that ReSharper 9.1.1 doesn’t provide full support for ASP.NET 5 Beta 4 yet. Most of the features are on board, but there are some areas we are still working on. Stay tuned for further updates on ASP.NET vNext support in ReSharper.

ReSharper C++ 1.0.1 receives lots of important improvements as well:

  • Improved code completion including an option to replace “.” to “->” when completing a member.
  • Find Code Issues is now available from Solution Explorer context menu. It brings up Inspection Results window with all ReSharper C++ code highlights, like code quality issues, redundancies and code improvement suggestions. Having all of them in one window is easier than navigating through your code files to find and fix issues.
  • Access specifiers are now represented in a tooltip.
  • Semantic colour highlighting is now turned on by default.
  • Better performance when working with Boost libraries.
  • For the full list of fixes please take a look at release notes.
Posted in News and Events | Tagged , , | 12 Comments

ReSharper Unified Installer. Why?

The ReSharper 9 release introduced a special ReSharper Ultimate bundle. In addition to ReSharper and ReSharper C++, this bundle includes our other JetBrains .NET products: dotCover, dotTrace, dotMemory, and dotPeek.

What made this bundle possible? In the pre-Ultimate era, customers using multiple JetBrains .NET tools together experienced serious performance issues. For ReSharper 9, we worked on a ‘shared platform’ to eliminate this performance overhead. This decision also led to the following:

  • All .NET products are now released on the same day.

  • ReSharper 9 and other shared-platform tools cannot be installed side-by-side with their predecessors onto the same Visual Studio instance. For example, after you installed dotCover 3.0 with switched on VS integration, you would find ReSharper 8 uninstalled. Unpleasant, but unfortunately inevitable.

  • Now, there is only one unified installer for all JetBrains .NET products. Whether you get ReSharper Ultimate, ReSharper, dotTrace, dotMemory, or dotCover, you will download the same installer (though it has different names depending on the product).

The latter consequence, in turn, created another concern. Even if the downloaded installer implies the installation of a single product (say, dotCover), it will contain installation options for our entire .NET product lineup.

Unified Installer

You may ask? “What are all these options for? What can/should I install?“. Of course, you can select just the tool you’re interested in and skip everything from the Available Products section. However, we recommend that you try installing all. Now let us explain why:

  1. No problems with trial licenses
    Having all these Available Products in the installer doesn’t mean you have licenses to the corresponding tools. In fact, the installer is absolutely unaware of this as applying a license is a post-installation step.
    Nevertheless, even if you don’t have a license to a particular tool, that’s OK, as any installed tool automatically gets a trial license. So, you’ll have from 5 to 10 days to give it a try.
  2. No annoying license notifications
    Even after the trial license expires, it will NOT bother you with notifications when Visual Studio starts up (this was really annoying in previous versions). The notification will be shown only in case of an explicit action, e.g. after you try to run profiling with an expired dotTrace license.
  3. More comprehensive development experience 
    This is a good opportunity to try all of the tools and decide whether you need each one in your work. For example, many developers neglect profiling their apps, not realizing that one profiling session may be all that’s needed to reveal a severe yet easily fixable bottleneck.
    Our vision of ReSharper Ultimate is that of a single product that covers most needs a .NET developer may have, rather than a set of separate products. In line with this vision, in ReSharper 9 we discarded separate .NET tool menus. Now, ReSharper’s menu is the only starting point for all your activities with all JetBrains .NET tools:
    R# Menu
    Of course, this is just the beginning and we plan to make this integration even deeper.
  4. Almost no performance penalties
    As we mentioned earlier, it doesn’t matter how many JetBrains .NET tools are currently installed in your Visual Studio. Thanks to the shared platform, there are virtually no performance costs. Nevertheless, if you don’t need a particular tool for your project, you can reduce its impact to zero by disabling it in ReSharper’s Products and Features:
    R# Products and Features

We hope this post answers most of the questions you may have had about the installer. If not, please post them in the comments below. Thanks!

Posted in How-To's | Tagged , , , , | 15 Comments

ReSharper 9.1.1 RC and Matching ReSharper Ultimate Update for Visual Studio 2015 RC

At Build 2015, Microsoft has just announced a new Release Candidate drop of Visual Studio 2015.

For those of you who are migrating to the new Visual Studio 2015 build, please download ReSharper 9.1.1 RC and accompanying updates to other ReSharper Ultimate tools.

Apart from support for the latest drop of Visual Studio 2015, the new ReSharper Ultimate update adds per-machine installation, introduces hot fixes in code completion and source templates, as well as lots of improvements in ReSharper C++.

Note that ASP.NET 5 Beta 4 is not supported so far but the final 9.1.1 release in a few weeks will add support for that as well.

By the way, JetBrains is at Build 2015 with a stand. If you’re at the event, come by and say “hi” or discuss the present and future of JetBrains tools for Visual Studio.

Speaking of Build 2015, Microsoft has also announced Visual Studio Code which is a cross-platform code editor with support for .NET applications. In case you’re wondering, we currently have no plans to integrate with this editor since it’s not extensible.

Posted in News and Events | Tagged , , , , | 5 Comments

Analyzing ineffective memory usage with dotMemory

Memory issues in .NET apps can be generally divided into 1) leaks, 2) large memory traffic, and 3) ineffective memory usage. In this blog we’ve written extensively about how dotMemory helps you deal with the first two problems. Now it’s time to talk about analyzing ineffective memory usage, especially since dotMemory 4.3 introduces a new feature that can help really fight this issue.

Before we move on, let’s agree on some terms. What is ineffective usage? When your app consumes more memory than it should, or could, we call this ineffective. Sometimes you just “feel” that a particular algorithm consumes too much, but nothing seems to explain why it does. That’s when you should use a memory profiler.

Assume you’ve done the profiling and taken a memory snapshot. What next?

There are two main analysis approaches that may be combined or used independently. Start by answering the following two questions:

  • What methods allocate the most memory?

  • What objects retain the most memory?

What Methods Allocate Most of the Memory?

This task is typically solved with the help of a call tree. Most memory profilers have a special call tree view for determining the calls that allocated the largest amounts of memory. Doesn’t sound too complicated, does it? But in fact, even for mid-size projects digging into the tree may become a headache.

Call Tree

Of course, this algorithm is applicable to dotMemory as well. However, since version 4.0 we offer a much easier way called Call Tree as Icicle Chart.

The idea behind the chart is simple – it’s a graphical representation of the call tree. Each call is shown as a horizontal bar whose length depends on the size of objects allocated in the call’s subtree. The more memory allocated in the underlying subtree, the longer the bar. The bar’s color value serves as an additional indicator – the more memory allocated by the call itself, the darker the bar.

Call Tree Icicle Chart

So instead of looking at lots of numbers, start your analysis by opening the Call Tree as Icicle Chart view. In just a glance you can match a certain call with the amount of memory it allocates.

For example, the following chart shows the same data as the Call Tree table in the GIF above. Notice how there’s no need to dive into the call tree: main memory allocations can be seen instantly.

Icicle Chart Example

Of course the chart is interactive: just click a call to see its call stack. Use the Shift+click combination to zoom into the chart and examine the call chain in more detail.

Icicle Chart

Who Retains the Memory?

Understanding how memory is retained in your app is essential for successful optimization. For example, you know that a major part of memory in your app is consumed by strings. Nevertheless, most likely, the subject of your optimizations is not these strings by themselves but the data structures that store them. That’s why “Who retains the memory?” is the next big question when analyzing ineffective memory usage.

Objects that exclusively retain other objects in memory are called dominators. Earlier dotMemory versions offered just one way of analyzing app dominators – the Group by Dominators view, which shows the tree of dominators sorted by retained memory size:

Group By Dominators View

Since version 4.3, dotMemory offers a new “visual” way of analyzing dominators: the Sunburst Chart. In this view, the dominators hierarchy is shown on a sunburst chart. The more memory a dominator retains, the larger the central angle.

Dominators Chart

A quick look at this chart shows what objects are crucial for your app and helps you evaluate the largest structures.

Sunburst Chart

If you click on a particular dominator, the Domination Path on the right will show you the retention path of this dominator. Double-click on a dominator to zoom into the chart and see the objects retained by this dominator in more detail.

Our experience shows that Dominators chart is also very effective when you need to quickly evaluate how a certain functionality works in your app. For example, below are two charts built for an image editor application: the first one was plotted before anything is done in the app, and the second one reflects memory usage after the user has applied an image filter.

Example of Two Dominators Charts

After some time, if you profile your app constantly, you’ll even be able to “see” not only how your app works, but even how particular changes in code affect memory usage.

Thanks for reading! We hope this post was helpful. Give dotMemory 4.3 a try and explore the Dominators and Call Tree charts.

Posted in dotMemory Tips&Tricks, How-To's | Tagged , | 5 Comments

TypeScript and ECMAScript 6 in ReSharper 9.1

As you may know, the working draft of ECMAScript 6 standard has reached the Release Candidate stage. TypeScript, starting with version 1.4, aligns more closely with this new standard while adding some new features of its own. We on the ReSharper team follow the development of both technologies closely: ReSharper 9.1 already provides full support for TypeScript 1.4, as well as initial support for ECMAScript 6 and TypeScript 1.5.

ECMAScript 6 features

ReSharper 9.1 fully supports the following ECMAScript 6 features:

Template strings

ReSharper understands template strings and tagged template invocations and provides support for them in its code assistance features.

Rearrange code works for template string arguments:


Parameter info for tagged templates invocations:


Create from usage allows you to create functions from tagged template invocations:


In addition, ReSharper now provides a refactoring for introducing a variable from a selected substring and adding a new template argument for it:


Of course, ReSharper will also suggest converting your string-expression concatenations to template strings where possible:


2) Lexical, or block-scoped, declarations

ECMAScript 6 introduces the notion of block-scoped declarations, let and const. These declarations, unlike the function-scoped var, are available only within the lexical block-like construct in which they are embraced.

ReSharper provides support for such declarations, as well as inspections and bulk quick-fixes which enable you to convert your var declarations to let and const, if possible. After the conversion it will suggest moving some variables closer to their usages:


Also, the Introduce Variable refactoring now lets you choose variable type:


3) Lambda expressions

ECMAScript 6, similar to TypeScript, now has lambda expressions. ReSharper supports them and provides a context action to convert between lambda representations:


4) Destructuring: bindings and destructuring assignments

ECMAScript 6 introduces destructuring assignments and variable declarations. That means that you may provide a pattern to assign a specified path from the assignment source to some variable or expression. ReSharper 9.1 now supports this feature.


Note that Visual Studio doesn’t currently support all standard options for destructuring declarations and assignments, meaning that valid ECMAScript 6 code may be red in Visual Studio:


5) New numeric literals

ECMAScript 6 introduces a new kind of octal literal as a 0O + number, and binary literals as 0B + numbers. As with the other numeric literal types, ReSharper provides you with an option to convert between these forms and their decimal representation.


As ECMAScript 6 is a huge extension over its predecessor, it’s taking us more time to polish features for it. At this time, ReSharper offers initial support for some of the new ECMAScript features, including for-of loops, computed property names, generators, class declarations, and modules.


We’re hard at work to bring you full support for ECMAScript 6 in the next versions of ReSharper. Stay tuned.

Oh, and please note that ECMAScript 6 support should be explicitly enabled in ReSharper options:


TypeScript 1.4

TypeScript 1.4 brought several new features which ReSharper now fully supports.

Union types represent a notable extension of TypeScript’s type system. With their help, you can avoid losing type information for entities which cannot be represented by a single type.

ReSharper 9.1 provides full support for union types code generation, quick-fixes and context actions. For example, implemented members now use union types whenever possible, and you may specify corresponding union types explicitly for variables which have ‘any’ type.


Union types are accompanied by type guards, which allow you to limit the variable type in a scope surrounded by a type check. ReSharper 9.1 supports them too:


TypeScript 1.4 also introduced type aliases, for providing your own names for complex type combinations. As an extra bonus, ReSharper substitutes them with the aliased type in contexts where the corresponding type alias is not available.


And finally, lexical declarations and template strings were integrated into TypeScript 1.4, and they are supported by ReSharper to the same extent as for plain ECMAScript 6.


TypeScript 1.5

TypeScript 1.5 is coming, representing an even bigger step forward compared to ECMAScript 6 support. ReSharper is catching up with the new features introduced into the language.

Destructuring variable declarations and assignments are supported:


ReSharper is also aware of ES6-style export and import declarations, and provides familiar assistance to what you had with TypeScript’s own exports and imports:


Starting with TypeScript 1.5, it’s no longer possible to use TypeScript-style exports and imports when targeting ECMAScript 6. No problem! ReSharper will help you migrate your code to adhere to this new requirement:


TypeScript 1.5 also introduces the notion of well-known symbols from ECMAScript 6, and they are fully supported, too:


And finally, the for-of loop is supported:


Note that TypeScript 1.5 support in ReSharper 9.1 is still experimental and has the following technical limitations:

  • Simultaneously exporting “default” and other elements from a module is not currently supported by ReSharper 9.1.
  • Using ECMAScript 6 specific features requires you to add “lib.es6.d.ts” file to your solution. For use with ReSharper it should be renamed to “lib.d.ts”.
  • Decorators are not currently supported.

All these technical limitations will be addressed in the next version of ReSharper, which is expected to provide full support for TypeScript 1.5.

Posted in How-To's, ReSharper Tips&Tricks | Tagged , , , | 16 Comments