dotTrace 5.5.2 Performance is available

We are excited to announce availability of an update to our performance profiler.

Please welcome dotTrace 5.5.2 Performance!

This is a minor update that contains a lot of important fixes, such as:

  • Updated Subsystems UI;
  • Stack walker fix;
  • Correct processing of situations when it’s not possible to open a file (DTRC-9235);
  • Improved snapshot name generation to get rid of symbols that cannot be used in a file name (DTRC-9339, DTRC-9342 and DTRC-9232);
  • Improved .NET Framework 4 support: more threads are now shown in Sampling mode and when profiling applications via Attach to Process.

Please download dotTrace 5.5.2 Performance if you have experienced any of the problems above.

Posted in dotTrace Tips&Tricks, News and Events | Tagged , | Leave a comment

Are you sold on ReSharper 8?

Calling ReSharper users! We are running a survey to learn more about your upgrade patterns and more specifically, your motivations for upgrading to ReSharper 8 or skipping this major release altogether.

You will have an opportunity to win one of ten $50 certificates, OR one of ten free personal licenses, OR one of ten personal license upgrades for ReSharper.

The survey will take 7-10 minutes to complete and will run November 1, 2013, through November 25, 2013. Winners will be announced December 10, 2013.

Your opinion is very important to us and we thank you in advance for taking part in our study. We ask that you complete the survey in one sitting.

To begin now, please continue to our ReSharper Users’ Upgrade Patterns Survey.

Posted in News and Events, Other | Tagged , , | 2 Comments

Architecture Tools: Improvements in ReSharper 8.1

In ReSharper 8, we brought out an entirely new feature called Architecture Tools (or, alternatively, Project Dependency Analysis). The goal of the Architecture Tools is simple: to let users visualize and manipulate the structure of their solution. In ReSharper 8.1, we’ve made a number of improvements that we’d like to show you.

User Interface Improvements

Following user feedback, we’ve slightly redesigned the UI to make it even easier to use. Changes include the following:

  • The action bar has been moved from the area just above the project selection list to the top right-hand side of the diagram, closer to where the graphical elements are.
  • We’ve improved the responsiveness of many UI elements. For example, the expand/collapse buttons have been made more snappy, and their tooltips are more responsive, too.
  • We now have a more convenient context menu for items related to a particular selection. We’ve also added three new items: Show Only Target and Source, Add Dependent Modules and Add Referenced Modules.
  • Last, but not least, is the rendering of the graph on changes. Re-layouting the diagram is now incremental, so that only the affected part of the diagram gets rearranged. The following recording illustrates just how smooth and fluid it’s become:
    ReSharper Architecture View Smoothness

Undo/Redo Support

To make it easy to view different sets of projects in the Architecture View, the tool now supports undo/redo: simply pressing the corresponding buttons on the toolbar (or using the Ctrl+Z and Ctrl+Y shortcuts) takes you back and forth between the configurations that you’ve set up for your diagram:

ReSharper Architecture View Undo/Redo Support

Possible Path

Sometimes, while selectively showing a part of your solution in a diagram, you might end up with a situation where two projects are linked indirectly via a 3rd project, and yet it is that in-between project that happens to be hidden. In ReSharper 8.1, we’ve introduced a new kind of arrow to indicate this indirect relationship:

ReSharper Architecture View Possible Path

In the illustration above, the green arrow indicates that ReTrack.Tests uses ReTrack.Engine indirectly via a third project. The dashed arrow itself also has a context menu item to display the in-between projects:

ReSharper Architecture View Show Path Context Menu

And one last thing…

Since the Architecture View can get quite involved in large solutions, additional optimizations have been performed so that the rendering of the Architecture View has become both faster and more memory-efficient, so there’s no reason not to check it out. You can see it in action right now — simply download the latest ReSharper 8.1 EAP build and give it a go!

Posted in News and Events | Tagged , , , , | Leave a comment

TypeScript Support in ReSharper 8.1

We have just recently announced TypeScript support as part of ReSharper 8.1 EAP, and this blog post is intended to give you more details on this exciting development. Note that ReSharper 8.1 is only the first milestone in supporting TypeScript, and while we’re ready to show a first set of TypeScript features, there’s still quite a long journey ahead.

