Performance Optimizations in ReSharper 8.x

One of the most popular questions we’re facing as soon as we push a new release is whether it works faster than before.

ReSharper performance has a ton of dependencies related to hardware, Visual Studio configuration (including other installed extensions as well as native VS components like XAML Designer) and ReSharper’s own configuration. Nevertheless, the team always finds ways to improve the product’s performance. This is an ongoing process across all our releases, and 8.x is no exception.

Let’s take a look at where exactly ReSharper 8.x became faster: overall UI responsiveness, coding assistance, code analysis, and unit testing. No mile-length lists*, just highlights.

*For those who are interested in statistics, it’s 170+ improvements (and growing).

Coding Assistance

When the auto-completion pop-up takes seconds to appear, I get the urge to smash the monitor or throw my keyboard across the room. Can you blame me? Well, since the coding assistance improvements in ReSharper 8.x I’ve gotten way more peaceful, and hopefully you will too.

  • Lower Impact on Typing
    All phases of code completion have become interruptible. What does this mean for you? Typing should be much smoother now as it doesn’t interfere with coding assistance.
  • Faster Displaying of Lookup Items in Pop-Ups
    Now we cache all lookup items in Intellisense, meaning it works faster on the second run and all subsequent ones. For example, here are two call stacks taken with dotTrace for ReSharper 7 and ReSharper 8 correspondingly. Both reflect the second run of an auto-completion pop-up showing a list of graphic files available for selection within the project.
    VS 2012 with ReSharper 7
    R#7 displaying lookup items
    VS 2012 with ReSharper 8
    R#8 displaying lookup items
    Thanks to caching introduced in ReSharper 8, the method that gets the results completes 16 times faster.

We’ve also fixed many other small assistance issues, like hangups during smart completion in VB, lags when erasing long symbol sequences, and more. Though most are minor, when taken together they result in a tangible performance improvement.

Code Analysis

Code analysis is also an area we consider to be crucial from the performance perspective. Even though solution-wide analysis is carried out in the background, poor performance here can lead to noticeable lags in Visual Studio. That’s why we’ve made some tweaks in this area.

  • Optimized Solution-Wide Analysis
    Solution-wide error analysis (SWEA) now utilizes the CPU much more efficiently. As a result, SWEA is finished a little bit faster, especially on complex solutions. What is more important, solution-wide analysis has a lower impact on the UI, thus improving its responsiveness.
    On the screencasts below, you can see how typing performs in ReSharper 7 and 8 at the same stage of solution-wide analysis.
    VS 2012 with ReSharper 7
    R#7 Solution-wide analysis
    VS 2012 with ReSharper 8
    R#8 Solution-wide analysis

Overall UI Responsiveness

Many of you complained about lags in the user interface when performing some ordinary actions in the UI: lags during code editing, slow loading of context menus, slow auto-completion on JavaScript, and others.

It’s no secret that most of these problems are related to numerous tasks that ReSharper is doing in the background. These background tasks became our main target for optimization in 8.x releases.

  • Faster Solution Building / Loading
    We’re constantly working to reduce ReSharper’s impact on the performance of Visual Studio’s native features. As our tests show, Visual Studio with ReSharper 8.x builds a solution up to two times faster than Visual Studio with ReSharper 7. Moreover, VS with ReSharper 8.x loads a solution nearly 20% faster.
  • Faster Caching
    ReSharper loads its caches much faster now. Among many improvements here, we optimized the way ReSharper works with its database that stores caches. The database (and your hard drive) is now accessed far less frequently.
    As a result, there are no lags when typing while the caches are being loaded. Exact numbers are difficult to evaluate as they are highly dependent on solution complexity.
  • Optimized Memory Usage
    We did our best to minimize memory traffic in main ReSharper usage scenarios. This should significantly lower the number of cases when Visual Studio UI hangs for a moment and then continues working. For example, consider such a common operation as Find Usages.
    The diagrams below show memory traffic (for ReSharper 7 and 8 correspondingly) when searching for all string usages in a large project.
    VS 2012 with ReSharper 7
    R#7 Memory traffic
    VS 2012 with ReSharper 8
    R#8 Memory traffic
    As you can see, the traffic in ReSharper 8 has dropped 15%. As we said before, large memory traffic causes excessive Garbage Collections which, in turn, lead to UI freezes (true for GCs longer than 200 ms). If you want to know how we fight such bottlenecks, it’s a combination of the Timeline view* in dotTrace and a new dotMemory tool (yep, we’re strong dogfooding followers). Timeline in dotTrace allows detecting all UI freezes (yellow stripes on the timeline diagram show Blocking GC) while dotMemory lets us determine exact objects that cause the traffic.* (This view will be available in the upcoming dotTrace 6.0.)Timeline view in dotTrace
    The snapshot was taken when typing during solution-wide analysis.

