Navigating to Source Code from dotMemory

We always look for ways to increase the value of ReSharper Ultimate and synergize our .NET tools. For example, in ReSharper Ultimate 9.2, we made it possible to profile ReSharper’s run configurations, so if you have both dotTrace and ReSharper you can even profile individual static methods in your project.

Now the time has come for dotMemory to get its portion of ReSharper’s functionality. dotMemory always lacked the ability to examine the source code of the profiled application. Just imagine how easier life would get if you could seamlessly continue the investigation of a suspicious object (one that may cause a leak) by examining its source code. Well, starting with dotMemory 10 and ReSharper Ultimate 10, you can!

To navigate to the source code from dotMemory

  1. In Visual Studio, open the solution that you have a memory snapshot for.
  2. In dotMemory, in any view that displays object types, right-click the type you’re interested in.
    Find declaration context menu
  3. In the context menu, select Find declaration (Visual Studio)*. This will open the Find Type Declaration window that lists all found type declarations in running Visual Studio instances.
    * As an alternative to steps 2 and 3, select a type and press Ctrl+L.
    Find type declaration window
  4. Click on the found declaration to navigate to it in Visual Studio.
    Type declaration in VS

After you navigate to any type declaration at least once, the context menu will offer an additional item, Go to declaration (<solution_name>) (also available via the Ctrl+L shortcut). Selecting it instantly navigates you to the type declaration in a specific solution, bypassing the Find Type Declaration window.

Go to declaration context menu

To see for yourself how the feature works, download the latest dotMemory or ReSharper Ultimate. If you have any comments or questions, please feel free to ask in the comments to this post. Your feedback is greatly appreciated!

Posted in dotMemory Tips&Tricks, How-To's | Tagged , , | 1 Comment

Continuous Testing webinar: recording

The recording of our recent webinar, Continuous Testing in Visual Studio using dotCover or ReSharper Ultimate, is now available:

In this webinar, we demonstrate Continuous Testing, a new feature of dotCover 10 and ReSharper Ultimate that will build and run your tests as they change. By monitoring what code is called from each test, Continuous Testing can optimise the test run by only running the tests that will exercise the changed code. ReSharper Build can also be used to further optimise the feedback cycle by speeding up the build step.

The following topics are covered:

  • A recap, with some hints and tips of ReSharper testing and dotCover code coverage
  • Enabling Continuous Testing
  • The Continuous Testing UI
  • Detecting “dirty” tests
  • Including/excluding tests from scope
  • Using ReSharper Build to speed up build time

You might also want to check out two related blog posts: Introducing Continuous Testing and Introducing ReSharper Build.

Posted in dotCover Tips&Tricks, ReSharper Tips&Tricks | Tagged , , , , , , | 3 Comments

ReSharper Ultimate 10.0.2 EAP 2: unit testing, red code fixes

ReSharper 10.0.2 EAP continues with a new build that is expected to fix a number of considerable problems in terms of:

  • Bogus red code: we have fixed incorrectly highlighted red code in solutions containing .modelproj and .wixproj project types. Since modelling projects (.modelproj) are only available in Visual Studio Enterprise and Ultimate editions, users of these editions might want to check out this fix.
  • Unit testing: NUnit tests with Ninject should now be running correctly again; NUnit’s test cases are now treated with fewer glitches; a set of problems related to grouping by category and namespace are now gone; unit test runner avoids running extra setup and teardown code for test fixtures; running the default NUnit 3.0 MSI installer no longer leads to inconclusive test runs; support for xUnit theory row test elements is restored following a regression in 10.0.1; line wrap in Unit Test SessionsOutput pane can now be controlled.
  • Inserting project references: projects should now be properly referenced again when you insert a using directive with a ReSharper action.

There are also other fixes here and there, including those related to TypeScript and JavaScript support, as well as renaming namespaces in XAML. Here’s the full list of fixes in ReSharper 10.0.2 EAP 2.

Compatible ReSharper Ultimate products are also available. Specifically, dotCover can now be properly integrated into Visual Studio again, even when installed without ReSharper, which fixes a regression introduced in EAP 1.

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

ReSharper Ultimate 10.0.2 EAP

As we continue working on critical issues discovered in ReSharper 10, today we open the Early Access Program for ReSharper Ultimate 10.0.2.