Typing Assistance and Code Completion

Just like all the other languages ReSharper supports, TypeScript support in ReSharper 8 includes the following:

  • Various forms of typing assistance such as automatic creation of closing quotes and terminal braces as well as overtype support.
  • Support for live templates, ReSharper’s powerful alternative to Visual Studio snippets providing enhanced functionality such as e.g. insert/replace behavior on tab/enter.
  • Support for code completion for both static and dynamically typed variables. TypeScript annotations are also used to enhance code completion in JavaScript files.
  • Ability to rearrange code (more on this in a later section).


As with other languages, ReSharper provides various navigation options, such as Go to Everything as well as its various specializations, such as Go to Member:

ReSharper 8.1 TypeScript Go to Member Navigation

As you might expect, contextual navigation also works throughout TypeScript files – for any element, you can bring up the Navigate To menu and search for the source of the declaration or the location where this is used. When searching for usages of a property, for example, ReSharper is capable of locating both the so-called smart usages (where the type is intelligently inferred) as well as other usages with similar name. (Incidentally, this feature is available for both TypeScript and JavaScript.)

ReSharper 8.1 TypeScript Find Smart Usages

This is also available in element references to HTML and CSS related entities. For example, you can find usages of the .ui-tooltip-top class below, which will take you to the HTML page where that style is used:

ReSharper 8.1 TypeScript Navigate To Menu


Our initial TypeScript support comes with two refactorings. The first is the Introduce Variable refactoring that lets you create a variable for the selected part of code. This refactoring is also sensitive to the number of occurrences of the same value when introducing a variable:

ReSharper 8.1 TypeScript Introduce Variable Refactoring

The other refactoring is Rename refactoring, whose name should be self-explanatory. Naturally, this refactoring also looks at references to the old name in the string literals and offers a chance to fix usages there too:

ReSharper 8.1 TypeScript Rename Refactoring Usages in Comments and String Literals

The Rename refactoring for TypeScript is also capable of detecting structurally compatible members, and offers to perform a rename on them too, as shown below:

ReSharper 8.1 TypeScript Rename Refactoring Structurally Compatible Members

Rearrange Code

Just as with other languages ReSharper supports, TypeScript support includes the Rearrange Code feature that lets you quickly change the position of code blocks within the file. To use it, step on e.g., a function, a hold the Shift+Ctrl+Alt keys:

ReSharper 8.1 TypeScript Rearrange Code

Now, simply press the ↑Up or ↓Down keys to move the selected block in the file. This feature doesn’t just work for high-level constructs, but also for smaller ones (e.g., lambdas), where it’s possible not only to rearrange the position of the block but also use the ←Left and →Right keys to move the selected item in and out of different scopes. Also, this mechanic is available for rearranging arguments.

ReSharper 8.1 TypeScript Rearrange Code Block

And finally, TypeScript support also includes the support for the greedy brace: using the same shortcut key combination, you can essentially move the opening or closing brace of a code block to leave in/out any part of that block outside of scope:

ReSharper 8.1 TypeScript Greedy Brace

Code Inspections

In the tradition of supporting various languages, ReSharper performs continuous checking of TypeScript files for errors and inaccuracies. For example, ReSharper is able to detect unused parameters:

ReSharper 8.1 TypeScript Inspection Unused Parameter

It’s also able to detect invalid CSS references

ReSharper 8.1 TypeScript Inspection Invalid CSS Reference

…as well as perform general stylistic clean-up such as, e.g., finding and fixing missing semicolons — note the Fix in Scope mechanic that’s available here:

ReSharper 8.1 TypeScript Semicolon Quick Fix in Scope

Things to Come

At the moment, our TypeScript support is still a work in progress, and we’ve got a lot more to do: support for the type system (e.g., hierarchy navigation), generics and contextual typing are still in the works, and we’re working hard to bring them to you as soon as possible.

For the time being, check out ReSharper 8.1 EAP and let us know what you think!

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

dotCover 2.6 Early Access Program Launched

Good news for those who has already started using Visual Studio 2013! Today we are launching the Early Access Program for dotCover 2.6 with Visual Studio 2013 support. Grab the latest EAP build and feel at home in your updated IDE.