Unit testing

The unit testing subsystem was also redesigned for ReSharper 8 to eliminate the key annoying lag that users complained about in ReSharper 7.

  • Faster Start of Unit Tests
    We’ve entirely reworked the way ReSharper runs tests. ReSharper 7 took a lot of time (whole seconds) before the tests were actually run. In ReSharper 8.x, it’s no longer a problem: tests are run almost instantly.
    VS 2012 with ReSharper 7
    R#7 Running unit tests
    VS 2012 with ReSharper 8
    R#8 Running unit tests

Your Help is Invaluable in Improving ReSharper’s Performance

Of course, we would never be able to find all these issues without the ReSharper community. Yes, we mean you, our valued customers and fans!

The main problem when fighting performance issues is that they are very hard to test and reproduce. The thing is, they are very sensitive to the environment: the complexity of your solution, installed Visual Studio plugins or NuGet packages, system components, and other factors. For obvious reasons, we are unable to test ReSharper on all possible environment combinations. And that’s where you can help us tremendously.

Profile Visual Studio menu

If you suspect ReSharper may be slowing down your work in Visual Studio, follow these steps to make sure that ReSharper is indeed the culprit. If it is, run the built-in dotTrace profiler (go to ReSharper | Help | Profile Visual Studio), profile Visual Studio and send a performance snapshot our way. We will look at your performance snapshot, locate the bottleneck and do our best to fix it.

As outlined above, we made a lot of performance optimizations to bring you the improved ReSharper 8.x. But of course we’re not stopping there. For ReSharper 9, we plan to do a lot more work in terms of improving performance. Stay tuned!

Posted in Other | Tagged , | 6 Comments

dotCover 2.7 EAP is Open

Spring is here and so is dotCover 2.7 Early Access Program. Now you can download and play with EAP builds. Please welcome integration with ReSharper 8.2 EAP and Standalone runner.

27 eap

We would be happy to get your feedback via dotCover issue tracker. Stay tuned for further updates.

Posted in dotCover Tips&Tricks, News and Events | Tagged | 5 Comments

Webinar Recording: dotMemory 4.0 – What’s Inside

The recording of our February 25th webinar with Maarten Balliauw, dotMemory 4: What’s Inside, is now available on JetBrains YouTube Channel and slides on slideshare.

In this webinar we explore the new dotMemory 4 memory profiler. We share our view on why one may want to use a memory profiler and show how easy it is to use dotMemory to find and solve memory issues.

Even if your program is just a few lines of code, .NET’s runtime will create a number of objects in memory. Are all objects being destroyed by the garbage collector? Or is there a potential memory leak? And why is the application seemingly slow when having lots of objects in memory? Find out in this webinar.

Below are select questions and answers from our webinar:

Has dotMemory 4 been released already?
No, not yet. We currently have an EAP version available for everyone to try. Do give us feedback if you’re using it! The final release will be there around the end of April.

Can dotMemory profile .NET 4.0 applications?
Yes it can! dotMemory allows memory profiling of applications written in .NET (all versions up to 4.5.1) and Silverlight, as well as Windows Store applications.

