ReSharper 9.1.3 to the Rescue

Visual Studio 2015 RTM users, please be informed that ReSharper 9.1.3 is now available for download, along with corresponding updates to all other ReSharper Ultimate tools.

This update fixes the annoying editor issues that were on display in ReSharper 9.1.2 and that included inverted keyboard input, disappearing caret, and focus switching off the text editor, potentially resulting in Visual Studio crashes.

Additionally, this update fixes ReSharper’s XAML code generation features in Visual Studio 2015 RTM.

If you use Visual Studio 2015 RTM, this is a recommended update for you. If you’re on older versions of Visual Studio, namely 2013, 2012 and 2010, you can skip this update.

If you have previously applied one of the suggested workarounds to improve the behavior of ReSharper 9.1.2, we suggest that you now revert the changes so that Visual Studio uses a single UI for displaying both ReSharper’s quick-fixes and Visual Studio’s quick actions.

We would like to once again apologize for the problems caused, or, to put it the 9.1.2 way, for the psmelbor cdesua.

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

Critical Issue with ReSharper 9.1.2 in Visual Studio 2015 RTM: Workarounds and Estimates

UPDATE! The behavior described below is supposedly fixed in ReSharper 9.1.3. Apologies to everyone affected, and please install the new version.

Sometimes bad releases happen, and it looks like this week’s ReSharper 9.1.2 was one of them.

What initially looked like a locale-specific problem turned out to be a universal hindrance for Visual Studio 2015 RTM users, with symptoms such as inverted keyboard input (sgnirt instead of string), disappearing caret, focus switching off the text editor, and random crashes.

We should point out that these problems only affect Visual Studio 2015 RTM users. If you are working in Visual Studio 2013, 2012 or 2010, you are not affected by this problem and you can safely continue using ReSharper 9.1.2.

Yesterday and today we have gathered symptoms and communicated with end users in this issue, and as of now, we have already applied a fix and we are testing it internally.

We will deploy an update as soon as possible this week. Meanwhile, if you are using ReSharper 9.1.2 in Visual Studio 2015 RTM and experiencing symptoms described above, here’s what you can do:

  1. Go to ReSharper’s editor appearance options (ReSharper > Options > Environment > Editor > Editor Appearance) and disable Enable action bar for action indicators and show it next to the left margin.
  2. Go to in ReSharper’s code analysis options (ReSharper > Options > Code Inspection > Settings) and disable Do not show Visual Studio bulb (VS action will be merged into ReSharper bulb).
  3. If none of the above helps, disable ReSharper (Tools > Options > ReSharper Ultimate > Suspend Now).
  4. Install ReSharper 9.1.3 as soon as it is published later this week.

We apologize for causing the problem to Visual Studio 2015 RTM users. We’ll be updating our testing infrastructure to help spot similar problems in future.

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

ReSharper 9.1.2 for Visual Studio 2015 RTM

Update! ReSharper 9.1.2 has proven to be unstable in many Visual Studio 2015 RTM installations. If you’re affected, please apply available workarounds until ReSharper 9.1.3 is available.

Visual Studio 2015 and .NET Framework 4.6 were both released to market yesterday. Kudos to Microsoft for making this finally happen.

We thought we would come up with a quick guide to help you sort out what to expect from ReSharper integration into the final RTM build of Visual Studio 2015. Here’s what you should know:

  • For those of you wondering if you need ReSharper in Visual Studio 2015 at all, look no further than this comparison table that gives an overview of ReSharper’s benefits over bare Visual Studio 2015.
  • ReSharper 9.1.1 does work with Visual Studio 2015 RTM although it does have a few known issues. The major issue with 9.1.1 is that it is blocking Visual Studio’s quick actions: whenever both ReSharper and Visual Studio detect a problem and provide a fix, you don’t have a way to choose Visual Studio’s quick action over ReSharper’s.
  • To solve the 9.1.1 integration problem outlined above, we have prepared and just published ReSharper 9.1.2. It provides two critical fixes:
    • As was the case with ReSharper integration into pre-release builds of Visual Studio 2015, ReSharper 9.1.2 merges its own quick-fixes and other contextually available actions with Visual Studio’s own quick actions into its Alt+Enter menu:
      ReSharper and Visual Studio actions merged into ReSharper's menu
    • ReSharper 9.1.2 maps Visual Studio’s shortcut for displaying quick actions (Ctrl+.) to its own Alt+Enter menu. In other words, you can use either Ctrl+. or Alt+Enter to display ReSharper’s menu that encapsulates ReSharper’s and Visual Studio’s actions. Previous versions of ReSharper suppressed Ctrl+. instead of taking advantage of it.

    If you are using Visual Studio 2015 RTM, please download ReSharper 9.1.2 to enjoy these integration improvements. Corresponding updates to other ReSharper Ultimate tools are also available.

  • As announced before, we expect to release ReSharper 9.2 in August, and it is currently available via Early Access Program. ReSharper 9.2 will focus on properly supporting Windows 10 application development, as well as ASP.NET 5 development based on the most recent ASP.NET 5 milestone available by then. We’ll also be monitoring if there are any major Visual Studio 2015 integration issues discovered by then, and if they are, we’ll fix them.

We hope you’ll find Visual Studio 2015 RTM as good as it gets and enjoy it even more when you download ReSharper 9.1.2.

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

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.

Conclusion

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 , , , , , | 11 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 , , , , | 3 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.

Enjoy!

Posted in How-To's | Tagged , , , | 3 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