The initial EAP build is mostly about Unit Testing, it comes with fixes to such issues as inabilty to run a single test or a group of selected tests with NUnit 3.0 (RSRP-450313), broken key bindings (RSRP-429324) or hanging Visual Studio (RSRP-449802).

Here is the full list of fixes for ReSharper for your reference. ReSharper C++ 10.0.2 EAP introduces a set of performance improvements and bug fixes as well.

Please download and try the ReSharper Ultimate 10.0.2 EAP build and let us know if it improves your experience with ReSharper compared to previous versions (10.0 and 10.0.1). ReSharper 10.0.2 release is currently planned for mid-December, so please expect more EAP builds in upcoming weeks.

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

Continuous Testing in dotCover and ReSharper Ultimate

Over the last couple of years, continuous testing has been the top anticipated dotCover feature. Now, the wait is finally over as dotCover 10 supports continuous testing in Visual Studio! Before we move on to the nitty-gritty details to show you how it works, let’s try to recall what continuous testing actually is.

Continuous testing

In a nutshell, continuous testing means testing ‘without interruption.’ It implies that tests are run in the background, so you have actual test results instantly, as soon as you’ve changed your code. This dramatically speeds up a developer’s workflow as there’s no need to manually rebuild the project and re-run all tests after making changes: the impacted tests are run in the background automatically (the testing session is triggered by some explicit action, e.g., saving changes).

If you practice test-driven development, the benefit is even more pronounced: the Red-Green-Refactor workflow becomes virtually seamless. All the boring routines go away, leaving you only with the fun part:

1. Write a test.
2. Write a stub.
3. Build.
4. Run the tests (they must fail).
5. Update the stub to return the expected result.
6. Build.
7. Run the tests (they must pass).
8. Write the code.
9. Build.
10. Run the tests (they must pass).
11. Refactor the code.
12. Build.
13. Run the tests (they must pass).

So, how to use continuous testing in dotCover? It’s very easy, with only three steps to follow.

1. Open Continuous Testing Session window

Continuous testing is managed via the Continuous Testing Session window. To open it, use the menu ReSharper | Unit Tests | Show Continuous Testing Session.

Continuous testing is off by default

2. Select continuous testing mode

By default, continuous testing is switched off. To make it work, select one of the modes in Mode:

Select continuous testing mode

A wide variety of combinations are available. For example, you can tell dotCover to automatically build and run dirty tests after you save the project. Or, run dirty tests only after you build the project.

What does ‘dirty test’ mean? It is the test that was impacted by code changes. For example, you have a test that covers some code, you change the code, and the test result is now obsolete, i.e. the test becomes ‘dirty.’ In addition, dotCover considers as ‘dirty’ all new tests, tests that were aborted by user (aborted), and tests that failed to complete for some reason (inconclusive).

3. Just work

Once continuous testing is enabled, you can simply start working. Initially dotCover will mark all tests as dirty.

The current tests status can be checked on the continuous testing icon in the status bar (bottom right corner of the main Visual Studio window). This handy assistant shows you whether there are any failed tests or all of them pass successfully. The Continuous Testing Session window displays the results in more detail:

Continuous testing status

As we already mentioned, your workflow with the enabled continuous testing is almost seamless. Suppose you change code that is covered by some tests and save the project (and you’ve selected the On ‘Save’ Build and Run Dirty Tests mode). dotCover builds the project and re-runs (only) dirty tests in the background:

Working with continuous testing

To navigate to a failed test, click the test in Continuous Testing Session window or click the number next to the continuous testing icon.

Failed test icon

Another option to navigate to the covering tests is to do it right from the code. Simply click on the code and select Show covering tests in the context menu. This opens the list of all tests that cover this line of code. Here you navigate to the corresponding tests or force them to run:

Show covering tests

Next steps

If you’re willing to try continuous testing right now, download and install ReSharper Ultimate.

IMPORTANT! If your tests that use external files fail during continuous testing (while being successful in a traditional unit testing session), you should properly set dotCover’s Shadow-Copy option. The following post describes in details how this option works.

Should you have any questions, please feel free to ask in the comments to this post. Your feedback is greatly appreciated!

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

ReSharper Build webinar: recording and Q&A

The recording of our recent webinar with Matt Ellis, Speeding up MSBuild: Tips, Tricks and ReSharper Build, is now available:

