What’s New in Rider

Say hello to Rider .NET Core edition! The backend finally runs on .NET Core runtime by default on macOS and Linux, instead of the Mono runtime. You will instantly notice:

• Better performance.
• A lower memory footprint.
• NuGet restore is now multithreaded (not single-threaded like on Mono). This means that it is 4x faster if you have a CPU with 4 logic cores, 8x faster if you have a CPU with 8 logic cores… you get the point.
• And the demolition of lots of other Mono limitations.

By the way, the current .NET Core version is the latest and greatest 3.1, which has a lot of performance improvements compared to the 3.0 version. 

Please note that there is no Windows support for now, only macOS and Linux. We are planning to add Windows support later this year.

Do you want to learn more about the transition from Mono to .NET Core and see the performance charts? Check out this blog post! 

If you experience any problems with the Rider backend running on .NET Core and want to move back to the Mono runtime, select Help | Switch IDE runtime to Mono. And if anything goes wrong for you, don’t forget to tell us.

Initial support for Xamarin Hot Reload is here! Now Rider automatically applies changes made in Xamarin Forms XAML to the application under debugging on a device or a simulator, without rebuilding and redeploying the whole application.

Please note there is a limitation: If a PC/laptop with Rider and an iOS device are not in the same WiFi network, a Hot Reload will not work, even if the iOS device is connected to the PC/laptop through USB.

Apart from that, Xamarin support gets one important fix: the “Invalid target architecture 'arm64e'” error no longer appears when running Xamarin.iOS projects on an iPhone XS Max device.

We are happy to introduce Dynamic Program Analysis. Every time you run your project in Rider, DPA starts collecting memory allocation data. Once you close the application, DPA will show you a list of detected problems: closures, and allocations to large and small object heaps. The great thing about it is that you do not need to start any “profiling sessions” and get snapshots. Just work as usual, and all the data will be collected in the background, with almost zero overhead. Testing DPA on a variety of real solutions has demonstrated a slowdown of only 0 to 2 percent.

Please note: DPA is available only on Windows, and you do not need a separate license to activate it.

This version of Rider introduces a new type of code analysis to track the usage of integer values in your application. This new type of analysis tracks how the values of all int local variables vary, and it verifies the correctness of all common operations on such variables to detect useless or possibly erroneous pieces of code. Namely, it warns you about:

• Relational/equality operators always giving true or false results.
• Heuristically unreachable switch cases checking int values.
• Meaningless arithmetic operations, such as multiplication by 1, addition of 0, etc.
• Possible int overflows.
• Possible division by 0.

To improve the precision of analysis, we’ve also added two new JetBrains.Annotations attributes to use with type members and parameters of the int type: [NonNegativeValue] and [ValueRange(from, to)]. These attributes specify how the values of the particular int members can vary in runtime.

• We’ve made significant improvements in the memory usage and speed of asset indexing. Rider will now index all of your code before looking at your assets, meaning that all productivity features, such as code completion, highlighting, and inspections, are available for use more quickly than before. Asset indexing will continue after the solution has been loaded, while you continue working, and Rider will find usages and even rename inside assets once indexing is complete. Of course, once done, the index is incrementally kept up to date, only looking at newly changed files.
• Asset indexing is now smarter, too. It understands usages of your code in Nested and Variant prefabs, and it shows usages for ScriptableObjects and values of serialized fields.
• Unit testing discovery now works better with Unity projects, with Rider finding all of the Edit mode and Play mode tests in your project automatically.
• We’ve added a new performance inspection, “Prefer jagged arrays to multidimensional arrays”, which demonstrates better performance in hot paths. This is a micro-optimization, so it is only suggested in performance-critical contexts, such as the Update method, or anything called from Update.
• Rider will no longer suggest Boo.Lang.List or System.Diagnostics.Debug in its code completion for Unity projects.
• We’ve tweaked the order of event functions in the Generate dialog to place the most important methods first. And when generating functions from the Alt+Enter menu, they will generate at the right location, too.
• For more updates and fixes, please see the GitHub repo.

We continue to add more and more support for C# 8 language features. We’ve refactored a lot under the hood in C# language support to prepare code analysis and other features, such as refactorings and ReSharper Build, to support nullable reference types (NRT). In Rider 2020.1, code analysis reports compilation warnings related to nullable reference types and provides quick-fixes for most of them.

There are also several new inspections and quick-fixes:

• To detect redundant type parameter constraints with respect to nullable reference types.
• To detect and use async overloads of methods when available instead of sync overloads.
• To use the nameof expression instead of using the typeof(SomeType).Name construction to get the name of the current type.

Over the past year, we have received a few reports of the code completion popup taking too long to appear. We’ve done our homework, and now the code completion popup displays much faster after you begin typing, especially in large solutions.

