We have just opened ReSharper Ultimate 2016.3 Early Access Program, and if you like using the latest technology, go ahead and download the first build.
Changes include further evolution of TypeScript support, more ways to inject languages, initial support for C# 7.0 and .NET Core unit tests.
For details on what’s inside, expect another blog post early next week.
Along with multiple performance improvements and bug fixes, dotMemory 2016.2 brings one long-awaited feature: comparison of memory snapshots stored in different workspaces (or in other words, snapshots collected in different profiling sessions).
When might this be helpful? Generally, in any situation where the data you need compared cannot, for some reason, be collected in one profiling session. For example, you want to find out how particular code changes affect memory usage in your application. In this case you need at least two profiling sessions: before and after changing the code.
It’s really simple.
This will open the Cross-workspace comparison view. Here you can see how many objects of a particular type exist in both snapshots. Since it’s impossible to match object lifetime data between sessions, the view won’t show you “new” and “collected” objects (which the regular “within-session” snapshot comparison does show). Nevertheless, in most cases, this data should be enough for further analysis.
For example, you can quickly detect a problem when the same workflow in your application (e.g., before and after you commit changes) leads to a different number of objects in your application’s namespaces.
Consider downloading ReSharper Ultimate and giving this new feature a try.
Sometimes, a bug fix release needs a bug fix of its own.
That’s what happened to ReSharper this time: yesterday’s 2016.2.1 release introduced a bug whereby running Code Cleanup would incorrectly introduce access modifiers ahead of static constructors (RSRP-460771).
If you’re affected by this bug, please download and install ReSharper Ultimate 2016.2.2, and apologies for making you update twice.
Try again. Fail again. Fail better. 👈
Although dotTrace 2016.2 mainly focuses on performance and bug fixes, it also gets one easy-to-miss yet important new feature, which has to do with how dotTrace Timeline Viewer shows recursive calls.
Recursive call stacks can be deep and difficult to analyze. Before 2016.2, Timeline Viewer showed call stack “as is”, i.e recursive calls were simply shown as they were called — one after another in the stack trace. Of course, on complex call stacks with multiple recursive calls this resulted in almost infinite stack scrolling. Now, dotTrace 2016.2 allows you to fold such calls to simplify stack analysis.
For example, let’s take a look at the call stack of a simple application that recursively copies files from a directory and its subdirectories, and reports the progress (the example below is shown for a directory with 3 subdirectories).
This is how it looked in dotTrace Timeline Viewer 2016.1:
And this is how the same stack looks in dotTrace Timeline Viewer 2016.2 when recursive calls are folded:
dotTrace recalculates the tree of recursive calls (it summarizes call times in all recursive subtrees) and presents the information by function signatures. Folded recursive calls are marked with the 
icon.
After you unfold a call (by clicking the icon), you get the familiar stack representation when all recursive calls are shown one after another as they were called. Unfolded recursive calls are marked with the 
icon:
Note that you don’t necessarily need to fold the entire recursive call tree. You can also fold/unfold any part of the recursive subtree:
We hope you find this feature helpful and that it does help you simplify the analysis of complex call trees. To try it on your own, download ReSharper Ultimate 2016.2.
We have just published a bug fix update to ReSharper Ultimate 2016.2.
This release contains a fine selection of 70 hand-picked bug fixes across ReSharper, ReSharper C++ and dotCover.
We have released ReSharper Ultimate 2016.2 last week, which introduced a whole lot of updates across ReSharper, ReSharper C++ and dotPeek, as well as a bunch of fixes and improvements in dotTrace, dotCover, and dotMemory.
In case you feel that reading a multi-screen list of what’s new is too daunting, our old friend Hadi Hariri has come up with an under-10-minutes summary video:
In the video, Hadi uses a lot of code samples from a special repository that we maintain in order to illustrate changes in new ReSharper Ultimate versions in a very code-centric way.
If you like to learn what’s new in the latest ReSharper by playing with code that exposes the recent improvements, go ahead and clone this repository, which you can navigate using ReSharper’s own To-do Explorer.
We at JetBrains have just finalized an update to the ReSharper Ultimate family, and we welcome you to download ReSharper Ultimate 2016.2 RTM!
Read on for the main highlights of this release:
In addition to 750+ fixes, major highlights of ReSharper 2016.2 are the following:
MethodName(.) with MethodName()., and correcting mistyped @$ prefixes for verbatim string interpolations.Omg, 'dot after semicolon' is cool too, all three typing assistance handlers working together: pic.twitter.com/OkYTl7zqWO
— Alexander Shvedov (@controlflow) May 22, 2016
for loops, or fix awaiting of a void method by making it return Task. (By the way, existing quick-fixes that make methods async now suggest using Task instead of void.) In other news, you can now check all parameters of a method for null (or empty strings) with a single context action. You can even uncomment or even delete a comment via Alt+Enter. 
/*language=html*/ ahead of a string literal. You can now use the Mark HTML here action to enjoy syntax highlighting, error detection and other HTML goodies right inside the string literal./*language=regexp|jsregexp*/ before the string literal. 
<inheritdoc/> tag in XML documentation comments, which is a good alternative to copying documentation from base types/members to derivatives.++ and -- operators as well as before and inside parenthesis of checked and default expressions.
ctorf/ctorp, overrides, lambdas).this for functions, control flow aware type guards, path mappings, optional class members, the never type.
ReSharper C++ 2016.2 comes with 200+ fixes and a set of larger improvements:
#pragma once directive. Another new inspection detects a missing default case in a switch statement with a corresponding fix to add it.[[deprecated]]/__declspec(deprecated) attribute. 
decltype(auto).[[noreturn]]/__declspec(noreturn) attribute in control flow analysis.#include directives in generated code.0, nullptr or NULL as the preferred initializer in the options, and ReSharper C++ will use it in generated initializers.#include directives are added automatically.
return, throw etc.), ReSharper C++ will automatically highlight all other exit points.__RESHARPER__ macro that allows you to detect when ReSharper is parsing your source code and, if necessary, disable ReSharper’s preprocessor for some code.
Other ReSharper Ultimate tools have received their shares of improvement as well.
/ProcessFilters parameter. For example, /ProcessFilters=+:prA;+prB will exclude all processes except prA and prB; /ProcessFilters=-:prC will exclude prC from the coverage.Recursive call stacks can be deep and difficult to analyze. Previously, Timeline Viewer would show call stacks “as is”, i.e recursive calls were simply shown as they were called: one after another in the stack trace, which would lead to long scrolling. With dotTrace 2016.2 Timeline Viewer, you can easily fold such calls to streamline stack analysis.
dotMemory now allows you to compare memory snapshots stored in different workspaces: that is, collected in different profiling sessions. This can be useful to check how particular changes in code affect your application’s memory usage. All you need are two snapshots taken before and after making the changes.
For the full list of fixes in dotMemory 2016.2 please refer to release notes.
If you have an active subscription for ReSharper, ReSharper C++ or ReSharper Ultimate, we encourage you to start using 2016.2 straight away.
As we have just recently switched to subscription licensing, some of you may still use older, pre-subscription licenses. If you are not sure whether your licenses are eligible to use with 2016.2, or if you need a formal quote or any other assistance, please get in touch with JetBrains sales anytime.
Ladies and gentlemen, you can now download ReSharper Ultimate 2016.2 Release Candidate!
All new features and improvements that we have revealed and blogged about in recent months are now in pre-final state.
This includes things as exciting as textual search via Go to Text, structural navigation with Tab, and warnings in solution-wide analysis, as well as more mundane fixes, of which there are plenty.
If you still have pressing issues with 2016.2 RC or if something that we assume fixed doesn’t actually solve your issues (btw, everyone who has been unhappy about Move to Folder behavior with TFS, we’re waiting for you to confirm a fix), this is probably your last chance to let us know via comments here, or better yet, via issues in respective product trackers: ReSharper, ReSharper C++, dotTrace, dotMemory, dotPeek or dotCover.
ReSharper Ultimate 2016.2 EAP has been open for over two months, and we are approaching release now. Most probably, the new things described below will round up the feature set of upcoming ReSharper Ultimate 2016.2. So here is what’s new in the latest EAP builds.
In addition to 100+ fixed issues in the mainline ReSharper, there are some new features worth mentioning:
<inheritdoc/> tag, which is a good alternative to copying documentation from base types/members to derivatives. Although the tag is non-standard, it is understood by tools such as NDoc, Sandcastle, and Stylecop; and there are also requests to support it in .NET Core and Roslyn.<inheritdoc/> comment to derived members; you can enable adding <inheritdoc/> automatically when generating missing/overriding members; the Quick Documentation popup will display the correct documentation even if the tag explicitly refers to specific symbol, i.e. <inheritdoc cref="SomeSymbol"/>.
++ and -- operators as well as spaces before and inside parenthesis of checked and default expressions.
return, throw, etc.) ReSharper C++ will automatically highlight all other function exits including exits from loops and switch statements.
switch statement’ and ‘Non-explicit conversion operator’
0, nullptr or NULL as the preferred initializer in the options, and ReSharper will help you maintain this style in your code base.
Recursive call stacks can be deep and difficult to analyze. Previously, Timeline Viewer would show call stacks “as is”, i.e recursive calls were simply shown as they were called: one after another in the stack trace. Of course, on complex call stacks with multiple recursive calls this would result in almost infinite stack scrolling. Now, Timeline Viewer allows you to fold such calls to streamline stack analysis.
dotMemory now allows you to compare memory snapshots stored in different workspaces, or, in other words, collected in different profiling sessions.
For example, this can be useful to find out how particular changes in code affect your application’s memory usage. All you need are two snapshots taken before and after committing changes.
/ProcessFilters parameter. For example, /ProcessFilters=+:prA;+prB will exclude all processes except prA and prB; /ProcessFilters=-:prC will exclude prC from the coverage.
Please feel free to download the latest 2016.2 EAP build and let us know what you think. If you have any problems, please raise issues in ReSharper, ReSharper C++, dotTrace, dotMemory or dotCover issue trackers.
Last time, we had a look at what was new in the June EAP of Rider, our .NET IDE.
This time, we’re going to go back to the beginning and have a look at some of the interesting features we’ve added during the EAP so far.
This includes:
Rider is a .NET IDE, and as such, requires a certain set of functionality, such as opening and creating projects, build and debug, and of course, an excellent editing and code navigation experience.
Rider supports opening Visual Studio solutions and .csproj based projects. It also supports .NET Core applications, as long they also have a solution and .xproj files (remember, .NET Core tooling is changing back to MSBuild based .csproj files. Rider will support this, too).
And of course, it allows creating projects, too, with project templates that can create executables, class libraries and .NET Core projects.
But Rider would be nothing if it didn’t have a good editing experience. And here, Rider takes full advantage of both its ReSharper and IntelliJ heritage, to provide all the functionality that you know and expect from a JetBrains IDE: complete statement, auto-completing brackets, tooltips and parameter info, live templates, and of course lightning fast code completion, either when you type ., or automatically, in context, like completing a type name after
new.
Rider also includes very rich navigation, making use of IntelliJ’s Search Everywhere feature to search for classes, symbols, or files, even searching for IDE actions and settings. In addition, you can Ctrl+click to go to definitions, go to file member, and of course use the Navigate To context menu to move up and down a class hierarchy or use other navigation options:
And who can live without Find Usages?
Rider has been designed to make the most of the investment we’ve put into ReSharper for the past 10+ years. Rider uses ReSharper as an out of process language server, so any functionality we add to ReSharper can be used in Rider (and any functionality we add for Rider can also be used by ReSharper).
The protocol we’ve designed for the Rider frontend to talk to the ReSharper language server is very lightweight, two way and asynchronous. On top of that, the data we’re sending between the two processes is designed to also be very lightweight – little more than “view models”.
For example, every advanced IDE needs to display inspection highlights – “squigglies”. With Rider, these inspections are carried out by ReSharper, out of process, and the data is passed to Rider, as a “view model” – essentially a list of offsets, highlight types and tooltip text.
This means that Rider immediately gets access to all of ReSharper’s over 2000 inspections.
And what would a JetBrains IDE be without Alt+Enter?
Everybody’s favourite keyboard shortcut is there, ready to safely rewrite code to apply quick-fixes to all of those inspections, or perform context specific actions like converting a string literal to string interpolation, or even marking it as a regular expression!
While the protocol allows us to reuse a lot of existing functionality, some features, such as refactoring, take a bit more work. Interestingly, a lot of the work is to create new UI for the workflows – ReSharper already knows how to rewrite your code, but it needs to know what you want to do. Which means we don’t have all of ReSharper’s refactoring support available in Rider right now. But we do support a number of refactorings, especially the most important – rename.
NuGet has changed the way we consume dependencies in a .NET project – referencing packages is a lot better than manually downloading libraries, adding them to a libs folder and checking them into source control.
So of course, Rider has to support NuGet. And of course we wanted to sprinkle a little JetBrains magic on it.
The idea behind our implementation is to be as fast as possible. When you search for a package, we return cached search results, so commonly used packages are available instantly. But we’re also updating the results in the background, so any new packages, or new versions, are added asynchronously.
The UI might be a little different to what you’re used to. The NuGet tool window is split three sections. The first is a view of the solution and project hierarchies, the second lists packages, and the third shows package details.
Selecting a node in the solution hierarchy lists the packages that are already installed, and provides a text box to search for packages to install. This list also shows when a package has an update available.
Clicking on one of these packages shows details in the final section of the window. This shows the package description, authors, license, project URL and so on. It also lists the available versions in a drop down – selecting one of these and clicking Apply will install, update or rollback to that version. Clicking the Remove button will of course remove the package.
And finally, the Restore button next to the solution hierarchy will restore all packages, downloading any that are missing.
Along the top of the tool window, you’ll notice some tabs:
The File Structure window shows an outline of the current file in the editor. So for a C# file, it will show classes, and under each class is a list of class members – methods, properties, fields, etc. Double clicking one of these will navigate the editor to the appropriate location in the source, and if you toggle the Autoscroll from source toolbar button, whenever you navigate around in the editor, the matching type member will be highlighted.
See the title of the tool window tab docked to the side of the window? 7: Structure – the “7” means that you can quickly get to the tool window by pressing Alt+7. This works for any tool window that has a number in front.
Another feature that Rider has brought over from ReSharper is Solution Wide Analysis. When enabled, ReSharper will analyse all files in a solution, rather than just open files.
This gives ReSharper a much better view of your solution, which it can use to power a number of features. For example, it tracks cross-file symbol usage, so it can highlight public classes or methods that aren’t used in any file. It also maintains a list of errors in all files across the solution, and uses the cross-file usage information to intelligently and efficiently rescan only
affected files to keep the list up-to-date as you type.
The Errors in solution tool window in Rider will display the list of errors in your files, grouped by file. Double-clicking on an error will take you straight there, while using the Next error action in the editor will cycle through all errors in the list, across all files.
And just like in ReSharper, there is a little icon in the bottom right of the status bar, showing if the solution has errors or not, allowing you to use the feature without having to have the tool window open. Clicking the number of errors cycles through them, while clicking the icon will open a small context menu to get quick access to useful features.
Solution Wide Analysis is disabled by default. Scanning all of the files in a solution obviously has an impact on resource usage, and we would rather you opt in to this behaviour. For most real world solutions, the disk-based caches happily handle the extra data required, and once the initial scan of all files is done, the cross-file usage data makes keeping the list of errors up-to-date very efficient.
And since Rider uses ReSharper as an out of process backend language server, ReSharper has much more headroom to allocate and use memory that won’t affect other aspects of the IDE. So give Solution Wide Analysis a go on your solution!
Rider is still in private EAP, although we are getting ready for a public preview. If you’d like to give it a go right now, please head over to the signup page, and we’ll send you a download link.