In this webinar Matt talks about some of the ways that help achieve faster build times in Visual Studio, including ReSharper Build introduced in ReSharper 10. The following topics are covered:

  • MSBuild refresher
  • Tips for speeding up MSBuild
  • Common sense tips
  • The CopyLocal myth
  • HintPath for references
  • Checking for slow targets and tasks
  • XAML & multi-pass compilation
  • Incremental compilation
  • ReSharper Build

Questions and Answers

There were some popular questions asked during the webinar, as well as those that we didn’t get the chance to answer on the day.

Q: How does ReSharper Build’s public API surface monitoring handle InternalsVisibleToAttribute?

A: ReSharper Build will only rebuild dependent projects if an assembly’s public API has changed. The  InternalsVisibleToAttribute allows other assemblies to see  internal types and type members as though they were public. Unfortunately, ReSharper Build doesn’t yet work with this scenario – the public API monitoring is currently only for public types and type members.

To work around this issue, you can mark the referencing projects as “always build” in the ReSharper Build options page – this disables ReSharper Build’s heuristics, and always calls MSBuild on the project, where it will rebuild, based on timestamps. The issue is RSRP-450733, if you wish to vote, track or add any further details.

Q: Can ReSharper Build be used in a Continuous Integration server or as a command line tool?

A: The current implementation is targeted at reducing the solution build time in a running instance of Visual Studio, specifically at improving the feedback cycle for edit/compile/test or edit/compile/debug. At this point we don’t have any plans to extend these scenarios to include continuous integration or other kinds of usage outside of Visual Studio.

Q: What are the impacts (if any) when using TFS with multiple developers some of which have ReSharper and some which do not?

A: None. ReSharper Build optimises the solution build for running instances of Visual Studio, by skipping projects that don’t need to be built. It doesn’t alter the project files or the solution file, or anything else that can affect other developers, or a continuous integration process.

Q: If you already have everything set up with your build using Visual Studio, does ReSharper reuse these settings? I want to make sure if I start using ReSharper the output of the build (structure, etc) will be the same.

A: ReSharper Build uses MSBuild to build the projects in your solution, just like Visual Studio does. Put simply, ReSharper Build replaces Visual Studio’s solution build management with its own, which means ReSharper Build gets to decide if MSBuild should be called for a project, or not. It does not alter the project build itself – when a project is built, the normal build process is followed.

Q: How do I force a complete rebuild when for example changing a method that is only used via reflection?

A: The “Rebuild” menu item will rebuild a selected project, or the whole solution. Also, the consuming project that is performing the reflection can be marked as “always build” in the ReSharper Build options. This disables ReSharper Build’s heuristics, and always calls MSBuild for a project.

Q: What kind of speedup do you experience with the ReSharper solution?

A: This is a tricky question to answer, because it very much depends on the scenario. If a public API is changed in a project referenced by everything else, then there isn’t much of a speedup – everything is rebuilt, and it takes as long as MSBuild normally would.

However, if the change is an internal implementation detail to the same root project, then only that project is built and the speedup is huge – seconds instead of minutes. Similarly, if a public API is changed, but the build is triggered for tests, then only the projects used by the tests are rebuilt, and this can also have a huge (positive) impact on the build time. The speedups vary, and the only way to really see how much of an improvement you’ll get is to try it with your own solutions! But it’s worth pointing out this feature was initially written to make things faster for the ReSharper solution, and the whole team uses it!

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

ReSharper Ultimate 10.0.1

Are you having issues with ReSharper 10, particularly in terms of unit testing, performance in web applications and/or red code in UWP applications?

If you are, please download ReSharper 10.0.1, a bugfix update which addresses all the major issues that we acknowledged last week.

As usual, the ReSharper Ultimate installer contains compatible updates to ReSharper C++, dotTrace, dotMemory, dotCover, and dotPeek.

Please comment to let us know whether the update improves ReSharper experience compared to the initial v10 release, and if there are any outstanding hot issues so that we can address them in further releases.

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

Optimizing Load Balancing in PLINQs with ReSharper Ultimate

When filtering large amounts of data, using a PLINQ instead of a sequential LINQ can provide significant performance boosts. Still, optimal parallelization is quite a complex task that depends on a variety of factors, such as the number of CPU cores, the nature of input data, and others. In some cases, a query that seems parallelizable works even slower after being transformed into PLINQ.