For more information on dotMemory, please see our blog post dotMemory 4.0 EAP: .NET Memory Profiler Resuscitation.

Maarten BalliauwMaarten Balliauw is a Technical Evangelist at JetBrains. His interests are all web: ASP.NET MVC, PHP and Windows Azure. He’s a Microsoft Most Valuable Professional (MVP) for Windows Azure and an ASPInsider. He has published many articles in both PHP and .NET literature such as MSDN magazine and PHP architect. Maarten is a frequent speaker at various national and international events such as MIX (Las Vegas), TechDays, DPC and others.
Posted in dotMemory Tips&Tricks | Tagged , , | Leave a comment

ReSharper for C++ Early Access Program Goes Public

Do you recall how we announced that ReSharper was going to support C++ last summer? Well we’re still serious about that: as serious as the folks who are working next door on a separate, cross-platform, IntelliJ-based C++ IDE.

We’ve been running private ReSharper C++ Early Access Program (EAP) for several months now. Out of 1200+ developers who subscribed to receive private builds, over 600 did in fact receive them. Great thanks to all subscribers who, by virtue of submitting info about their development environments, helped us significantly in sorting out what to support in a priority fashion and what to leave in the backlog for now.

As we now have a sufficiently good idea of how devs are working on C++ in Visual Studio, there’s little sense to keep the gates closed. That said, we’re now opening ReSharper C++ EAP to the public.

Before you go and download and play with the latest EAP build though, you should totally read the following and mind the limitations that are inherent to the current state of ReSharper C++ EAP. Here are the things you should know about ReSharper C++ EAP.

What is supported

  • C, C++03 and a part of C++11
  • Code bases up to 40Mb
  • Most Boost libraries

What is not supported

  • Code bases exceeding 40Mb
  • Microsoft libraries including MFC, ATL and WTL
  • Certain C++11 features including variadic templates, raw string literals and trailing return types. Lambdas are supported partially
  • An array of MS preprocessor extensions
  • An even wider array of MS C++ extensions

If you’re not sure if a C++11 feature or an MS C++ extension that you’re using is supported, the ReSharper C++ EAP page contains a full list of known issues and unsupported items, which you’re highly encouraged to examine before you decide to download and install an EAP build.

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

Introducing ReSharper 8.2 EAP

Yes, you read that right. We’ve just released the EAP version of 8.2, which replaces the previous 8.1.1 EAP.

We’ve been working hard on fixes and especially on improved TypeScript support, and we’ve decided that the number of new features should be a whole new version, and not just a maintenance release. We’ll publish a blog post soon taking a look at some of the changes.

As ever, with a new minor release, we’ve got some changes to APIs, which means existing plugins need to be updated. Plugin devs can find some guidance on our resharper-plugins Google Group.

You can download ReSharper, as well as the ReSharper Command Line Tools from the ReSharper 8.2 EAP page. Give it a go, let us know how you get on.

Posted in How-To's, News and Events, ReSharper Tips&Tricks | Tagged , , , , , | 23 Comments

Webinar Recording and Q&A: ReSharper Secrets with Igal Tabachnik

The recording of our February 13th webinar with Igal Tabachnik, ReSharper Secrets, is now available on JetBrains YouTube Channel.

In this session you will learn about ReSharper hidden gems, powerful annotations and 3rd party plugins to help you become a true ReSharper ninja!

Watch as Igal takes you behind the scenes of ReSharper and shows you how to use this knowledge in your own code, to get even more out of ReSharper. The intended audience is intermediate-to-advanced ReSharper users.

We received a lot of questions during the webinar and we’d like to use this opportunity to include the most frequently questions, as well as those we didn’t have a chance to answer during the webinar.

Q&A on Igal’s Visual Studio setup and ReSharper plugins that he uses

Q: Where does that “number of references” annotation in Igal’s Visual Studio come from?
A: It is called CodeLens. This feature is a part of Visual Studio 2013 Ultimate but is not included in any of Visual Studio’s lower-end editions. Addressing a related question, no, we’re not planning to replicate the functionality of CodeLens in ReSharper.