Another very handy feature that has landed in this release is that members marked as Obsolete can be hidden in code completion if you don’t want to see them there.

Last but not least, completing an item from the code completion popup now respects your code style settings.

We have completely reworked the UI for the Debug tool window to make it as clean and uncluttered as possible. When there’s only one debug session running, the tabs layout is simplified, as all tabs are now on one single level. Tab captions take up less space, so there is more room for debugger content. And when there are multiple sessions, one more tab layer is added to separate the sessions.

At the same time, we’ve combined the Threads and Frames views. If you don’t need the Threads view at the moment, you can hide it by clicking the “Hide threads view” icon.

We have also updated the debugger engine to make your debugging experience even better:

• Now you can detach from a process initially started under the debugger without terminating the app.
• Smart Step Into is enabled by default for the Step Into action (Preferences/Settings | Build, Execution, Deployment | Debugger | Stepping | .NET Languages | Always do Smart Step Into).
• The debugger supports the .NET Core x86 runtime.
• The thread name is now displayed in the execution line to help you understand where the application’s execution is right now.
• You can Skip to Here/Cursor after stopping the debug session on an exception.
• Now you have more control of the Debug Output window and can disable service messages in Debug Output.

We’ve tweaked the toolbars in the Unit Test Session and Unit Test Explorer windows. 

• Several icons have moved from the left-hand toolbar to the top one.
• Now it's possible to filter the unit test tree with text search, by using the new textbox in the top toolbar.
• The statuses "Failed", "Aborted", and "Inconclusive" have been merged into a single “Broken” one by default. If you’d rather keep them separate, click the "Gear" icon on the top toolbar.

In addition to that, we’ve added three big features:

• You can use the new advanced Group by functionality in the Unit Test Explorer and Unit Test Session tool windows to create a custom grouping. With the added Duration element, it is now possible to group unit tests based on the time they take to execute.
• You can filter unit tests by the target framework in the Unit Test Session tool window, in the event that you have more than one (which is quite common nowadays) and don’t want to see some of them.
• You can export and import any of your Unit Test Sessions. This allows you to share them with your team, between your computers, or between branches when you change something in the code and want to run/cover the same set of unit tests for both branches. Also, the exported file is fully compatible with ReSharper, so you can share Unit Test Sessions that you have in Rider with colleagues who use ReSharper, and vice versa.

In Rider 2019.3, we added an experimental TFS client which provided a dramatic speed improvement for the "Checking for changes" action. In the current release cycle, we’ve continued to put a lot of effort into the client. 

Finally, our TFS client hits its first release and brings a lot of improvements. Let’s mention the two most significant ones. First, enabling the Version Control Integration now works for TFS workspaces locally created with Visual Studio. This means you no longer need to re-create a local workspace from scratch in Rider. Second, we have greatly boosted the performance of the Delete and Rollback operations.

To start using the TFS client, go to Settings | Version Control | TFVC and enable it.

Rider, like all JetBrains IDEs, now uses JetBrains Mono as the default font in all themes. We hope you will enjoy it!

One more ReSharper feature that has been missing in Rider until now is finally here: namespaces can be auto-imported when code is pasted from a file in the solution.

If you edit NuGet-related files manually, we think you’ll be happy to get assistance from Rider, as it now offers initial support for editing NuGet.Config, packages.config, and *.nuspec files, including code completion, syntax validation, and the quick documentation popup.

These smaller enhancements are also worth mentioning: 

• Method separators are now available in C# to visually separate interfaces, classes, methods, and so on.
• The shortcuts Alt+Shift+Up / Down / Right / Left Arrow will execute a block selection in the same way they do in Visual Studio.
• Two pairs of actions, "Move Caret To Code Block Start"/"Move Caret To Code Block End" and "Move Caret To Code Block Start with selection"/"Move Caret To Code Block End with selection", are now supported in C# and follow the same behavior they do in other JetBrains IDEs.
• Documentation tooltips are shown on mouseover for code symbols highlighted as errors.

One more highly requested and long-awaited refactoring available in ReSharper has finally arrived in Rider – Extract Class.

Wondering why you need this? Imagine you have a class doing work that should be really done by two different classes. Using this refactoring is the safest and most effective way to decompose that complex class into two single-responsibility classes. Extract Class will help you choose methods and fields to move from the old class to the new class. It will also warn of any broken dependencies and accessibility issues, and suggest conflict resolution options.

The Solution Explorer view introduces two new useful folders that provide you with more information about your project: Implicit references as a subfolder for the Assemblies folder, and MSBuild import targets.

In addition to that, there are several small updates:

