Rider 2022.3

Performance

• The Rider installer is now able to add executable files to the Microsoft Windows Defender exclusion list, providing a significant startup speed boost.
• Rider can now load a solution file and build its project tree instantly without having to wait for the backend to initialize.
• Removed all loading bars from the solution explorer to achieve a cleaner UI. From now on, all these loading progress bars will be rendered in the IDE Status bar.
• Added a new C# parser, which provides basic syntax highlighting during startup and the full experience once Rider is started and your solution is loaded completely.
• Enabled server garbage collection (GC) to get better memory throughput for the backend process.
• Updated the runtime for the Rider backend language service from Microsoft .NET 6 to the latest .NET 7 version.
• Design-time builds are now run in parallel when projects have no interdependencies.

WSL 2 support

• Rider now supports WSL 2 (Microsoft Windows Subsystem for Linux 2) through the IDE’s remote development functionality. This means you can use Rider on a WSL 2 instance to browse your solutions and sources as well as to build, debug, and run apps as if they were stored locally.

UI/UX

• Docking tool windows - You can now dock tool windows to floating editor tabs this makes arranging your working space and interacting with Rider on multiple monitors more convenient.
• Updated Search Everywhere - Fine-tuned the algorithm behind the Search Everywhere result list to make its behavior more predictable and its ability to select the elements you’re searching for more accurate. Now, when you start typing your query, the IDE freezes the first search results that appear and doesn’t re-sort them when more options are found (as was the case with earlier versions).
• New Attach to process dialog - Added a new Attach to process dialog to improve your user experience, particularly when attaching to a process via SSH.
• Reworked paste action - Improved editing experience by reworking the behavior of the paste action (⌘V / Ctrl+V). Now when you copy (⌘C / Ctrl+C) or cut (⌘X / Ctrl+X) a line without any code selected, the paste action will add the contents of the clipboard above the current line, not at your caret as it did in previous versions.
• Paste JSON as Classes - There’s now an Edit | Paste Special: JSON as Classes action that lets you “smart paste” objects.
• New UI [Early Preview] - You can now switch to the new UI for IntelliJ-based IDEs.
• Other - Made some small optimizations for Rider’s UX and UI to make it more relevant and useful:
  • Cleaned up the Add menu so it only presents relevant items for the current solution or project.
  • The Open in Terminal action is now in the Solution Explorer context menu.
  • The File | New at the top menu has been renamed File | New Solution to better reflect the actual action it will execute.
  • Added an action for switching between solutions within the solution explorer.

Microsoft .NET 7 SDK Support

• Rider now officially provides support for the .NET 7 SDK including:
  • Updated project templates.
  • NuGet Central Package Management.
  • Support for ASP.NET minimal API route groups in the Endpoints tool window.
  • New C# 11 features, including file-local types, UTF-8 literals, ref fields, and scoped keyword.
  • The ability to create, run, and debug projects targeting the new SDK.

C# support

• C# 11
  • UTF-8 literals - Added basic support for UTF-8 literals. The code analysis now suggests using a u8 suffix for a literal instead of the System.Text.Encoding.UTF8.GetBytes() method or a byte array with proper UTF8 symbols. There is also a set of compiler warnings and errors for UTF-8 literals.
  • File-local types - Added basic support for file-local types includes understanding of the new syntax, a file accessibility modifier for types, and compiler warnings and errors with corresponding quick-fixes, like Move class to outer scope when the file modifier is specified for a nested class. There is also a useful context action to convert a general type to a file one.
  • Raw strings - Rider can now convert regular and verbatim strings into their raw counterparts. This also means that numerous existing features for strings are now available for raw strings.
  • List pattern suggestions - Introduced suggestions to use the new C# 11 list pattern syntax (instead of conventional collection length checks with subsequent indexer access expression) to check the corresponding items of the collection.
  • Static virtual members - Starting from C# 11, you can now use abstract and virtual modifiers for static members in interfaces and use such members in generic code with type parameters constrained by this interface. Rider has been updated to handle polymorphic static members the same way ordinary polymorphic members are handled:
    • Inheritance marks on the gutter.
    • Navigation to implementing/super members.
    • Generation of missing implementations.
    • Code completion suggestions after the override keyword also include interface members, so now you can easily implement abstract or virtual static members.
  • Unsigned right shift (>>>) operator - Rider now recognizes the cumbersome code pattern that C# developers have to write to perform an unsigned right shift for signed data types and suggests using the unsigned right shift (>>>) operator in C# 11 instead.
  • Pattern matching over spans - If you parse Spans of characters you probably use the MemoryExtensions.SequenceEqual method a lot. C# 11 introduces a shorthand for this kind of check. You can now simply pattern-match Spans of characters against string literals with is or switch expressions. Rider now suggests using is or switch expressions instead of lots of if statements.
  • ref fields and scoped keyword - Starting from C#11, you are now allowed to declare ref fields inside ref structs. Rider supports this new syntax rule, provides all compiler errors and warnings, shows a ref keyword in the code completion, and allows such fields to be initialized in a constructor.
    • Rider is also aware of a new scoped keyword which you can use on by-ref or ref struct arguments and local variables. The support includes correct parsing of the new syntax, the scoped keyword in code completion, and preservation of the scoped keyword when generating method overrides. It also verifies the compatibility of scoped modifiers and offers quick fixes for mismatched scoped parameters on overrides, interface implementations, and delegate conversions.
    • C# 11 and .NET 7 also introduced changes in the language's ref safety rules. The changes govern what operations are available for by-ref and ref struct variables in order to provide ref safety in managed code with the introduction of ref fields. Rider is aware of the changes and will help you find the parts of your project that need to be updated and annotated with the new scoped keyword to accommodate the changes when migrating to C# 11 or .NET 7.
