Dotnet logo

The .NET Tools Blog

Essential productivity kit for .NET developers

.NET Tools How-To's Roadmap

ReSharper 2021.1 roadmap

We recently posted our roadmap for Rider 2021.1, so let’s take a look today at what’s brewing for ReSharper 2021.1, and the other dotUltimate tools. As with the Rider post, this is a list of what we’re working on, what we hope and currently intend to ship with ReSharper 2021.1. As ever, priorities can change and we might move things in and out of scope.

Let’s dive in, and please, let us know your feedback!

  • Out of process. Stop us if you’ve heard this one before. Yes, we’re still working on running ReSharper outside of the Visual Studio process, and yes, we’ve been talking about it for a very long time. But we are making steady progress on a mammoth task. We can already run a bare bones instance of ReSharper out of process, with a project model, language parsing and analysis and more (which is quite a lot for “bare bones”).

    We’ve recently been migrating all ReSharper actions so they can run in this backend process. These are the toolbar buttons, menu items and context menu items – UI elements which obviously need to integrate with Visual Studio, but now need to also work asynchronously in another process (we need to keep current ReSharper running in process, while we work on out of process). ReSharper has approximately 700 of these actions, and we’re nearly done migrating them all.

    We’re also hard at work removing all usages of our "document" abstraction from the part of ReSharper that still needs to run in the Visual Studio frontend, which will allow us to properly separate the Visual Studio editor from ReSharper running in the background process. This should see us ready for an alpha preview.

  • C# 9 and 10. The language continues to evolve, and we continue to keep up. Our C# team will be mostly focussed on C# 9, but we’re also keeping an eye on the new features currently planned for C# 10. We’ll be stabilising and improving the existing C# 9 support, including more features for pattern matching, as well as integrating existing IDE features with C# features, such as inlay hints, null analysis, top level statements, target typed ?: expressions and more.

  • Entity framework N+1 analysis. A common problem with working with object relationship mappers such as Entity Framework is that it’s very easy to hit the N+1 problem – where we get an entity with one call to the database, and then make N more database calls to get related or child entities. We’re working on bringing some inspections to ReSharper to highlight possible N+1 issues, complete with quick fixes to add the appropriate Include calls to make sure EF generates the appropriate SQL.

  • ASP.NET route insights. We’ll be pulling information about your ASP.NET routes out and providing features such as a URL/endpoint tree view and completion, navigation and find usages of URLs and routes.

  • Debugger improvements. ReSharper already provides debugging assistance with inline adornments to show values directly in the editor, rich data tips and great breakpoint management (not to mention debugging decompiled code!). In 2021.1, we’re going to be working on improving these adornments, making them work more asynchronously, and improving the performance.

    We’re still at work on predictive debugging, which we started talking about in the 2020.3 roadmap. This helps find issues before they happen, by using ReSharper’s data flow analysis to highlight the code that will be executed next. We’re hoping to ship this as a preview in 2021.1.

  • Command line tools. If you’re not already aware, it’s possible to run ReSharper’s analysis, duplication finder and code cleanup as standalone, command line tools, and as .NET Core tools!. We’ll be updating them to run on .NET 5, and we’ve added some diagnostics to generate snapshots to help with troubleshooting.

  • Testing. We’ve got several features lined up for ReSharper’s unit testing support. Firstly, we’ll bring back support for testing UWP projects, after the API was removed in Visual Studio 2019. We’ll also support discovery and tests of frameworks that use a vstest adapter and that aren’t supported "natively" by ReSharper – we handle NUnit, xUnit.net and MSTest directly, as this gives us noticeably improved performance, especially in test discovery.

    We’re adding support for running JS/TS tests with Karma, and will be introducing inspections for xUnit parameterised tests, and also for the popular AutoFixture package.

  • Localisation of ReSharper. This is not something that we expect to ship in 2021.1, but it’s a project that we’re kicking off this iteration. We’ve got a lot of international users of ReSharper, but we only provide English language support. We’ve recently been implementing internationalisation for our IntelliJ based IDEs, and we’re starting to do the same for ReSharper. And because ReSharper is the language engine for Rider, we want to be able to use this in Rider, too – any strings coming from the ReSharper backend need to be in the appropriate user interface language. We’re hoping to ship this later in the year.

These are our main priorities, but it’s not everything we’re working on. We’ve got some internal projects in the work with some of our interns and students (the N+1 analysis started life as an intern project), and there are more features that don’t fit under the banners above, such as support for reading custom naming rules from editorconfig, continued work with Razor and Blazor, as well as fixes and some planned optimisations for specific use cases. We’re also designing a set of metrics to capture more details about performance on a user’s machine. We’ll be talking more about this as the EAP progresses.

And of course, ReSharper is only a part of our dotUltimate family. A lot of what we’re working on in ReSharper also applies to Rider, especially C# language support and other analysis. And let’s not forget the dotTrace and dotMemory profilers, dotCover and our decompiler, dotPeek.

In our profilers, we’re going to extend our existing dotTrace native performance profiling to fully native applications. Currently, we can show native events and call stacks for .NET and Mono applications (great for apps that combine the two, such as Unity games), but with 2021.1, we’ll be supporting fully native apps, with no .NET stack, ideal for Unreal games. This will initially be implemented as part of the dotTrace integration in Rider (and of course, Rider for Unreal), and we’ll be bringing it to the standalone dotTrace app in a subsequent release.

The dotMemory profiler will be getting the ability to open .NET memory dumps from Linux apps. While the dotMemory application is still a Windows application, this will allow better profiling of applications built for cross platform use.

We’ll be looking at a couple of things with dotCover this release, primarily addressing some performance issues around continuous testing.

And finally, the dotPeek decompiler (both standalone and integrated with ReSharper and Rider) will get improved support for newer C# features like records and async streams and so on. We’ll also be adding formatter and code style options for decompiled code (we currently decompile to a static code style, rather than matching your existing code). And we’ll also be working on some minor UI updates.

We’re busy working on all aspects of ReSharper – features, architecture, performance and fixes. We hope you’ll find something interesting here, and since we’re very close to opening the EAP, hope you can give it a go as we work towards release. Let us know what you think, please give us your feedback, suggestions and ideas.

Discover more