• We’ve added a new feature to the Add References dialog called Recent Assemblies.
• We’ve introduced a simple designer for application settings files (*.settings).
• File properties are available for all files in the Solution Explorer view (in View | Appearance | Details in Tree Views).
• Resx code generation now works better for .NET Standard projects on macOS and Linux.

To give you more control of the unit test coverage results that you get in Rider, we’ve added Coverage Filters. To specify them, go to Preferences/Settings | Build, Execution, Deployment | dotCover | Filtering.

If you do performance profiling on Linux or macOS, we have good news for you: .NET Core applications can finally be profiled in Tracing mode on these operating systems. Also, you can now attach the profiler to .NET Core applications on Linux.

• We’ve added a very handy action: Cancel build.
• There are "Build/Clean Project" tasks for all run configurations. These tasks allow you to select which projects to build or clean before launching a run configuration.
• Support for the UpToDateCheckInput MSBuild property is now available. 
• The UI of “Publish to folder” run configurations now supports “ARM” identifiers and any custom “target runtime” identifiers.
• The bundled MSBuild has been updated to 16.5

We’ve added several new features to Rider’s decompiler and IL Viewer: 

• Nullable Reference Types (NRT) support is available in the decompiler. Please note this currently only works in declarations but not in the methods’ bodies.
• Support for decompiling the default members of interfaces.
• Support for decompiling tuple component names has been improved.
• "IL viewer" Code Vision is now available in external source files after decompilation.

• Code Vision is now able to show the history for a method. This feature is enabled by default instead of VCS Annotate (adjustable in Preferences | Editor | Code Vision | VCS Actions).
• The Git Branches popup gets an explicit search field and a reworked Refresh button.
• Incoming (blue) and outgoing (green) commit indicators have been added to the status bar.
• Check out the new dialog, “Interactively Rebase from Here”.
• The Repositories tool window is now called Git, Subversion, Mercurial, or Perforce, depending on what VCS you’re using.
• The Diff and Merge views now support code highlighting.
• If you don’t have Git on your machine, Rider will offer to download and install it for you.

To improve F# support in Rider, we’ve made tons of improvements and fixes that should help you in your daily routine:

• The Send project references to F# Interactive; action is available.
• The evaluation tooltip on mouseover works for more expressions when you are debugging: self-reference qualifiers in methods and types (this.Property), and indexer expressions ("foo".[1]).
• A Type file template has been added.
• Code analyzers now run in parallel.
• Several new quick-fixes for already existing code inspections, e.g. the Make field mutable quick-fix for the FS0005: Field not mutable inspection.
• A couple of new code inspections with appropriate quick-fixes, e.g. the “Redundant Attribute suffix” inspection.
• Two new code intentions: Elif to If/If to Elif and Negate If expression condition.
• Code Vision has a new action Copy Inferred Type, and it no longer shows parent namespaces for types to make the displayed information shorter.
• Extend Selection can select the whole () expression.

• A new intention for converting to optional chaining and/or nullish coalescing and for inferring parameters from usages.
• The documentation popup can be displayed on mouseover.
• Vuex and Composition API support.
• Running Prettier formatting on save.
• Full file paths in the Go to popup.
• Yarn 2 support for TypeScript projects.
• For more about web development updates, see What’s New in WebStorm 2020.1.

• Export to Excel.
• Support for the utPLSQL and Tsqlt test frameworks.
• See the results in the code editor (disabled by default).
• New authentication options.
• Shared SSH configuration.
• Better filtering data in MongoDB.
• And many more database-related features as described in What’s New in DataGrip 2020.1.

• Support for WIX (Windows Installer XML Toolset) projects finally comes to Rider! 
• A new plugin that supports the Godot game engine is available for Rider 2020.1+. It is open-sourced on GitHub. 
• C# code style settings are now searchable.
• You can have Rider use the same machine-wide (global) settings file as ReSharper in order to synchronize settings for both tools (adjust this behavior with File | Settings | Tools | ReSharper | Synchronize machine-wide Rider and ReSharper settings).
• Code formatting brings new settings that cover the trailing comma for C# Code Styles. They can be found under Preferences | Editor | Code Style | C# | Syntax Style | Trailing comma, and they are also compatible with the StyleCop SA1413 inspection (except in a very few corner cases).

• The new Zen Mode combines Distraction Free Mode and Full-Screen Mode.
• Split the Terminal tool window vertically or horizontally if you want to run terminal sessions side by side. You can invoke the context menu from the Terminal to create, navigate, and close a split terminal session.
• There are a lot of improvements in the HTTP Client. You can autocomplete URLs and navigate to the related endpoints right from the HTTP request files; you can generate HTTP requests from the Endpoints view; and the HTTP client now correctly autocompletes path variables.
• A unified IntelliJ Light theme is now available for all operating systems.
• The top window border on Windows 10 now looks much better in borderless mode.