Rider 2021.2

Prend en charge les points de terminaison dans ASP.NET Core, ainsi que le débogage côté client pour les applications Blazor WebAssembly.
Août 4, 2021
Nouvelle Version

Fonctionnalités

  • Support for Microsoft ASP.NET Core Endpoints
    • The new Endpoints tool window helps you explore and navigate to any ASP.NET Core endpoint in your project that is registered or annotated with [Route], [Http{Method}], or [AcceptVerbs] attributes.
    • You can now inspect endpoint documentation or Jump to Source of the controller that implements an endpoint. You can also use Find Usages to see where it is registered.
    • You can now use the HTTP Client tab to create and submit requests to your application. This is useful for testing APIs.
    • You can now try out your API using the bundled OpenAPI Specifications plugin. It adds Swagger UI support for OpenAPI files that you can use to write requests and inspect responses.
    • In the code editor, you will get first-class support as well:
      • When you use HttpClient, code completion will suggest all URIs that can be resolved to actions in controllers annotated with [Route], [Http{Method}] or [AcceptVerbs] attributes.
      • You can easily navigate between route attributes inside controllers and these URIs by using Go to Declaration and Find Usages.
      • Renaming an attribute route in a controller affects its usages in URIs and you can even rename a route directly from the URI string.
  • Blazor WebAssembly Debugging
    • Added client-side debugging for Blazor WebAssembly. It works for Microsoft .NET 5.0 and Microsoft .NET Core 3.1 applications.
    • To get it working on Linux, you have to manually install development certificates beforehand; otherwise, it won’t work.
    • Rider supports the debugging proxy if either of these NuGet packages are installed:
      • Microsoft.AspNetCore.Components.WebAssembly.DevServer.
      • Microsoft.AspNetCore.Components.WebAssembly.Server.
        • There is no support for any custom debugging proxies for Blazor WASM apps right now.
  • Language Support
    • C# Code Analysis:
      • Added new Swap via deconstruction quick-fix which will help you modernize your code.
      • You can now reduce the number of allocations in your code and increase throughput. Just replace empty array creation with Array.Empty<T>.
      • If you’re allocating a new Type[0], Rider will now suggest using Type.EmptyTypes to make memory usage more efficient.
      • If specific EventArgs are not required, Rider can now replace new EventArgs() with EventArgs.Empty.
      • Other improvements:
        • You can now use the generated_code property from .editorconfig to mark files or folders as generated code and exclude them from processing.
        • Code analysis is now faster for members with lots of local functions and closures.
        • Enjoy performance improvements in Find similar issues and code analysis for large and complex switch statements and switch expressions.
    • Nullable Reference Types (NRT):
      • Rider now indicates suppressions (!) that are no longer needed and can be safely removed.
      • Added a new context action which lets you search for all nullable warning suppressions in scope. From the Find Results tool window, you can then re-evaluate whether the suppressions are needed or not.
      • Added a new refactoring to change nullability. It’s available as a quick-fix, through the Refactor This action or through an in-place refactoring when adding or removing the nullable annotation (?).
      • Rider will now update nullability annotations and suggest propagating the changes throughout your codebase.
      • Several new inspections with corresponding quick-fixes are now available for when you’re using JetBrains.Annotations attributes and nullable reference types are enabled.
      • You can now update JetBrains.Annotations attributes to NRT syntax and compiler-supported attributes.
      • Rider will now inform you about redundant JetBrains.Annotations attributes, such as [NotNull] string or [ItemCanBeNull] List<string?>. It will also offer a quick-fix to update your code.
      • When the type annotation syntax is not allowed, a new inspection with a quick-fix adds compiler-supported annotations, e.g.:
        • [JetBrains.Annotations.NotNull] T param to [DisallowNull] T param (where T: class?).
        • [JetBrains.Annotations.CanBeNull] T to [System.Diagnostics.MaybeNull] T (in C# 8, where the T? syntax is not allowed).
      • Added new inspections and quick-fixes to help you with using compiler-supported annotations such as [DisallowNull], [AllowNull], [MaybeNull] and [NotNull].
      • Added a new inspection which detects redundant compiler annotations, such as when [AllowNull] is applied to a nullable type, and a quick-fix removes them.
      • When nullable reference type syntax can be used, Rider will now suggest doing so.
      • Additional improvements:
        • Rider now checks whether variables need to be nullable and produces stricter types when possible.
        • Many context actions, quick-fixes and postfix templates have been updated to work better with nullable warning suppressions. They either preserve nullable warning suppressions or produce them for introduced code if the original code suppressed the warning.
        • Improved support for using generics with nullable reference types.
    • Source Generator support:
      • Source Generators can be used to reduce tedious and repetitive development work and to generate code at compile time. In this release, many of the features available for human-written code files are now available for source-generated files as well. Improved editor support and added support for refactorings as well.
      • Refactorings can now be triggered from source-generated files. Use the Rename refactoring to rename a generated property. Rider will also rename the related symbol in manually written code.
      • Similarly, Change Signature lets you verify whether code that will be generated after the change can still be compiled.
      • You can now use Find Usages, search for inheritors, navigate from generated code to manually written code with Ctrl+Click and Navigate To and more.
      • Semantic highlighting is now enabled so that class members like events, fields and properties are highlighted correctly. All inlay hints are shown where appropriate.
      • For generated code, warnings and errors are displayed in the editor and on the marker bar.
      • Rider now supports code generated by source generators in VB.NET.
  • Game Zone
    • Unity Support:
      • Rider’s smart integration with the Unity editor will now check if any scenes are open and unsaved before you commit code. You can be sure that everything is saved before committing.
      • Rider has long shown a link to Unity’s documentation in the tooltip for a Unity class or method, but now you can use the External Documentation action and shortcut to jump straight to the docs without showing the tooltip first.
      • Rider can now debug local UWP players, by correctly asking Microsoft Windows to allow incoming connections to the process being debugged.
      • The Packages view in Unity Explorer is now significantly faster to display when a solution is reopened and will even remember open folders.
      • This release improves the experience of debugging IL2CPP-based players, by automatically disabling Break on Unhandled Exception when it connects to a IL2CPP player.
      • There are lots of other minor improvements and fixes; for example, [UnitySetup] methods are no longer marked as unused, and layer names are correctly shown in completion for older projects. There are various performance improvements for Unity-based inspections, especially those for large files.
    • Unreal Engine (Early Preview):
      • Support for Unreal Engine 5 - Rider for Unreal works great with the new Unreal Engine 5 projects, just as it does with your existing Unreal Engine 4 projects.
      • Support for opening .uproject files - Rider can now open your Unreal Engine project straight from the <ProjectName>.uproject file.
      • Rider for Unreal Engine now works on Apple Mac - Simply open your <ProjectName>.uproject file and get the full Rider for Unreal experience on your Apple macOS. This includes rich C++ and HLSL shader editing, navigation, inspections and refactorings, code style settings and quick-fixes, Blueprint support (Find Usages of code inside a Blueprint, Code Vision links and counters, and navigation) and debugger and rich integration with the Unreal Editor. The macOS version works with Unreal Engine 4.26 or later.
      • Big improvements for Natvis and the built-in presentation of debugger results - Added support for the inheritable attribute, format specifiers, custom list items and more, including one-line summaries for all structures not covered by Natvis and a [Raw View] node for looking at underlying object data.
      • Expanded Code Style settings - Rider will now recognize an Unreal project and it will automatically configure itself to understand and follow the UE code style conventions. It will highlight code that doesn’t follow the correct style and offer quick-fixes to automatically update your code.
      • The EzArgs plugin provides easy access to the C++ run/debug configuration arguments – just type a new argument in the drop-down on the toolbar.
  • Code Cleanup
    • Merged the Reformat File and Code Cleanup dialogs into one. The shortcuts for both remain the same, but you will have a new unified view that allows both steps to be performed at once. Cleanup profiles will also preview which actions will be executed and you can easily switch to the profile editing mode with a button.
    • In the commit dialog, you can now enable automatic code cleanup of your changes with the profile of your choice. Alternatively, you can use a new option in the Reformat and Cleanup dialog to reformat/clean up only uncommitted changes in the current file.
    • Actions for reformatting code, optimizing imports and rearranging code are now available for CSS, JavaScript and SQL.
  • User Experience
    • Import Settings from other IDEs - The Welcome wizard now lets you import settings from other IDEs such as Microsoft Visual Studio, Visual Studio for Mac or Visual Studio Code. In addition, Rider will recognize settings from ReSharper.
    • Organize tool windows by drag and drop - It is now easier to drag a tool window to the desired place within the main IDE window or in a separate window. You can drag it by clicking and holding the tool window name bar and dropping it in any highlighted area.
    • Transparent title bar (macOS only) - The title bar is now transparent on macOS when the IDE window isn’t in Full-Screen Mode. It means that there is no visible border between the title bar and the rest of the window.
    • Advanced Settings - If you need to configure use-case-specific options in Rider, you can do it in the new Advanced Settings node in Preferences/Settings. For example, you can add a left margin in Distraction-free mode, or set the caret to move down after you use the Comment with Line Comment action.
    • New navigation option in Preferences/Settings - Navigation has been simplified in Preferences/Settings by adding arrows to the top right-hand corner of the window. They allow you to quickly jump back and forth between the sections you’ve opened.
  • Debugger
    • Property values are evaluated and shown in the debugger by default, but sometimes their evaluation can take some time. This is why a new Disable Evaluation of Selected Item action has been added.
    • Especially with native code, it can happen that evaluating a method call crashes the debugging session. Rider will now remember these troublesome calls and disable their evaluation for you.
    • When stepping through codebases, each new file is opened in a new tab, sometimes leaving you with a very polluted tab bar. The preview tab allows you to view files in a single tab one by one without opening each file in a new tab each time.
  • Editor
    • Structural remove - Added structural removal of code. Select and delete code with any kind of structural selection (such as structural navigation, extend/shrink selection or rearrange code) and let Rider perform the remaining structural modifications. You can remove commas and colons for method call arguments, parentheses in attribute arguments or braces for empty object initializers.
    • Quick Documentation - Updated how Quick Documentation is shown. Attributes are now highlighted, so they are easier to read and explore. If you’re inspecting any class or method that uses generics, Rider no longer renders a placeholder value - the concrete implementation is shown instead.
    • Formatting - Pico style has been added as an option to the Brace Layout tab.
  • Front-End Development
    • Reload pages in browser on save - If you preview HTML files in the browser, they will automatically update in accordance with the saved changes in your HTML file or the linked CSS and JavaScript files. This feature is enabled by default.
    • Rename refactoring for React useState hooks - You will no longer need to waste time on refactoring useState values and functions one by one – Rider can now rename both for you. Place the caret on a state value and press Shift+F6 or go to Refactor | Rename from the right-click context menu.
    • Auto-import for require() - The IDE can now add missing import statements as you complete CommonJS modules - required imports will be inserted on code completion.
  • Xamarin
    • Added support for generating .aab (Android App Bundle) in addition to .apk files, which will soon be the only way to upload your apps to the Google Play Store.
    • XCAssets can now be created and edited for imageset, appiconset and colorset right inside of Rider. This allows you to see all the different end devices and their assigned images, icons and colors. Images and icons can be added or replaced via drag and drop. The color picker control has been added for convenient color selection.
    • When editing Android layout or resource files, the Resource.Designer.cs file is now automatically generated, removing all errors that were previously incorrectly shown.
  • F# Support
    • Postfix templates in code completion - Starting with the let template, postfix templates have been added for F# which can help you transform expressions that you have already typed without jumping backward.
    • Actions:
      • Rider now has a new action for pattern deconstruction for F# tuples and union cases.
      • Actions for rearranging the code are now available. You can move elements up/down or left/right in enum or union cases, record or union case fields, match clauses, tuples and function parameters.
      • Another new action that has been added is Optimize Imports, this will free you from the need to manually trigger a similar quick-fix on warnings each time you need to clean imports.
    • Other notable improvements:
      • The Inline Variable refactoring now also works for top-level let bindings.
      • You’ll find significantly better XML documentation rendering in the editor.
      • Language version can be specified in the project properties, and it will be also written to .fsproj.
  • Apple Silicon support (macOS only) (Early Preview) - An early preview version of Rider 2021.2 with full native M1 chip support is now available. This version has no x64-to-ARM64 translation. It uses the following runtimes:
    • The Apple Silicon–compatible JBR (JetBrains Runtime) for the frontend.
    • .NET 6 Preview 4 for the backend.
  • Database Support
    • Generation from a real data source:
      • DDL data source generation is another step in the long-term development of seamless database versioning. With this feature, you can keep your DDL files under a VCS system and regenerate them every time your database structure is updated.
      • It is now possible to generate a DDL data source based on a real one. The DDL files are created locally and the new data source is based on them. This way you’ll always be able to regenerate these files and refresh the DDL data source.
    • Separate folders for functions and procedures - If you turn on the Separate Procedures and Functions option in the database explorer settings (the gear icon), it will immediately take effect. For Microsoft SQL Server there are dedicated nodes for scalar and table functions. For PostgreSQL there is a node for trigger functions.
    • Separate nodes for triggers, keys, and indices - The new database tree option called Show Constraints and Triggers in the Schema assigns triggers, keys and indices their own individual nodes in the database explorer.
    • Completion for cross-database synonyms (SQL Server) - Code completion for cross-database synonyms is now available.
  • Plugins
    • dotCover - dotCover can now run coverage analysis of test classes in parallel within one assembly. In some particular cases, this may result in faster coverage analysis. Preloading of unit test runners is available for .NET Core and .NET projects, which means coverage analysis starts faster as unit test runners are already loaded in memory. Additional improvements:
      • Improved support for C# 8.0 and C# 9.0 in the coverage tree – showing default interface implementations, and more.
      • dotCover now offers to restart Unity Editor if the coverage filters have been changed.
    • Dynamic program analysis (DPA) - DPA now stores two values for each issue - the historical max value and the value from the last run. This prevents false negatives, as it was previously possible for issues to fall below the threshold and disappear from the issue list, not because they had been fixed, but because their launch conditions had changed. There are also several other improvements:
      • DPA is automatically disabled when you start performance profiling.
      • The Dynamic Program Analysis window now supports selecting multiple issues.
      • Suppressing issues with the SuppressMessage attribute now works for asynchronous methods.
    • SpecFlow announced - SpecFlow is a tool to bring Behavior-Driven Development to .NET. The SpecFlow development team has brought a SpecFlow plugin to JetBrains Marketplace, which adds syntax highlighting, code completion, navigation and skeleton code-generation for SpecFlow tests.
    • Featured plugins - The list of the featured plugins you can see in the “Customize Rider” wizard during initial setup has been changed. Now the list is the following:
      • IdeaVim.
      • Heap Allocations Viewer.
      • Rider Xamarin Android Support.
      • Azure Toolkit for Rider.
      • AWS Toolkit.
      • SpecFlow for Rider.
  • Other
    • Solution Explorer - Large directories like node_modules or libs can significantly slow down the indexing of files, which is used for providing fast text search. Rider can now stop certain directories from being indexed from the context menu. You can now edit File Properties (such as Build Action or Copy to Output Directory) for multiple items selected in the Solution Explorer.
    • Assembly Explorer and Decompiler - The embedded decompiler now can decompile single-file apps. It supports single-file formats for .NET Core 3.1, .NET 5 and upcoming .NET 6 SDK. Using Assembly Explorer, you can browse through bundled assemblies inside a single-file app as you are used to.
    • Toolbox App - You will no longer miss any critical product updates from the Toolbox App. Rider will alert you if there is a new version available for download and will offer to upgrade you to it. You’ll need to have Toolbox App 1.20.8804 or later for this.
    • Miscellaneous
      • Razor developers working on large views can turn off the CPU-intensive assistance and automatic suggestions if their editor begins to lag.
      • The Go To Base/Inheritors list now shows hidden overrides, as well.
      • Added support for the log message template from Microsoft LoggerExtensions. Rider now analyzes the code, adds highlighting and offers context actions.
      • Added an option to suppress issues for asynchronous methods.
      • Rider will now warn you when you try to run a 64-bit web application on 32-bit IIS Express ("use64Bit": false in launchSettings.json) in in-process mode.
Rider 2021.2
Inspect endpoint documentation or Jump to Source

Rider

Un IDE multiplateforme de premier plan pour les développeurs .NET et du domaine du jeu.

Demander devis Acheter maintenant

Rider est également disponible en :

Vous avez une question ?

Discutez en direct avec l'un de nos spécialiste des licences JetBrains .