Optimizing a PLINQ is, first of all, the task of finding the optimal load balance between worker threads. This usually requires multiple experiments with various input data, loads, and computer configurations. By using the right tools, you can find the best solution faster. In this post we’ll explain why ReSharper Ultimate (or more specifically ReSharper with dotTrace integrated in Visual Studio) is possibly the best candidate and why it is more convenient than the standard approach of measuring overall query time.

Sample application

Suppose we have a large project with many subsystems and we’ve just implemented a new feature that allows searching for a specific string in files stored inside zip packages*. Our application will use it to find particular files in numerous zips.

*This example, as well as the entire post, is inspired by PLINQ performance problems we faced when processing multiple NuGet packages in ReSharper. However, this post is not about optimizing a specific algorithm; it’s more about giving you a basic understanding of how you can analyze PLINQ performance with ReSharper Ultimate.

Our feature is based on the ZipPackage class (representing a zip package) and the FileInZip class (representing a file inside a zip). The FileInZip class provides the ContainsString method that finds a particular string in the file. This allows us to use simple LINQs for searching (e.g., …where file.ContainsString(str)…). To perform the search, a FileInZip instance extracts the corresponding file from a zip package to MemoryStream. We won’t provide the exact class implementation in this post but you can get the entire example on GitHub.

Sample app classes

Creating a run configuration

Now we want to test the feature on some sample zip packages without running the entire application (remember, it’s huge). Should we create an integration test for this? No, much easier. With ReSharper Ultimate we are able to run specific static methods using run configurations (read this post for a lot more details about the feature). In a nutshell, we should write a static method that contains only the code we need. ReSharper Ultimate’s run configurations feature will allow us to run just this method in a separate JetLauncher process. In this way we can run and debug any part of our code by isolating it from the main application. For example, anywhere in our project we can create the following static method:

Then we just use Alt+Enter on the method and select Debug | Run:Method's action list

This opens the Run Configuration Properties window. Clicking Save & Execute will run the method (under the JetLauncher process) and save the particular run configuration for future use.

Run configuration properties

Our method writes the result to the debug output. Debug output

OK, the algorithm works as expected, but how can we measure its effectiveness? Let’s profile our method! If you have ReSharper Ultimate (or both ReSharper and dotTrace) installed on your machine, you can profile any run configuration. So, all we need to do is start profiling the run configuration we’ve just created.

Profiling run configuration

To profile a static method, we once again use Alt+Enter on the method and select Profile (<profiling type>)*, where <profiling type> is the type of profiling that will be used by dotTrace. We’ll use the Timeline profiling type as it not only provides time data for method calls but also binds them to the timeline, which is extremely important when analyzing multi-threaded applications.

*The default profiling type can be selected in Performance Snapshots Browser which can be opened via ReSharper | Profile | Show Performance Snapshots… Profile through the action list

This runs profiling and automatically takes a performance snapshot when the process completes its work. Then the collected snapshot is opened in dotTrace Timeline Viewer.

If you’re new to Timeline Viewer, find more details about it here. In a few words, it is a part of dotTrace that allows you to slice and dice the collected snapshot data using filters. For example, select time intervals where a certain event takes place (UI freeze, GC and so on) and find out what methods stand behind that. Or, vice versa, select time intervals where a specific method is executed and see what subsystems are working at this moment.

If we now take a look at the Threads Diagram in Timeline Viewer, we’ll see that the profiled static method utilizes just one Main thread (as expected) and requires about 70 seconds to complete:Threads Diagram showing sequential LINQ

The Top Methods filter shows that the highest own time belongs to the Ionic.Crc.CRC32.SlurpBlock method. This is kind of expected as this method is responsible for zip extraction (the app uses the DotNetZip library to work with zip packages).

Top Methods and Call Tree

As 70 seconds is too long for us, we decide to parallelize our LINQ so that multiple threads can unzip packages at the same time.


The most obvious solution is to add the AsParallel method to the input sequence in our LINQ.

After profiling, we see that this solution kind of works – overall execution time has decreased to 39 seconds. Still, that result is far from ideal. The Threads Diagram shows that the data is split among 8 threads and, while some threads do most of the job, others complete their work much earlier.Timeline Diagram for PLINQ with AsParallel