• Language injections
  • This build brings a number of language injection improvements:
    • Added support for language injections using the [StringSyntax] (from .NET 7) and [LanguageInjection] (from JetBrains.Annotations) attributes, as well as support for the // lang=<language_name> language injections instruction comment.
    • Language injections are now possible in interpolated strings and string concatenations for any language, whereas before it was only available for SQL. Please note that syntax errors are suppressed when using either string interpolation or concatenation with arbitrary expressions. Language injections inside C# 11 raw strings are also supported.
    • An indent guide separating the indentation from the actual value is now displayed on raw strings.
• General C# updates
  • Global imports gutter mark - Added a new gutter mark icon to notify users about implicit namespace imports in C# and Razor files. Rider also presents global imports from _Imports.razor and allows navigation to corresponding import definitions.
  • Machine learning-assisted completion for C# - In an effort to help you streamline and speed up your development process, ML-assisted element sorting has been introduced for code completion options in C#. To enhance your experience using this feature, there are two options you can enable in Settings/Preferences | Editor | General | Code Completion | Machine Learning-assisted Completion:
    • Mark position changes in the completion popup.
    • Mark the most relevant item in completion popup.
  • Format string completion - With the addition of Int128 and UInt128 numeric types in .NET 7, the code completion format specifier suggestions have been updated. Missing support for DateOnly and TimeOnly date/time types from .NET 6 has also added, as well as the half-precision floating point numeric type introduced in .NET 5.
  • Trivial patterns to expressions - Sometimes after refactoring, your pattern-matching expressions may turn into trivial recursive patterns. At this point it may not be worthwhile to use the recursive pattern syntax at all, so Rider now offers the action of rewriting patterns into simpler expressions while preserving the original pattern-matching semantics.
  • Code completion hints for a void expression - Sometimes when you type after an invocation, you see hardly any meaningful suggestions. This can happen if the invocation resulted in no value being produced when the void-returning method was invoked. Usually it takes a few IDE actions to realize that (going back and navigating to the method declaration, or hovering the mouse over the invocation). This release introduces the void hint item over this type of void-returning invocation to give you immediate feedback about the type resulting from the invocation. Accepting this void item will add a semicolon after the invocation if the semicolon is missing.

Web development

• Blazor - This release introduces Hot Reload for Blazor Server Apps. When you modify source code in your Blazor Server app while the app is running, Rider will ask you whether you want to apply this change to the running app without restarting it.
• Internet Information Services (IIS) - Added a new IIS Application run configuration for running and debugging classic ASP.NET applications on an IIS Server. Support for the IIS command name from the launchSettings.json file for ASP.NET Core applications has also been introduced.
• Endpoints - Improved Endpoints support and the Endpoints Viewer. The viewer now correctly recognizes and collects endpoints for ASP.NET Core 7 minimal API route groups. This means that you can search, navigate through and use smart code completion on the endpoints declared with MapGroup() API, in addition to the features that were already available.
• .NET User Secrets - The .NET User Secrets action has been added for ASP.NET projects.
• JavaScript/TypeScript web projects - Rider now auto-generates an npm run configuration for JavaScript and TypeScript web projects (.esproj) referenced by the solution (.sln).
• Code Vision for JavaScript and TypeScript - Code Vision inlay hints now also work for JavaScript and TypeScript. These hints will make it easier to track the usages of various classes, methods, type aliases, and interfaces in your code.
• CSS support - The IDE now understands the @supports at-rule, which associates a block of statements with an @supports condition. This build also includes support for viewport units, range media queries, container queries, @layer (Cascade layers), and color modification functions.
• Updates for Angular - Added support for type narrowing in Angular templates, which will provide more precise type information and better code completion suggestions. Additionally, Rider now excludes the .angular cache folder from global searches to help provide better search results.