Moreover, dotCover 2.6 integrates with the latest ReSharper 8.1 EAP builds.

Please download dotCover 2.6 EAP build, and don’t forget to let us know about any issues you might experience via dotCover issue tracker.

Posted in dotCover Tips&Tricks, How-To's, Links and Opinions, News and Events | Tagged , | 6 Comments

Webinar Recording: Build Your Own Extension in ReSharper 8

The recording of our October 22nd webinar with Matt Ellis and Robert Demmer, Build Your Own Extension in ReSharper 8, is now available on JetBrains YouTube Channel and

This webinar is aimed at anyone interested in extending ReSharper. We’ll have a quick look at how to get started writing plugins, and talk about some of the more interesting extension points. Then we’ll take a walk through an example of extending ReSharper without any code, using Live Templates and Structural Search and Replace patterns, from definition to packaging and distribution. Matt’s presentation can be found here.

About this webinar

ReSharper has always had many extension points for plugins to take advantage of. This webinar will look at how you can extend ReSharper not only by writing code, but also declaratively, with Live Templates, Structural Search and Replace patterns and ReSharper 8′s NuGet-based extension manager.

This webinar is aimed at anyone interested in extending ReSharper. We’ll have a quick look at how to get started writing plugins, and talk about some of the more interesting extension points. Then we’ll take a walk through an example of extending ReSharper without any code, using Live Templates and Structural Search and Replace patterns, from definition to packaging and distribution.

Stay tuned for updates and news on upcoming webinars.

Posted in How-To's, ReSharper Tips&Tricks | Tagged , , , , , , , | Leave a comment

ReSharper 8.1 Early Builds Available for Download

It’s that time of the year again when we open up the covers on what’s been cooking in ReSharper since the release of 8.0 a few months back! And while today we’re opening ReSharper 8.1 Early Access Program, there’s nothing minor about the new features that we’ve got in store for you.

Here are some of them that you can check out right now.

TypeScript Support

The key focus for this release is the support for the TypeScript programming language. Support for TypeScript includes the following:

  • Refactorings such as Rename and Introduce Variable, with detection of identifiers in strings as well as detecting of structurally compatible members.
  • Navigation support including support for Go to Everything and smart usage search (an ability to search for structurally similar constructs). Note that both Rename and the navigation features work in dynamically typed parts of code, too!
  • Code completion support.
  • Support for rearranging code, including the greedy brace mechanic.
  • Code inspections such as an ability to detect unused parameters, detect invalid CSS references, and many others.
  • Deep integration with other parts of the project, i.e. HTML, CSS and JavaScript. This includes inspection, navigation and other features.

JavaScript projects also benefit from TypeScript support. For example, even in a pure JS project, you can improve ReSharper’s code completion by including TypeScript type definitions for your libraries. To get them, search for DefinitelyTyped on NuGet. Also, note that smart usage search and smart Rename mechanisms are available for JavaScript, too.

Stay tuned for an in-depth post on TypeScript coming very soon!

Support for Visual Studio 2013

ReSharper has included support for Visual Studio 2013 since version 8, but version 8.1 enjoys better integration with two new supported features. The first feature is Peek Definition. ReSharper integrates transparently into this feature, providing a lot more functionality than Visual Studio. For example, ReSharper can show decompiled method definitions, whereas Visual Studio can only show method stubs:

ReSharper 8.1 Peek Definition Decompile

ReSharper’s contextual navigation is also available in this mode, and any element navigated to shows in this same window.

Also, features such as Find Usages or Find Inheritors and many others that return large result sets now show them using the Peek Definition API in the list on the right:

ReSharper 8.1 Find Usages

Another feature that ReSharper supports is the enhanced scroll bar — a feature very similar to ReSharper’s own marker bar. ReSharper places its markers alongside this bar, together with tooltips and an ability to click to navigate to a particular issue:

ReSharper 8.1 Enhanced Scroll Bar

And don’t worry, if you prefer to use the old marker bar, we give you this option as well — you can find it in ReSharper’s Options under Environment | Editor | Editor Appearance.

Code Analysis

One of the major pain points we’re addressing in 8.1 is infinite loop detection – for those embarrassing times where you inadvertently made an infinite loop by failing to change the loop condition anywhere within the loop.