Q: What ReSharper plugins does Igal use?
A: He uses a whopping 14 of them! Here’s the full list:

  1. Agent Mulder
  2. Enhanced Tooltip
  3. JetBox
  4. Nancy Plugin for ReSharper
  5. Preview Tab Behaviour
  6. Go to Word
  7. InternalsVisibleTo Helper for ReSharper
  8. NuGet support for ReSharper (bundled plugin)
  9. Postfix Templates
  10. ReSpeller Pro
  11. Live Template descriptions
  12. xUnit.net unit test provider
  13. Joar Øyen’s extensions for ReSharper
  14. Locate File or Folder in Solution Explorer

If you’re using ReSharper 8.0 or above, go to ReSharper | Extension Manager to install any of these plugins.

Q: What was the tool that changed .var into a variable assignment?
A: This cool plugin is called Postfix Templates. If you want to have it installed, go to ReSharper | Extension Manager | Online and search for postfix. If you’re ready to contribute, here’s the plugin’s github repo.

Q&A on code annotations

Q: Does using ReSharper’s code annotations have any performance impact?
A: No. They are just attributes, thus they do not affect your compiled assembly’s performance. As for ReSharper performance, the attributes are cached and the analysis is run even without attributes, so there is no performance difference there.

Q: What do I need to do exactly for importing the annotations?
A: There are two options. First, you can paste the source code of JetBrains annotations into your project. To do that, go to ReSharper | Options | Code Annotations | Copy default implementation to clipboard. Paste that into a new file, and you’re done. The second option is to reference a library called JetBrains.Annotations.dll that you can take from ReSharper’s installation folder.

Q: Can I have a single annotations file in the entire solution, or is Annotations.cs created for every assembly/project you create?
A: You are free to put Annotations.cs in a shared assembly, as long as it’s referenced.

Q: Do I need to ship the library containing annotations with my code?
A: If you add annotations by referencing JetBrains.Annotations.dll, then yes, you’ll need to ship the dll with your application. If you add them as a source file, they are compiled in your assembly, and there are no extra references to ship.

Q: What if a project uses ReSharper annotations, but another developer does not have ReSharper installed? Do these annotations work for them?
A: No, the warnings and analysis are provided by ReSharper. The annotations essentially provide hints for ReSharper’s analysis. If you don’t have ReSharper installed, they are just attributes that no one uses.

Q: Can I make ReSharper treat everything as [NotNull] by default so that and I can use [AllowNull] instead?
A: You can change ReSharper’s default assumption by going to ReSharper | Options | Code Inspection | Settings and change the value of Assume entity value can be null. The default value is optimistic (assumed to be not null) but you can change it to pessimistic (assumed to be null).

Q: Regards [Pure] can ReSharper not simply look at the method return type as not being void instead?
A: No, because e.g. string.ToUpper() is a pure method. It returns a new string without changing any of the fields of the current string instance. Calling it without assigning to a variable is pointless. If we add [Pure], ReSharper will warn you that the return value is unused.

For more information on using code annotations, see ReSharper online help and two prior blog posts: ReSharper NullReferenceException Analysis and Its Contracts and Contract Annotations in ReSharper 7.

Join us Tuesday, February 25th for our next webinar, dotMemory 4: What’s Inside with Maarten Balliauw.

Igal TabachnikIgal Tabachnik is a software developer from Israel, who values clean code, test-driven development and continuous refactoring to reduce complexity, reduce bugs and achieve better design. He frequently speaks at local ALT.NET and Software Craftsmanship user groups. Igal is also the author of the Agent Mulder plugin for ReSharper, a plugin that helps ReSharper understand DI containers, providing navigation to and finding usages of types registered or resolved by those containers.
Posted in ReSharper Tips&Tricks | Tagged , , , , , | 9 Comments

Live Webinar – dotMemory 4: What’s Inside, February 25th