Game Development

• Unity support
  • Added support for Unity’s new Input System package. Rider will recognize when methods are used as event handlers for inputs and will no longer show them as unused. Find Usages also works on these methods, showing where they’re used in code or in the .inputactions file.
  • Rider can now help ensure you’re using the correct path in Resources.Load methods. It displays code completion as you type and highlights any unknown resources with a warning.
  • Rider has offered completion and verification of tag names for several releases, and this release adds new support for the GameObject.FindWithTag group of methods. It provides code completion while you type and warns you if you try to use a tag that doesn’t exist in the project.
  • In Unity projects, it’s very important to keep meta files in sync with files and folders. This release will warn you if you’re trying to commit a meta file for an empty folder into source control. If the Unity editor is open, Rider will now warn you if there are any unsaved scenes or assets, helping you make sure you don’t miss changes when you commit.
  • Reduced the time it takes to load exceptionally large projects.
  • Added a notification that appears if you try to edit a read only package file.
  • Improved Find Usages so it can be used for methods in nested prefabs and arrays of event handlers.
  • In DOTS support, Rider now knows not to mark classes implementing IBaker or IAspect as unused.
  • You can now disable the naming inspections for serialized fields and have them treated just like normal fields, and links to online documentation are now pointing to the right places.
• Unreal Engine support
  • Rename with CoreRedirects - Rider already provides the option to add CoreRedirects when renaming Unreal classes or properties via the Rename refactoring. This now also works for:
    • Renaming UFUNCTION().
    • Renaming USTRUCT().
    • Renaming UENUM.
    • When you perform the Rename refactoring, Rider now suggests adding CoreRedirects in these cases. If you agree, then the corresponding .ini file will be updated automatically.
  • Updated Code Vision for Blueprints - Added a new Blueprints-specific Code Vision metric. You can now quickly check how many Blueprints use the BlueprintCallable function and get the list of all usages from the Code Vision context menu.
  • Generate GUID - The Generate GUID tool now supports the Unreal Engine GUID format. Whenever you need to quickly generate a GUID, just choose Tools | Generate GUID... from the menu, and the preferred hexadecimal format will be pre-selected.
  • Auto-import - The auto-import on completion feature can save you tons of time. But if it adds an incorrect #include directive, the problem may be tricky to detect. This functionality has been improved to make sure it doesn’t suggest unwanted entities from system headers in auto-import. By default, system headers are not suggested, but if you want them to be, you can enable them in Settings/Preferences | Languages & Frameworks | C++ | Unreal Engine.
  • UnrealBuildTool Log - Improved the presentation of UnrealBuildTool logs. To make sure you do not miss any warnings about or errors involving project configurations, the log panel now includes timestamps and keeps logs from the previous runs of UnrealBuildTool.
  • Native .uproject support - For Unreal Engine–based projects, Rider works with both .sln and .uproject projects. Support for the native .uproject model has been enhanced to make it more accurate and comfortable to work with:
    • This release respects additional source locations specified in .project, specifically AdditionalRootDirectories and AdditionalPluginDirectories.
    • It also supports custom programs placed in the game location and generates all the programs' project files correctly.
    • Rider now supports modules with several .Build.cs files for platform-specific modules.
    • Completion and inspections in .uplugin and .uproject files are now supported when using the .uproject project model.
    • Run configurations are now auto-generated for C++ programs whenever the .uproject model is used.
  • Attach to Unreal Editor - Added an Attach to Unreal Editor action for Unreal Engine projects. It allows you to quickly attach to an Unreal Engine process instead of having to manually search for the right one. Currently, you can only attach to the same process that UnrealLink is connected to, meaning the project running in Unreal Editor should correspond to the one you’re working on in Rider.

ARM64 support [Early Preview]

• Added the ability to run on Windows and Linux ARM64. All of the basic development workflows are supported, including running and debugging your .NET applications and running unit tests.

Plugins