So, why does this happen? Let’s use dotTrace’s filtering capabilities to find out the root cause. Our input data are zip files stored on a disk, so we should take a look at how threads treat these files. To do this, we simply turn on the File I/O filter in Interval Filters. Now, all other filters show the data only for the time intervals where file I/O takes place.

Threads Diagram with applied File IO filter

The File I/O: File Name sub-filter shows how File I/O time is distributed among specific files:

File IO File Name subfilter

The sub-filter states that some files require more time than others. If we now turn on a filter by a specific file, we’ll see that each zip file is processed by exactly one thread:

Threads Diagram with applied File IO File Name filter

Therefore, the problem lies in the zip-per-thread load partitioning. As zip files have different sizes, threads take different amounts of time to process them. This means we need to implement partitioning in a way that lets each thread extract files from any zip package.

Custom partitioner

Our solution is to create a custom partitioner that will split the input data into equal chunks. In our case the partitioner must provide not zip packages to PLINQ, but the files inside these packages. For this purpose, we can try using a “default” partitioner, an instance of the Partitioner class. We just need to prepare the input data for the partitioner (files in zips) and specify whether we want to use dynamic or static partitioning (this is specified in the partitioner’s Create method).

With dynamic partitioning, it will try to balance the load dynamically so files will be provided to threads as they are requested. This can provide a speed boost on computers with many cores. The static partitioner prepares all chunks before the start, resulting in a lower overhead. This approach may be faster on computers with only a few cores.

Let’s try dynamic partitioning:

After we profile the method, we can see that the load is now much more balanced. The makes the method take only 29 seconds to complete, which means a 10-second (25%) improvement. The default static partitioner on an 8-core computer shows almost the same results:

Threads Diagram for default dynamic partitioner

As we can see on Threads Diagram though, the partitioning is still not perfect as some threads complete their work a little bit earlier than the others. This happens because the “default” partitioner knows nothing about the internal structure of our input data (text files).

The problem is that bigger files require more time for extraction. This means we need to fill the chunks not based on the number of extracted files, but on their size. We can try to solve this task by creating our own static partitioner. Such a partitioner must be based on the Partitioner class and must implement the GetPartitions method, which returns enumerators for the given number of partitions.

On an 8-core machine, our custom partitioner works a little better than the default partitioners. The load is more balanced now with about 10% additional improvement (from 29 seconds down to 26).

Threads Diagram for custom static partitioner

What next? The only way to ensure your PLINQ works as fast as possible is to test it on as many configurations as possible. For example, if we try all the partitioners we’ve just created on a 4-core PC, we’ll see somewhat different results:

Threads Diagrams on a 4-core PC

While the default static and dynamic partitioners are still close, the custom one increases its lead. It takes 30 seconds, which is about a 15% improvement compared to 35-37 seconds. The small difference in absolute time values between 8-core and 4-core PCs may be explained by the large number of garbage collections which block worker threads (as our algorithm allocates a LOT of memory for zip extraction). Excessive GCs would make a good target for optimization too, but that’s a story for another post.

As you can see, PLINQ performance offer rich opportunities for experimenting, and ReSharper Ultimate can help a lot. We hope you find this post helpful and give a try to ReSharper Ultimate features on your own.

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

ReSharper 10 critical issues and fix schedule

Following the release of ReSharper 10.0 last week, we have received a great deal of feedback, and unfortunately a lot of it was negative.

Upon analyzing the feedback, it looks like unit testing is the most affected area. Hot issues include the Output pane in Unit Test Sessions that might not show any results upon running your tests (RSRP-450266), as well as Visual Studio hanging when you debug MSTest-based tests (RSRP-449577). Both issues are going to be fixed in the next bugfix update, 10.0.1, that we expect to release soon, hopefully this week.

Speaking of other problem areas, ReSharper 10.0 is known to show red code in some perfectly compilable Universal Windows Platform (UWP) projects (RSRP-450057, a private build and workarounds are available in comments to the issue). This is already fixed internally, and a fix is also going to make it into 10.0.1.

We’ve seen license activation issues related to connecting your ReSharper installations to your JetBrains Accounts but these were hopefully fixed with a redeployment of the JetBrains Account application early last week. If you’re still experiencing license related issues with ReSharper 10, make sure to read this article for ways to resolve or work around them.