Join us Tuesday, February 25th, 15:00 – 16:00 GMT (9:00 – 10:00 AM EST) for our free webinar, dotMemory 4: What’s Inside with Maarten Balliauw.

Even if your program is just a few lines of code, .NET’s runtime will create a number of objects in memory. Are all objects being destroyed by the garbage collector? Or is there a potential memory leak? And why is the application seemingly slow when having lots of objects in memory?

In this webinar, we’ll explore the new dotMemory 4 memory profiler. We’ll see why we want to use a memory profiler and how easy it is to use dotMemory for that. There will be an opportunity to ask questions during this webinar.

Space is limited, please register now.

Maarten BalliauwMaarten Balliauw is a Technical Evangelist at JetBrains. His interests are all web: ASP.NET MVC, PHP and Windows Azure. He’s a Microsoft Most Valuable Professional (MVP) for Windows Azure and an ASPInsider. He has published many articles in both PHP and .NET literature such as MSDN magazine and PHP architect. Maarten is a frequent speaker at various national and international events such as MIX (Las Vegas), TechDays, DPC and others.
Posted in dotMemory Tips&Tricks, How-To's | Tagged , | 1 Comment

JavaScript Improvements in ReSharper 8.1

With JavaScript’s continuous rise to fame, it only makes sense for us to continue improving JS support in ReSharper. The following is an exposition of some of the new ways in which ReSharper 8.1 makes JavaScript coding faster as well as safer.

Completion Helpers via TypeScript

When working with pure JavaScript files, it’s actually possible to improve ReSharper’s code completion functionality by including TypeScript type definitions in your libraries. In order to add this kind of support, you need first of all to search NuGet for DefinitelyTyped packages:

NuGet search for DefinitelyTyped packages

Without the TypeScript annotations, ReSharper’s code completion is limited by what it can infer from the source JavaScript file. Since JavaScript is a dynamically typed language, it is not always possible to acquire complete information regarding the imported symbols and the relationships between them. That is why, apart from the inferred members (which are shown in bold in the completion list), ReSharper also shows all properties of all symbols found in the current solution. In this case, however, it is up to the user to check whether a particular element does in fact have a particular member which, in itself, is a potential cause of additional errors.

For example, in the above use of underscore.js, ReSharper is not able to infer the properties of the _ (underscore) symbol, and thus the developer has to pick from all identifiers. In addition, function parameter information is not available.

JavaScript completion without TypeScript information

After the addition of the strongly typed definitions from the *.d.ts file, ReSharper shows the members that are permitted for the _ symbol in bold, and proceeds to offer those members by default. This reduces the risk of error.

JavaScript code completion with DefinitelyTyped definitions

Also, ReSharper is able to provide information about function parameters:

JavaScript parameter information via DefinitelyTyped definitions

JavaScript SSR

The ReSharper Structural Search & Replace (SSR for short) lets you perform search and replace operations not with a fixed search string or a regex pattern, but rather allows you search for a structural definition that lets you match individual constructs, such as variable names, literals, and so on. And now it’s available in JavaScript.

So let’s start with a simple example of searching for a declaration of objects with a single property assignment:

ReSharper 8.1 JavaScript SSR

The above pattern uses the Name placeholder to locate anything that can be considered a variable or property name. The Find Results window then gives you a listing of all the locations code matching the pattern has been found.

Of course, finding things is only half of what you can do, because you can also perform replacements. For example, say you wanted to replace explicit Array declarations with square-brace syntax. Here’s how you would define such a pattern:

ReSharper 8.1 JavaScript SSR Search with Pattern

This pattern uses yet another placeholder which allows $args$ to represent any number of arguments to a function.

It’s important to note that SSR mechanisms are semantically aware. Here’s an example: searching for a condition $x$ > 100 will correspondingly match if (100 >= x):

ReSharper 8.1 JavaScript Conditional Inversion Match

Similarly, prefix and postfix operators are matched interchangeably, assuming, of course, that no assignments are made:

ReSharper 8.1 JavaScript Postfix Prefix Matching

