What’s New in Rider

Source Generators are almost certainly the most talked about feature in the C# compiler. It’s understandable: the ability to create new code right in the compilation process and use it immediately is exciting and could be useful in lots of different situations.

What can Rider do here? Well, it can do what it does best and take the generated files into account while performing refactorings, provide code editor features, and help you navigate to the generated code.

Partial methods are now allowed to have out parameters, non-void return types, and any type of accessibility, making them more useful with Source Generators. Source Generators can use the defining declaration of the partial method to customize the behavior of the generated code.

Another cool addition is init-only properties. Such properties can only be set during the initialization of an object. So finally you can use object initializers without exposing the property as mutable!

Rider is aware of init-only properties and takes them into account when completing your code, performing generative completion, analyzing whether the property changed anywhere, and offering a quick-fix to make it mutable if you change your mind.

The perfect place to apply init is new record types. These are reference types with value semantics that help you achieve immutability, but this time for the whole object. Again, Rider is keeping up with the language, from quick-fixes for choosing your preferred declaration style to basic completion.

Positional records have a compiler-generated Deconstruct() method. Rider supports all deconstruction features in such objects. Notice the popup when introducing a variable: it offers you the choice between single variable or a deconstructing declaration. The same choice will be offered when a function accesses a property of a record object.

Moving on from the big things, local functions are now permitted to have attributes (as well as parameters and type parameters in local functions). This is supported by Rider quick-fixes, including the neat feature of annotating the method as [NotNull] or [CanBeNull] by pressing ! or ?, respectively.

Another useful C# 9 addition is the ability to write top-level programs. No more fighting with Program classes: you can place your entry point code right after the using directives! There is some help available for working with top-level statements as well. There are two rules about top-level statements: they should precede any type or namespace, and only a single file in the project can contain top-level code. Both rules are easy to break when you’re rearranging and copy-pasting code. Rider provides quick-fixes to remedy this by moving your top-level code to the top or to another file.

With target-typed new expressions in C# 9 we can omit the type after the new keyword when it can be inferred from the usage context. Rider provides full support for the feature including the ability to Find Usages of the constructor and configure preferred syntax style. The latter allows you to use new() syntax when a created type is evident while enforcing an explicit type specification in other cases.

By the way, Rider’s new (pun intended) type name hints can help if all the new() in your code gets out of control.

With return type covariance, you’re no longer bound to returning the same type in overriding members as you do in the base class method. There is no longer any need to implement workarounds to return a more specific type.

Pattern matching continues to evolve in the new language version. Matching expressions now allow using relational (<, >, etc.) and logical (not, or, and) patterns, cutting out a lot of the verbosity of the old switch constructs. Rider can assist you with analyzing the patterns and rewriting them in the desired style.

Finally, when lambda discard parameters were introduced, we felt it would be nice to add a quick-fix for them.

That’s about it for the major language highlights. There are smaller improvements added to the language that are supported in Rider 2020.3 as well. This includes target-typed conditional expressions, static lambdas, extension GetEnumerator methods in foreach, function pointer types, and native integer types.

Immediate Window

Introducing a new Immediate Window with code assistance. It allows you to create synthetic variables when the program stops on a breakpoint, and to experiment with your code without restarting the debugger.

When you start a debugging session, the Immediate Window appears on the bottom-right, below the watch variables within the debugger pane. It will accept input only when your application is in a paused state, typically when it has reached a breakpoint.

Type any valid C# code, with the full range of code completion features at our disposal.

Define new synthetic variables. Rider will track those values in the variables window under a synthetic variables collection. You can inspect, pin, and modify those variables like you do any other variables.

You can even call any member functions on the available objects or any static functions available in the current context using any available objects as arguments. Breakpoints on the execution path of the function will suspend the execution as if it was a normal call. The call will have its own part of the stack starting with Function Evaluation, which you can explore in the Frames panel.

New actions

New debugger actions are now available when debugging hasn't started.

Right now, you don’t have to start debugging and navigate through several steps to the method or a place in code you’re interested in. If you use Start Debugging and Run to Here or Start Debugging and Run to Here Non-Stop, Rider will take you there, skipping any breakpoints.

If you want to start debugging your application and stop the execution right in the beginning, as soon as it reaches the application entry point, use the Start Debugging and Step Over or Start Debugging and Step Into actions.

You can find these actions under Run | Debugging Actions in the main menu.

Please note that the actions mentioned above are only available for the .NET Project configuration / .NET Static Method.

Private Source Link

Other debugger updates

Save and compare snapshots

Export diagrams

From the toolbar, you can export the diagram as an image and include it in your documentation.

Unity

Rider 2020.3 brings another great release for our Unity support, with updates to Burst analysis, shader support, and unit testing, as well as a handful of helpful fixes.

Click the icon next to any method marked with Unity’s [MenuItem] attribute, and Rider will tell Unity to invoke the method, right from the IDE.

Rider’s smart support for shaders gets an upgrade, automatically using define symbols from pragmas such as shader_feature and target when analyzing the code. There is a new context picker in the status bar to analyze a shader based on the symbols defined in the location it was included from.