• Memory Profiling on Apple macOS and Linux [dotUltimate] - In addition to Windows, dotMemory is now available for JetBrains Rider on Linux and macOS.
  • Two new profiling modes are available in the Run widget and in the Run | Switch profiler configuration menu - Memory (sampled allocations) and Memory (full allocations).
• Dynamic Program Analysis - Dynamic Program Analysis (DPA) has new inspections that let you find various issues related to database usage, namely:
  • Long command execution times.
  • Too many database connections.
  • Too many simultaneously executed database commands.
  • Commands returning too many records.
  • The new inspections are available for all applications that use Microsoft Entity Framework Core and .NET Data Provider for Microsoft SQL Server.
• dotCover [dotUltimate]
  • Easier navigation to tests - Added the Show Covering Tests action to the dotCover context menus in both the code editor and Unit Test Coverage window. This action shows a popup with all covering tests together in the same place. The popup also lets you create a new coverage session.
  • Faster shadow copying - dotCover now only copies the assemblies and symbol files required for continuous testing in JetBrains Rider. This improves dotCover’s overall performance, especially on large projects, as it no longer needs to copy the entire working directory. If necessary, you can adjust the shadow-copy file filter in the dotCover settings.
  • Improved Unity support - Previously, to analyze the coverage of Unity tests you had to restart Unity with coverage support enabled. Beginning with this release, restarting Unity is no longer required and test coverage is supported out of the box.

NuGet support

• Whenever you’re using open-source NuGet packages in your solutions, there’s a risk of exposing your project to security vulnerabilities. To mitigate this risk, vulnerable dependency detection has been introduced in Rider.
  • The IDE will alert you to vulnerable dependencies associated with the use of NuGet packages by providing notification popups, which can be further investigated in the Security section of the Problems view.
  • Information about vulnerable dependencies associated with packages included in the solution can also be found in the NuGet Package Management window by selecting a particular package.
• Improved the scrolling experience inside the Packages list in the NuGet tool window.

F# support

• Better XML documentation support - Typing < inside a comment will now add a documentation template. Additionally, syntax highlighting and code completion make editing documentation comments much easier.
• Code completion for records - Added a new code completion rule which simplifies typing record expressions, as it emphasizes fields from the inferred record type, hides any that are already used, and fixes various cases where no suggestions would be shown previously.
• Signature files - Added new quick-fixes, Update parameter name and Update record field, which update signature files, making it easier to use them when changing code.

Database support

• Added new features for working with databases:
  • Quick filter - You can now filter results and hide non-matching objects when using quick search.
  • Pattern-based schema filtering - You can now choose databases or schemas for introspection based on regular expression patterns.
  • Formats for date/time fields - You can customize how fields of date and time types will be displayed in the data editor.
  • Multiple edits in the Modify window - You can now edit several objects at a time.

Miscellaneous

• IL Viewer - Rider's IL Viewer tool window is now able to decompile code into different levels of C# language constructs. There are two C# levels available: high-level, with certain syntax constructs simplified using the latest language features, and low-level, for cases when you want to know how these syntax constructs are desugared.
• Code highlighting - Code highlights and squiggles in this release received an overhaul. Due to a difference in internal logic, Rider used to come into conflict with Microsoft Roslyn’s code style analyzers, causing it to display overlapping highlighting, draw the same highlight in different spots, or double the squiggles. The differences in logic behind the majority of such instances have now been resolved, and for the rare outlier cases, there are errors with clear suggestions on how to resolve the conflict. Additionally, Rider will now show Roslyn Analyzer ID and URL Reference in a Quick Documentation tooltip for inspections produced by Roslyn Analyzers.
• C++ formatting - Added the option to run a clang-format binary directly instead of using Rider’s formatter engine, ensuring full compatibility with the industry-standard formatter, as well as better performance and a more extensive range of formatting options.
• Debugger - Improved the debugger’s performance with the Allow property evaluations and other implicit function calls option disabled. It can now evaluate many more expressions in no-side-effects mode for .NET, .NET Framework, and .NET Core projects.
• Unit testing - Made the unit test explorer tree “lazy” so that it will be faster and less taxing on memory. Previously, all nodes would be created automatically along with the unit test tree, causing it to lag when explored and consuming too much memory. Now, only the nodes belonging to the expanded parts of the tree will be created, giving you noticeably improved performance.
• MSBuild - Enabled default server garbage collection for .NET Core 17+ MSBuilds. Rider can now detect when the 32-bit version of MSBuild is out of memory and switch to using the 64-bit version from Microsoft Visual Studio.
• Performance - Solution Wide Analysis and the Find usages command have been refactored.