Also note that SSR ignores non-significant tokens such as curly or round braces or semicolons:

ReSharper 8.1 JavaScript SSR Ignore Insignificant Tokens

And finally, it’s possible to generate search patterns directly from code:

ReSharper 8.1 JavaScript Find Similar Code

File Structure Window Improvements

One of the biggest problems with JavaScript development is actually figuring out the organizational structure that a block of JS code represents. To facilitate this, the File Structure window has been redone to facilitate the presentation of both JavaScript and TypeScript code. Let’s take a look at some of the features.

First of all, function names are inferred either from declarations or variable names:

ReSharper 8.1 JavaScript File Structure Function Name Inference

ReSharper is also able to determine element names from documentation when they are not available explicitly:

ReSharper 8.1 JavaScript File Structure From Documentation

The file structure window uses an ellipsis … to indicate additional arguments. Consider the varArgsFunction below; it sees that the arguments value is being used:

ReSharper 8.1 JavaScript File Structure Parameter Inference

Some function call expressions actually represent higher-level constructs called modules. ReSharper attempts to recognize these structures and present both their private and exported members. Note that, for a constructor, we try to present its fields, too:

ReSharper 8.1 JavaScript File Structure Module Support

Smart Usage Search

We’ve already mentioned this in our blog post on TypeScript, but it bears reiterating: ReSharper 8.1 supports a new feature called Smart Usage Search. When searching for usages of a property, for example, ReSharper is capable of locating both the ordinary usages as well as so-called smart usages – usages where the type is intelligently inferred. The end result appears as follows – note that the feature is supported in both JavaScript and TypeScript:

ReSharper JavaScript and TypeScript Smart Usages

That’s It (For Now)

We hope you enjoy these new features! Rest assured, we continue to work hard on JavaScript and TypeScript support in ReSharper, so expect to see new features soon!

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

Live Webinar: ReSharper Secrets with Igal Tabachnik, Feb. 13th

Join us Thursday, February 13th, 15:00 – 16:00 GMT for our free webinar, ReSharper Secrets with Igal Tabachnik.

In this session you will learn about ReSharper hidden gems, powerful annotations and 3rd party plug-ins to help you become a true ReSharper ninja! Igal will take you “behind the scenes” of ReSharper, and show you how to use this knowledge in your own code, to get even more out of ReSharper.

The intended audience is intermediate-to-advanced ReSharper users. There will be an opportunity to ask questions during the webinar.

Space is limited; please register now.

Igal TabachnikIgal Tabachnik is a software developer from Israel, who values clean code, test-driven development and continuous refactoring to reduce complexity, reduce bugs and achieve better design. He frequently speaks at local ALT.NET and Software Craftsmanship user groups. Igal is also the author of the Agent Mulder plugin for ReSharper, a plugin that helps ReSharper understand DI containers, providing navigation to and finding usages of types registered or resolved by those containers.
Posted in How-To's, News and Events, ReSharper Tips&Tricks | Tagged , , , | 4 Comments

ReSharper 8.1.1 Goes EAP: More TypeScript Support + Fixes

There’s got to be at least one more maintenance release in the 8.x family, and we’re taking the first step in this direction.

ReSharper 8.1.1 EAP is, first of all, about expanding TypeScript support. Apart from architecture improvements that you can’t see right away, v8.1.1 brings popular ReSharper features to TypeScript such as naming inspections, “create from usage” quick-fixes and navigation combos with support for path filtering in Go to Everything, Go to File, Go to Type:

Other than that, ReSharper 8.1.1 EAP brings a (modest) set of fixes that are mostly related to unit testing (4 fixes) and ReSharper Command Line Tools (5 fixes). Here’s the entire list of issues fixed in 8.1.1 so far.

At this point we suggest that you download ReSharper and/or ReSharper Command Line Tools from the ReSharper 8.1.1 EAP page only if you’re interested in TypeScript development and/or if any of the fixed issues are directly relevant to you; otherwise you can safely skip this EAP.

Posted in How-To's | 8 Comments