ReSharper 8.1 Infinite Loop Detection

Another complaint that’s been addressed relates to ReSharper complaining about values possibly being null in LINQ even when an explicit check has already been made. We’ve updated our LINQ nullness analysis so that the following code no longer triggers any complaints from ReSharper:

ReSharper 8.1 Nullness LINQ Analysis

Yet another inspection issues a warning in downcast in foreach statement, another potential source of bugs:

ReSharper 8.1 Warning in Downcast Foreach

XAML Improvements

  • Completion improvements, including double completion for resource references and command name completion (see this blog post for info on the double completion mechanic).
  • An update to the usage inspection mechanism, including WPF 4.5 static property notification support.
  • A mechanic to import types on paste, just like the one we currently have in C#.
  • ThemeDictionary support for WinRT 8.1.
  • Various typing assistance mechanisms, including smart handling and deletion of XAML braces, smart deletion of XML attribute quotes, as well as a mechanic to convert an attribute to an element on the press of the Enter key.

Architecture Tools

Our latest creation, the Architecture tools, are getting some love as well. Latest improvements include:

  • Better overall performance of analysis and rendering.
  • Improvements in UI fluidity and smoothness, including smooth repositioning animations when graph elements are added or removed.
  • Undo/redo support.
  • A new option for drawing edges called Possible Path. Shows up as green dashed reference lines and implies that even though there are no direct references between currently selected projects, there is a path between them consisting of one or several projects. These reference lines also have a Show Path context menu item.
  • Many improvements were made in response to user requests – for example, we made more convenient context actions to get desired graph selection:
    ReSharper 8.1 Architecture View Selection Context Menu

Odds & Ends

Our standalone tools InspectCode and dupFinder have also gotten some love in the form of better error validation and output as well as support for plugins.

The tool windows that ReSharper uses have been redone using WPF. New tab items now show up on the left, they look better, you can pin them, and if you open more than five tabs, old tabs unload themselves, saving memory — but you can always restore them if you need to.

Things to Come

Here are some of the things we’re still working on, which will appear as part of the 8.1 release:

  • Improved JavaScript support. We’re working on improvements in renaming, navigation as well as support for Structural Search and Replace (SSR) for this language.
  • Various improvements to TypeScript support beyond those mentioned above.
  • Improved support for High-DPI monitors, so those of you with Retina displays have a more pleasant experience.

While we’re preparing for final release, feel free to download ReSharper 8.1 EAP builds and let us know how this new update is working out for you!

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

Fix in Scope: a New Code Cleanup Experience in ReSharper 8

As you all know, ReSharper has lots of inspections, all of varying complexity. Some inspections present a multitude of choices – for example, when ReSharper meets an undeclared symbol, it has no idea what to make of it. Does the user want it as a parameter, a local variable or perhaps a field or property of the containing class?

On the other hand, plenty of fixes are unambiguous. Some examples include:

  • Redundant using statements

  • Redundant this. prefix on class members

  • Properties with backing fields that can be transformed into auto-properties

There are two ways that users can interact with these inspections. The first, and most direct, way is via a quick-fix — that little pop-up that shows up in code when the cursor is at a location where a fix can be applied:

Remove redundant qualifier quick-fix

Another option is to invoke a predefined set of fixes in bulk at the scope of a file, folder, project or solution. This is the Code Cleanup mechanism that can fix a configurable set of issues in every file in the selected scope:

Code cleanup options

However, in ReSharper 8 we’re introducing a new mechanism that we call Fix in Scope. This feature is an extension of the quick-fix mechanic that lets you either apply the fix just in a particular location or, alternatively, you can expand the menu and pick a wider scope for the fix to be applied:

ReSharper 8 Fix in Scope

Here’s a video overview of Fix in Scope — one of several videos about ReSharper 8 available on YouTube:

It is our hope that this feature helps you streamline fixes of a particular type when you need to do them en masse. For example, you’re starting a new project, and a default project template generates lots of plumbing with lots of unnecessary using statements. Just move the cursor over one of the unused directives, expand the Remove unused directives in file, pick Remove unused directives in project and you’re done — extraneous using statements in all files in the project will be instantly removed!