We’re also fixing miscellaneous performance problems as soon as we can reproduce them. Particularly, heavy performance issues that could affect all kinds of web sites and web applications were fixed and a fix will be available in 10.0.1.

Apart from the bugfix update (10.0.1) that we’re hoping to roll out as soon as possible, we have another update (10.0.2) scheduled for mid-December that will target any considerable regressions left following 10.0.1.

Apologies for the struggle caused by 10.0 to many of you. If necessary, you can revert to ReSharper 9.2 or another recent release until we’ve released the upcoming update.

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

Welcome ReSharper Ultimate 10 RTM

We are here to let you know that the final release of ReSharper Ultimate 10 is now available for download!

ReSharper Ultimate 10

As described earlier, all ReSharper Ultimate family tools now share a common version number to simplify dealing with compatibility issues, so please welcome ReSharper 10, ReSharper C++ 10, dotTrace 10, dotCover 10, dotMemory 10 and dotPeek 10.

Watch this video for an overview of what is new in ReSharper Ultimate 10:

Here is a quick recap of what is new for each of the tools, if you prefer text.

ReSharper 10

In addition to around 450 fixes, highlights of ReSharper 10 include:

  • ReSharper Build is a new out-of-process incremental build tool that can take advantage of multiple processes, visualizes different kinds of project build status, and is optimized for large solutions with lots of dependencies. ReSharper Build
    Read this post for more details on ReSharper Build.
  • Built-in postfix templates. One of the most popular plugins gets integrated into mainline ReSharper. Postfix templates allow reducing backward caret jumps while typing C# code. For example, you can start with an expression and proceed to wrap it into an if statement to check whether it returns true. Another template allows you to throw an exception if certain condition is met. Postfix templates
  • Usage-aware Go to Declaration. ReSharper 10 extends the functionality of Go to declaration (as well as Ctrl+click) so that you can also use the shortcut to look up for usages. In case you have one declaration and one usage, you can use Go to declaration to simply switch between them. If you have multiple usage of a symbol, subsequent Go to declaration hits will take you to further found usages of the symbol, one usage at a time. Navigation between usages is aided by a Find Usages-like pane that enumerates found usages, contains additional controls to mouse-click between usages, and helps you flush all found usages to the regular Find Results window if you like. Usage-aware Go to declaration
  • Code style improvements. ReSharper 10 comes with a set of changes aimed to simplify configuration of and complying with code style settings. Inspection severity can now be configured right from the Alt+Enter menu, without using a modal window. Find similar issues window is now used only for searching in a custom scope. All default scopes, such as solution, project and file, can be applied right from the same old Alt+Enter menu. Additionally, there are new code inspections with quick-fixes that detect explicit or implicit access modifiers for types and type members, let you use a pre-configured order of modifiers, and help you join or separate attributes in a section.
  • Refined Stack Trace Explorer. Stack Trace Explorer was basically rewritten from scratch in ReSharper 10. This enabled Stack Trace Explorer to provide links to types in addition to methods and to parse more types of data, including WinDbg GCRoot dumps, Visual Studio Call Stack tool window contents and dotTrace snapshots.
  • NUnit 3.0 Beta 5 support. As the new major version of NUnit is approaching release, we have laid the groundwork to support it in ReSharper unit test runner. We will make more changes in order to support the release version of NUnit 3.0, though at this point the latest Beta 5 is supported.
  • JavaScript and TypeScript support improvements. Support for JSX syntax is now available in .js, .jsx and .tsx files to streamline React development in ASP.NET applications. Code completion, all ReSharper regular context actions for HTML and JavaScript, navigation to declarations and search for usages, as well as a couple of refactorings are available as well. JavaScript regular expressions that were originally supported in ReSharper 9.2 are now covered in more detail. TypeScript 1.6 support has been finalized with the addition of intersection types and class expressions. Moreover, code completion for JavaScript is now aware of types from JSDoc comments.
  • UWP device family-specific views. Universal Windows Platform enables using device family-specific XAML views to provide different UI for different types of devices. ReSharper 10 learns to handle this with dedicated code inspections, quick-fixes and context actions.Code inspections for UWP device family
  • Google Protocol Buffers (Protobuf). ReSharper 10 starts to provide support for .proto files. This includes syntax highlighting, code analysis, code completion and navigation for both 2.x and 3.0 Protobuf versions.