We’ve improved the Burst context analysis with a new Code Vision indicator and new warnings for incorrect SharedStatic usage. You can also use the Alt+Enter menu to quickly add a [BurstDiscard] attribute.

New context actions allow better control of the analysis of performance-critical methods such as Update. You can now tell Rider to stop treating a method as frequently called, or stop highlighting a method as expensive, and you can even start a new performance context from an arbitrary method.

Unit testing gets some great new updates, too, with support for the [Explicit] attribute, and parameterized test features. You can also run both edit and play mode tests in a single test run.

The Unity log viewer tool window has been given some useful UI improvements, notably the ability to filter based on the last time you switched the game to play mode, or the last time the game’s AppDomain was reloaded.

And of course, we’ve fixed a number of issues, including a fix for an infinite “refreshing solution” message when not connected to the Unity editor and a new quick-fix to remove a redundant event message. We’ve also resolved incorrect C# language suggestions for player projects. Please see the changelog for more details.

Rider for Unreal Engine Early Preview

Rider for Unreal Engine is still at the public preview stage and is scheduled for release as part of Rider in 2021. You can evaluate the preview for free until the public release.

F# 5 features

This release adds support for the nameof keyword which helps you convert almost any symbol in F# to its name.

Last but not least, open type declarations are now supported too. Using the open type declaration, you can “open” any type to import static content stored inside of the type.

Other features and improvements

Now you can generate missing overrides in types and interface implementations, using both quick-fixes and context actions. Thanks to Matt for the idea and initial implementation!

There are new syntax-highlighted tooltips to improve code readability. We’d like to thank Saul for the nice implementation.

New context actions to annotate let binding types. Again, special thanks goes to Matt.

We’ve added the ability to configure severities of analyzers provided by the ReSharper backend. Please note that most warnings / errors are still produced by FCS.

There is now an action to rename files to match a module / type name.

The debugger now keeps better track of local variables in async workflows.

New Welcome screen

We’ve redesigned the Welcome screen to make it clearer and more modern. It still has exactly the same functionality, but it is better organized. You can still manage your projects, start tutorials to learn something new about Rider, create new solutions, open existing solutions, or get a solution from VCS.

Search in Solution Explorer

The “true” search comes to the Solution Explorer view! It looks through all the nodes in the solution tree (now even in collapsed nodes) including files, folders, projects, references, analyzers, imports, and packages to give you all occurrences of a search query. You can go through them one by one using keyboard shortcuts or the icons on the toolbar. To open the search field, use the Ctrl+F shortcut or the magnifying glass icon on the toolbar.

Dynamic Program Analysis (DPA)

The DPA plugin is now able to analyze memory allocations when a debugger is attached to a running process.

Azure DevOps

dotCover

The dotCover plugin lets you perform coverage analysis of applications targeting .NET 5 on Windows, macOS, and Linux.

The Unit Tests Coverage window lets you filter coverage results by target framework.

Highlighting provided by dotCover in the code editor can be toggled in the plugin settings or in the 'Configure highlighting level' popup.

dotTrace

The performance profiler now lets you profile .NET 5 applications on Windows, macOS, and Linux.

Azure Toolkit for Rider

In Azure Functions projects, run/debug configurations are shown in the project context menu to make them more accessible. We’ve also reorganized context menus in the Azure Explorer tool window so common actions can be executed quicker.

AWS Toolkit for Rider

Markdown

Inlay Hints

We believe in the power of inlay hints, but we also know that the environment should be kept as clean and uncluttered as possible. We’ve come up with a new "Push-to-Hint" mechanism for inlay hints to keep the best of both worlds.

File header

Code Style & Formatting

You can now adjust the indentation of the current line of code with the Tab key. Assign the Tab key to the Emacs Tab action to use this feature.

Code Analysis

As is typical for all the WPF-like frameworks, code analysis provides plenty of common code inspections with appropriate quick-fixes for both C# code-behind and .axaml files including “Possible ‘System.NullReferenceException’” and “Class/Property {...} is obsolete: Use {...}”.

In addition to the common WPF inspections, there are a lot of Avalonia-specific inspections, such as “Path to resource is case-sensitive” or “ColumnDefinitions tag can be converted to attribute” inspections with quick-fixes. For the latter, there is a context action on ColumnDefinitions="*,Auto,*" attribute to convert it back into a <Grid.ColumnDefinitions> tag.

We’ve added proper support for $self, $parent, ^, and # syntax in Avalonia bindings, as well as proper validation of indexes in the $parent[] array.

There is extended support for CompiledBinding and the x:CompileBindings extension. Rider knows that DataType is required here and prompts you to specify it for bindings in your code.

The “Create from usage” quick-fix is available for all sorts of Avalonia properties.

Avalonia XAML support includes understanding of the CSS-like styling system.

Other notable improvements include:

Unit Testing

Unit tests can be launched for a specific target framework right from the code editor via the Alt+Enter menu.

You can now export the results of unit tests execution from the Unit Test Session tab.

Xamarin

Miscellaneous