At the moment, Fix In Scope supports a set of features provided by Code Cleanup. Here’s a (hopefully) complete list:

  • Remove code redundancies, including the removal of
    • Explicit integer type specifiers for enumerations
    • true specifiers in for statements
    • Redundant type casts
    • Redundant qualified references
    • Redundant this qualifiers
    • Redundant parentheses from attributes without arguments
    • Explicit calls to base class constructors without arguments
    • Redundant boolean comparisons
    • Redundant braces from collection initializers with a single expression
    • Redundant explicit delegate creation expressions
    • Empty argument lists from object/collection initializers
    • Redundant new keywords
    • Redundant partial modifiers on type declarations where a type has a single part
    • Redundant unsafe contexts and statements
    • Redundant object.ToString() calls (for example, in a concatenation with a string or as an argument of a string.Format() call)
    • Redundant string.ToCharArray() calls
    • Redundant specifications of type arguments
    • Signatures in anonymous methods where its parameters are not used in the method body
    • Non-referenced labels
    • Redundant field initializers
    • Redundant explicit names in anonymous type properties
    • Redundant nullable types where value type is implicitly convertible to nullable

    as well as the following conversions:

    • Nullable types to short form (Nullable<T> to T?)
    • Static method invocations to extension method calls where extension methods are invoked as static methods
    • Conversions to implicitly typed array creation expressions when array type can be inferred from initializer
  • Use auto-property if possible
  • Make field read-only, if possible
  • Use ‘var’ in declaration, inculding options to
    • Use ‘var’; or
    • Specify type explicitly
  • Optimize ‘using’ directives
  • Optimize ‘import’ directives
  • Shorten qualified references
  • Remove redundant qualifiers
  • Terminate statements
  • Optimize register directives

In the future, we plan to expand the set of supported inspections to make the process of code improvement even more streamlined. Meanwhile, we suggest you check out ReSharper 8 and let us know what you think!

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

Live Webinar: Build Your Own Extension in ReSharper 8, Oct. 22

Join us Tuesday, October 22nd, 14:00 – 15:00 GMT (10:00 – 11:00 EDT) for our free webinar, Build Your Own Extension in ReSharper 8 featuring Matt Ellis.

ReSharper has always had many extension points for plugins to take advantage of. This webinar will look at how you can extend ReSharper not only by writing code, but also declaratively, with Live Templates, Structural Search and Replace patterns and ReSharper 8′s NuGet-based extension manager.

This webinar is aimed at anyone interested in extending ReSharper. We’ll have a quick look at how to get started writing plugins, and talk about some of the more interesting extension points. Then we’ll take a walk through an example of extending ReSharper without any code, using Live Templates and Structural Search and Replace patterns, from definition to packaging and distribution.

Space is limited; please register now. There will be an opportunity to ask questions during the webinar.

About the Presenter:

Matt EllisMatt Ellis is a Technical Evangelist at JetBrains. He has been a professional developer for nearly 20 years, shipping software for BBC Worldwide, BNP Paribas and Egg, the UK’s first Internet bank. He is an open source creator and contributor, owning projects such as the test runner for ReSharper. He believes in clean code, simplicity and standing on the shoulders of giants.

Posted in How-To's, ReSharper Tips&Tricks | Tagged , , , , , | Leave a comment

ReSharper 8.0.2 is Released

Well it’s that time again: another bug fix update to ReSharper 8 is available.

This time though, most of you would be safe skipping it since it targets quite a limited part of ReSharper customers.

You’d benefit from downloading and installing ReSharper 8.0.2 if you were unable to use 8.0.1 despite having an active upgrade subscription. As it turned out, customers who have purchased ReSharper 7 with upgrade subscription from end of July to end of August 2012 were unable to make use of 8.0.1 although they were entitled to 3-digit updates for 8.0. Version 8.0.2 fixes this issue and should work fine with subscriptions purchased within this period.

Apart from resolving the problem highlighted above, this update only contains 2 more fixes: one related to assembly resolve with certain web.config configurations (RSRP-369336) and another one that has to do with navigation between usages discovered with Find Usages Advanced (RSRP-383894).

Posted in News and Events | Tagged , | 15 Comments