ReSharper C++ 10

ReSharper C++ 10 comes with 200+ fixes and a variety of enhancements:

  • Improved support for C language. ReSharper C++ 10 provides full support for C99, including designated initializers. C11 is supported to the same extent that Visual Studio supports it. Code completion and some context actions that are specific for C language are introduced with this release as well.Code completion for C in ReSharper C++
  • New context actions. There is a new action to create a derived class when standing on a class declaration. Other new context actions help replace decltype with the underlying type, as well as substitute a template type alias.
  • New code inspections and quick-fixes. We’ve introduced a new code inspection that detects whether a class needs a user defined constructor with a quick-fix to generate it. Another new code inspection detects uninitialized base class in a constructor and offers a quick-fix to initialize it. Additionally, we added quick-fixes for mismatched class tags highlighting, a quick-fix to add a template argument list and a quick-fix to make base function virtual.Make base function virtual quick-fix
  • ReSharper C++ 10 inherits the updated usage-aware Go to declaration mechanic from the mainline ReSharper. From now on you can use the single shortcut not only to switch from declaration to definition, but also to navigate through usages.
  • Code generation. ReSharper C++ 10 allows generating definitions for a function inline. We’ve also added support for generating Google Mock stubs for those who use Google Test framework.
  • Performance was one of our priorities for this release, and as a result ReSharper C++ 10 works significantly faster on solutions that had already been cached.

dotCover 10

The main highlight for dotCover 10 release is the long-awaited Continuous Testing functionality. Following an initial code coverage analysis of your solution, dotCover 10 learns to track your code changes, figure out which tests are affected by them, and then it can re-run the affected tests as soon as you hit Save, or use a different strategy of reacting to code changes.
Continuos testing session in dotCover 10

dotTrace 10

dotTrace integration in Visual Studio has been considerably improved with this update. With dotTrace 10 when you choose to profile your startup project from Visual Studio in Timeline mode, you can view the resulting snapshot right in Visual Studio, using the Performance Profiler tool window. You can select a particular time frame to investigate and drill into, make use of several filtering options, as well as export and save snapshots, all without leaving Visual Studio.
dotTrace 10 Timeline viewer in Visual Studio

dotMemory 10

dotMemory 10 introduces a new contextual option that lets you navigate from a type in an object set to its type declaration in an open Visual Studio instance. If the target type is a library type, this triggers ReSharper’s decompiling functionality and opens decompiled code in Visual Studio.
dotMemory 10 Find declaration in VS action

In addition, dotMemory receives a start view similar to dotTrace Home. The new dotMemory Home screen can be used as a starting point to memory profiling that lets you launch a new local or remote profiling session, attach to a running process, configure a profiling session and more.

dotPeek 10

dotPeek 10 delivers one of the most heavily requested features: you can now navigate to IL code from any point in the C# decompiled code viewer. IL code can be shown in a separate tool window or as comments to C# decompiled code.

IL viewer in dotPeek 10

Find Usages in dotPeek now works asynchronously, similarly to how it does in recent versions of ReSharper. This means that even if you started to look up for usages, you can still work with dotPeek without needing to wait until it finalizes the search.

In other news, dotPeek 10 supports color themes: you can now select one of 3 default themes, or choose to synchronize your color scheme preference with Visual Studio settings.

Get ReSharper Ultimate 10

Licensing and upgrade options

In terms of licensing and upgrades, some changes are introduced with this release:

  • ReSharper 10 is a free upgrade for you if you have a valid ReSharper upgrade subscription. ReSharper C++ 10 is free if you have a valid upgrade subscription to ReSharper C++.
  • In case your upgrade subscription expired, you can now subscribe to ReSharper, ReSharper C++, ReSharper Ultimate or All Products pack with a discount and get the second year of subscription for free. For details on how new subscription-based licensing works, please see JetBrains Toolbox.
  • Starting from November 2, 2015 dotTrace, dotCover and dotMemory are only licensed as part of ReSharper Ultimate. Read this post for details.
  • If you need a formal quote or any other assistance, you are welcome to contact JetBrains sales.
Posted in News and Events | Tagged , , , , , , | 67 Comments