Jetbrains Rider .NET development tool

JetBrains Rider is a cross-platform integrated development environment (IDE) designed for .NET development. It combines the power of JetBrains’ IntelliJ platform and ReSharper to provide powerful code editing and debugging tools.

Key features include:

1. Cross-platform support : Rider runs on Windows, macOS, and Linux, supports .NET Framework, .NET Core, and Mono projects, and is suitable for multiple platforms such as desktop, web, cloud, mobile devices, and game development.
2. Intelligent Code Assist : Provides over 2,500 real-time code inspections, contextual actions, and refactoring tools to enhance code quality and developer productivity.
3. Integrated debugging : Rider comes with a powerful debugger that supports debugging of .NET, Mono, and .NET Core applications, providing inline values, intuitive variable views, and advanced breakpoint configuration.
4. Database Tools : Integrates with DataGrip to provide intelligent SQL editing, execution, and database management tools.
5. Version control integration : Supports Git, Subversion, Mercurial and other version control systems, simplifying code base management and team collaboration.
6. Plugin extension : Rider is based on the IntelliJ platform and supports a large number of JetBrains IDE plugins, which enhances its functionality and integration capabilities.

Rider is a comprehensive IDE that supports a variety of development needs, especially for C# and .NET developers. With Rider, developers can improve development efficiency, ensure code quality, and enjoy the convenience of cross-platform development.

Download

https://www.jetbrains.com/zh-cn/rider/download

JetBrains Rider For Mac v2024.3.4 updates include:

1. Code analysis and repair : Enhanced code analysis capabilities with more code inspection rules and automatic repair options to help developers quickly identify and resolve code issues.
2. Performance Improvements : We have optimized overall performance, especially in loading and operating large projects, significantly improving the responsiveness and stability of the IDE.
3. New features : Added full support for .NET 7, improved support for Blazor and MAUI projects, and enhanced the convenience of cross-platform development.
4. User Interface Update : Improved the user interface to make it more intuitive and easier to use while providing more customization options.
5. Debugging tool enhancements : Improved debugging tools, adding better support for multi-threaded debugging and asynchronous code, and improving the debugging experience.
6. Database support : Enhanced database tools, improved SQL editor and database connection management, and added support for more database types.

These updates are designed to improve development efficiency and user experience, making JetBrains Rider an even more powerful development tool.

What’s new in Rider 2024.1?

Monitoring Tool Window

In Rider 2024.1, we introduced the Monitoring tool window, which allows you to monitor the performance of your .NET applications and collect key metrics behind the scenes while running or debugging.
Learn more

Sticky Rows

We’ve introduced sticky lines in the editor to simplify working with large files and exploring new codebases. This feature pins key structural elements, such as the beginning of a class or method, to the top of the editor, keeping them visible as you scroll. This way, the scope always stays in view, and you can quickly navigate your code by clicking one of the pinned lines.

Collection Visualizer

During debugging, inspecting the state of collections (such as arrays, lists, dictionaries, and other enumerable types) is very useful for understanding the data state of your program and discovering potential problems related to data processing. New in Rider 2024.1 is a collection visualizer that allows you to inspect the contents of a collection, expand and collapse elements, and easily navigate the data structure. This helps to better understand the data state of your program and diagnose problems related to collections, processing, or data handling.
Learn more

Updated New Project dialog

We’ve completely reworked the New Project dialog to make configuring new projects much simpler. It now provides full support for .NET projects, including custom template parameters, and you can install the target SDK and the appropriate MAUI workload directly from the dialog.
Learn more

User interface updates

Updated New Project dialog

We’ve completely revamped the new project dialog to reduce the cognitive load when configuring a new project. The updated dialog includes the following features:

• All .NET project configuration options are supported, such as showing a Progressive Web App checkmark when creating a Blazor WASM application.
• Support for customizing parameters in project templates.
• Allow the required SDK to be installed in the dialog box.
• Allows installation of the appropriate MAUI workload from within the dialog.

Minimize the entire IDE

Previously, you could zoom in and out across the entire IDE, adjusting the size of all interface elements simultaneously. However, the initial zoom range was limited to 100% to 200%. Now, we’ve added a new option that allows users to zoom out to 70%, providing greater customization.

Updated Terminal tool window

The new version brings a redesigned Terminal tool window, improving the convenience and ease of terminal tasks through visual and functional enhancements. This update includes improvements to the user interface and an expanded feature set.
You can enable the new terminal in Settings/Preferences | Tools | Terminal | Enable New Terminal.
For more information about the redesigned Terminal, check out the IntelliJ IDEA blog post.

Code Analysis

C# support

More Set Expression Transformations

You will now get suggestions in your source code to convert more code constructs to collection expressions in C# 12, such as declaration and initialization of empty arrays or ImmutableArrays.

Collection modification analysis

We’ve added a new inspection called “Possible ‘System.InvalidOperationException: Collection was modified’.” This inspection warns you if a collection is modified within a foreach loop, as such modifications could cause runtime exceptions. This analysis also considers the case where the loop is exited after the collection has been modified, which would not trigger a warning. This inspection also comes with a corresponding quick-fix to help you resolve the issue immediately.

Generate | Format Member

Generate | Format Members now generates boilerplate code for your types to override the ToString() method and return a meaningful string. Starting with version 2024.1, this feature also supports more types such as ISpanFormattable, IUtf8SpanFormattable, and IFormattable.

Improve support for disposable resources in asynchronous methods

Improvements to the @MustDisposeResource annotation: C# code analysis now ensures that resources returned by asynchronous methods, including those wrapped by Task and ValueTask, are handled correctly to properly handle the release of these resources and avoid accidentally releasing them themselves.

Task-like return values: 2024.1 release correct analysis of task-like return values ensures that awaited resources are checked for release, and also includes resources retrieved using .ConfigureAwait(…), .AsTask(), or .Result.

Updated “Reconstruct Signature” feature

Here are some improvements from Refactor Signatures:

• Refactoring now supports Deconstruct methods. You can add, remove, rearrange, and rename parameters, and these changes will be reflected in method declarations and usages.
• Code completion is now available for type parameters. For example, when you need to specify a type for List<>, you can use code completion to easily select the desired type, such as int.
• When adding or updating parameters, type namespaces are automatically shortened to keep the code concise. For example, if you specify the System.Collections.Generic.List<System.Int16> type in the Change Signature dialog box, it will be automatically shortened to List in the generated code.

Updated static refactoring

With this release, the Make static refactoring supports primary constructor parameters. They will appear in the list of incoming parameters with a separate icon to help you easily distinguish them. This refactoring also works for local functions.

High resource utilization patterns for solution-wide analysis

We are actively working on improving the high-resource utilization mode of solution-wide analysis to significantly reduce analysis time by more effectively using CPU parallelism. We have also improved the memory allocation profile of code analysis activities to reduce the time spent on garbage collection. While this improvement is ongoing, we encourage you to enable this mode and provide your feedback.

performance

In the 2024.1 release, renaming code elements is faster and more efficient. This change also affects other core components of Rider, improving performance in several features, including Find Usages.

The performance of the Move to Another Type refactoring for static members has been significantly improved to better handle the case of large classes.

Support for the protobuf-net image library

Code analysis now supports the ProtoContract attribute and ImplicitFields enumeration of the protobuf-net library. These two attributes can be used to mark members for serialization. As a result, these members are no longer marked as unused.

F# support

The ability to generate overrides in object expressions is now supported by new quick-fixes for missing members, code completion, and Generate refactoring.

When searching for union usages, you can now see the union case. This makes it easier to see how type instances are created and pattern matched.

We have added a new postfix template for creating instances of record types and object expressions for classes and interfaces.

For F#, we implemented sticky line support, making it easier to see context when working with long types and functions.

Smart spell check

Following ReSharper’s example, Rider will also have an upgraded spelling and grammar checker. The new spelling checker supports more than 20 languages and can catch natural language errors in Rider’s supported programming languages (such as C#, C++, VB.NET), markup languages (HTML, XML, XAML), and comments.

.NET Debugging

Collection Visualizer

Rider 2024.1’s collection visualizer provides a graphical display of collections (arrays, lists, dictionaries, and other enumerable types), with the ability to expand and collapse elements and view individual values, for a better understanding of the state of your program’s data. This helps understand the state of your program’s data during debugging and diagnose issues related to collections, processing, or data handling.

Jump time

While debugging, it’s valuable to know how long the debugger takes to execute code between two breakpoints. If you notice that the debugger takes too long to jump, this could indicate a performance issue in your code. When debugging your application with Rider, you’ll see an inline tooltip showing the time elapsed between the previous and current breakpoints.

Inline breakpoints

Starting from this version, Rider allows you to set multiple breakpoints on a single line of code. If there are multiple statements on a single line of code, you can use the relevant inline tooltip or the shortcut (Cmd + F8) to set breakpoints.

Redesigned “Jump to Cursor” option

In the 2024.1 release, we’ve unified the “Jump to Cursor” functionality with an option in IntelliJ IDEA. The new “Jump to Cursor” option provides a quick way to navigate through debug code. Once the program is paused, you can hover the cursor over the line of code you want to continue running. You can then use the “Jump to Cursor” pop-up menu to execute code until you reach the line where the cursor is located.

Hot Reload with Blazor WASM

Hot reloading is now available when running and debugging Blazor WebAssembly (WASM) applications. Hot reloading works for .cs, .razor, and .css files (including scoped .razor.css files).
This feature is enabled by default. You can configure it by going to Settings/Preferences | Build, Execution, Deployment | Hot Reload.

Support for .NET process dumps

Process dumps are invaluable during debugging because they allow you to examine the program’s state at the time of an error, even if the issue is difficult to reproduce. Previously, Rider could only handle C++ core dumps. Now, the IDE also allows you to import dump files of .NET processes.
To import a process dump, go to Run | Debug Core Dump or drag and drop the dump file into the editor.

AI Assistant

Using AI to explain anomalies

We’ve added a new “Explain with AI” button next to exceptions or error messages in failed unit tests, build failures, or debugging sessions.

Rename with AI

When you rename a local variable, you’ll get AI-powered name suggestions in the code completion popup.

AI Assistant Plugin

Please note that the AI Assistant has been unbundled in the 2024.1 release and is now available as a separate plugin. This change was made to provide greater flexibility, allowing you to better control your use of AI features and tailor the plugin to the needs of your work environment. The AI Assistant still requires an active JetBrains AI subscription.

Game Development

Unreal Engine

C++ support

Some notable enhancements in C++ support include:

• Change Signature provides some new functionality, including the ability to change the type of a parameter between pointer, reference, or value types.
• Outgoing call chains are supported using Call Tracking.
• You can now easily customize the style of generated documentation comments. Additionally, you can now perform syntax checking within documentation comments.
• The reimplementation of C++20 modules improves performance and provides support for internal module partitioning.
• Rider’s C++ support is provided by ReSharper C++. For more details, check out What’s new in ReSharper C++ 2024.1.

Blueprint debugger call stack

We’re excited to add Blueprint support to the debugger call stack. Instead of seeing anonymous memory addresses in the call stack, you’ll now see information about Blueprint calls interspersed with the existing C++ code. Be sure to update to the latest version of the RiderLink plugin!

Slate formatting and smart navigation

In this release, we’ve added support for Unreal Engine’s Slate UI framework, letting Rider know how to use the Go to Definition and Find Usages commands, as well as the Rename refactoring to rename symbols declared by Slate macros.
Rider now formats Slate DSL code correctly, both as a reformat and as you enter it.

Smart Blueprint Function

Rider’s smart integration continues with Blueprint functionality, now supporting the addition of core redirects when renaming UENUM instances, as well as asset path completion for resource names in C++ code.

Perforce updates, Visual Studio interoperability, and more

To improve Perforce support, we’ve made some helpful improvements to make logging in after a session expires easier and to put files into the correct working set during refactoring renames.
We’ve also fixed an issue with UnrealBuildTool that sometimes caused a full rebuild of a project previously built in Visual Studio. This significantly improves the experience of using both IDEs. The fix applies to all versions of Unreal Engine 5.4.
Don’t forget to check out all the C++ changes in the ReSharper C++ Engine.

Unity

Odin Inspector Support

We’re excited to announce that our collaboration with Sirenix is bringing support for the popular Unity asset, Odin Inspector. Rider will recognize and highlight fields and properties serialized by Odin Inspector, provide completions and inspections for group names in layout attributes, and display previews for Odin’s GUIColor class. It also recognizes Odin’s ranged properties and uses them in Rider’s integer value analysis, displaying warnings if values are out of range.

Shader variant improvements

Rider 2024.1 improves upon the shader keyword support introduced in the previous release. You can enable or disable different keywords when editing shader files, enabling and disabling highlighting and code analysis in different preprocessing branches. This release adds support for implicit shader keywords, stage-specific local keywords, and preprocessing directives with the _KEYWORD_DEFINED suffix.

Null value analysis and object lifetime checking

This release updates Unity’s handling of null equality comparisons. Now, Rider highlights when modern C# null checks bypass lifetime checks, instead of warning when null comparisons are performed.

Improvements to debugging, asset indexing, and more

Debugging has been enhanced with more support for DOTS, such as the addition of an Entity child node when inspecting IJobEntity instances in the Watches pane. Pausepoints have also been updated for the DOTS system. The texture debug value visualizer has some bug fixes, and a new collection visualizer helps with working with collections of game objects.
There are also some performance improvements to asset parsing, a fix for issues with identifying serialized fields, and many other minor fixes and updates. You can read more details in the changelog.

Godot

We continue to improve support for Godot, and you can install optional plugins from the Plugins tab in Settings. Recent changes include:

• Syntax highlighting for more Godot file types, including .gd, .tscn, .tres, .godot, and improved highlighting for .gdshader.
• Rider can now automatically detect the correct .NET runtime from launchSettings.json to run or debug Godot tests.
• Added a button to the main toolbar to launch the Godot editor, similar to Unity (JetBrains/godot-support#119).

Web Development

Resolve references to @addTagHelper and @removeTagHelper directives

Rider now resolves references to assembly names specified in @addTagHelper and @removeTagHelper directives in Razor views. As a result, you can now benefit from code completion, find usages, and code navigation. Additionally, Rider highlights any unresolved assembly names as warnings, so you can easily identify them in Razor views.

Blazor component file template

You can now generate additional files, such as .razor.cs, .razor.css, and .razor.js when creating templates.

React quick-fix for prop and state creation

Rider 2024.1 introduces several new React quick-fixes that make it easy to create properties and state. You can apply these quick-fixes using the ⌥+Enter shortcut.

See the Web Development Improvements page for more information.

Version Control Systems

VCS support updates in this release include:

• Support for in-editor code reviews in GitLab and GitHub repositories.
• CI status check in the Git tool window.
• Prevent large files from being committed to the repository.
• New Stash tab in the Commit tool window.
• Options to exclude files and folders from comparison, etc.

Learn more about all the changes.

Working with databases

In Rider 2024.1, we’ve made some notable improvements to working with databases, including:

• Local filters in the Data Editor.
• Single record view.
• Ability to move columns in CSV files.
• More functionality for UUIDs.
• Code style adjustments for multi-line INSERTS.
• The columns of the GROUP BY clause are completed.

For more information about improvements for working with databases, see this page.

plugins

.NET Aspire plugin

The .NET 8 SDK introduces .NET Aspire—a new approach to solving the complex problems of building distributed applications on the .NET technology stack. To support this innovation, we’ve provided a new integration tool—the .NET Aspire plugin for Rider.
The plugin is available for Rider 2024.1 and can be downloaded directly from the JetBrains Marketplace or through Settings/Preferences | Plugins.
For more information about .NET Aspire and the new plugin, please check out this blog post.

Support for Frozen Object Heap (FOH)

The built-in dotMemory profiling tool now supports the Frozen Object Heap (FOH), a new feature introduced in the .NET 6 SDK to improve garbage collection performance.
The FOH allocates a dedicated area of memory for immutable objects. These objects remain unchanged after allocation and are not subject to garbage collection. Support for the FOH allows dotMemory to analyze the memory usage of immutable objects in the FOH in more detail, thereby improving memory usage optimization.

Provides performance and memory profiling for desktop MAUI applications support/dotUltimate

The built-in dotTrace and dotMemory profilers now support MAUI and .NET macOS applications.
Supported target frameworks:

• MAUI Windows: net8.0-windows, net7.0-windows.
• MAUI Mac: net8.0-maccatalyst, net7.0-maccatalyst.
• macOS applications: net8.0-macos, net7.0-macos.
  More information on available profiling modes can be found here.

New Azure Toolkit plugin

The new Azure Toolkit for Rider plug-in is an open source project that helps .NET developers easily create, develop, configure, test, manage and deploy highly available and scalable web applications on Azure. The
plug-in can be downloaded and installed from JetBrains Rider and is available in the JetBrains Marketplace.

Enhanced GitHub Actions support

This update enhances support for GitHub Actions, providing more efficient CI/CD workflows with intelligent features tailored for GitHub Actions.
The list of improved features includes:

• Extensive code completion support for various GitHub Action contexts.
• Branding support for action.yml.
• Code completion for Docker images.
• JavaScript file path completion.
  To learn more, check out the related post on the IntelliJ IDEA blog.

Drag and drop project files onto the type dependency diagram

The type dependency graph was introduced in version 2023.3 and is configured using the Configure button. The new graph configuration methods are:

• Use the search to build nodes in the configuration.
• Removes a node from the graph view.
• Add related types to the chart for a specific type.
• Drag and drop project files into the type dependency diagram.

For more information on creating type dependency graphs, see this blog post.

WebAssembly

Decompiler

The assembly explorer in Rider now supports WebCIL, the WebAssembly wrapper format.
Support includes:

• Decompile WebCIL.
• View the .wasm file in Assembly Explorer.
• The metadata subtree for a WASM node including the WASM and WebCIL headers.

This is the latest change to Rider 2024.1, I hope it helps you.

JetBrains Rider is a unique cross-platform .NET IDE created by JetBrains and designed to optimize developer workflows. A netizen named “DevMaster” said:

“Since using Rider, I can’t go back to other IDEs. Its smart prompts and code refactoring tools are the best I’ve ever seen. – DevMaster”

Rider’s functions and features

JetBrains Rider combines the power of ReSharper with the excellent user experience of IntelliJ to provide a powerful development tool for .NET developers.

Here are some of the key features:

Function	describe
Code Analysis	Provides 2200+ code inspections to automatically and quickly fix code problems; can analyze errors in the entire solution
Code Editing	Intelligent code completion, code templates, adding matching code blocks, etc.
Refactoring	Support various refactoring operations, such as renaming, extracting methods, etc.
Unit Testing	Supports mainstream testing frameworks and can run and debug tests
debug	Built-in debugger, supports debugging of .NET, Mono and .NET Core applications
Database Management	Connect to the database, directly edit the database structure and data, and write SQL queries
Navigation and search	Quickly find what you need in the codebase
Front-end development	Supports front-end technologies such as JavaScript, TypeScript, HTML/CSS, etc.
Scalability	Support various plug-ins to extend IDE functions

1. Intelligent Code Editor : Rider provides deep code analysis and a comprehensive set of smart hints and auto-completion tools to help you write high-quality code.
2. Powerful refactoring tools : Rider provides 450+ refactorings and 2500+ inspections to help you improve your code easily.
3. Seamless integration : Rider integrates many common development tools, including version control systems such as Git, Subversion, and Perforce, as well as database tools, Docker, HTTP clients, etc.
4. Cross-platform support : Rider supports Windows, Mac, and Linux, so you can develop .NET applications on your favorite platform.

Here is a list of some of the .NET technologies and languages supported by Jetbrains Rider 2023 for Mac:

Technology/Language	Support Status
C#	✔️
VB.NET	✔️
F#	✔️
ASP.NET	✔️
.NET Core	✔️
Xamarin	✔️
Unity	✔️
SQL	✔️
JavaScript	✔️
TypeScript	✔️
HTML/CSS	✔️

Rider’s evaluation

JetBrains Rider excels in many areas. Its IntelliSense and code refactoring tools are among the best I’ve seen, contributing significantly to both code readability and maintainability. Its integrated tools are also incredibly convenient, allowing you to manage everything from version control to database management within the same interface.

However, Rider also has some areas that need improvement. First, while its performance is good in most situations, some lag can occur when working with large projects. Additionally, while Rider offers a large number of configuration options, this can make it difficult to find specific settings.

Overall, JetBrains Rider is an excellent .NET IDE. Whether you are a novice developer or an experienced professional developer, it can provide the tools and features you need to help you develop .NET applications more efficiently.

Rider – The next generation cross-platform .NET IDE from JetBrains

As a leading developer tool brand, JetBrains enjoys a strong reputation within the .NET developer community. Its new generation of cross-platform .NET IDE, Rider, integrates numerous innovative features and is attracting a growing number of .NET developers.

Key Features of Rider

As a new generation of cross-platform IDE, Rider has the following core features:

characteristic	describe
Cross-platform	Runs on Windows, MacOS, and Linux
Support for multiple project types	Supports .NET Framework, .NET Core, Mono, etc.
Rich code editing	Smart tips, refactoring, templates, etc.
Powerful code analysis	Various code checks, error fixes, etc.
Integrated debugger	Support debugging for .NET, Mono, and .NET Core
Unit Testing	Provide test case management, code coverage, etc.
Database Management	Allows direct editing of the database, writing SQL queries
Version Control	Provide GIT, SVN and other version control system integration
Scalability	Support various plug-ins to extend IDE functions

Jetbrains Rider 2023 Mac version is developed with the help of IntelliJ platform, and deeply integrates the code analysis engine from ReSharper. While ensuring powerful functions, it also ensures the lightweight and responsiveness of the IDE, which is of great help to development efficiency.

Rider’s Advantages

Compared with other .NET IDEs, Rider has more advantages:

• Cross-platform : Rider can run on mainstream Windows, MacOS, and Linux systems and has cross-platform portability.
• Powerful : It integrates the functions of ReSharper engine and IntelliJ platform, and has powerful editing, analysis, debugging and other functions that other .NET IDEs do not have.
• Fast speed : Developed based on the IntelliJ platform and optimized specifically to ensure Rider’s lightweight and high responsiveness.
• Supports multiple application types : can be used for the development of various .NET applications, such as desktop applications, mobile applications, Web applications, games, etc.
• Extensible : supports various plug-in extensions and can customize the IDE environment as needed.

Rider users

Rider has been adopted by many well-known companies and organizations, including:

• Unity Simulator
• Stack Overflow
• Event Store
• OCTO Technology
• AutoScout24

These users choose Rider to improve their .NET development efficiency and quality.

Full .NET support

No matter what kind of .NET application you are developing, Rider has full support for you:

• Supports .NET Framework, .NET Core, Mono and other frameworks
• Supports development of desktop applications, Unity games, Xamarin applications, ASP.NET websites, etc.

Code analysis, smart prompts, refactoring, testing, debugging, Rider speeds up .NET development!

Powerful

• Code analysis : Over 2,200 real-time checks to help you eliminate code problems
• Smart editing : Rich code completion, templates, refactoring, etc., making coding more powerful
• Refactoring : Extract, move method and more than 60 refactorings can be used at will
• Test : Easily run and debug NUnit, xUnit and other tests
• Debugging : Full support for .NET debugging, visual stack information
• Database : Connect to the database and run queries. There is no faster database client.
• Navigation : symbol jump, call hierarchy is clear at a glance
• Extension : Supports plug-ins such as WebStorm and ReSharper, with more powerful functions

Cross-platform use

Rider can run on Windows, Mac, and Linux systems. You deserve the convenience brought by cross-platform.

Summarize

JetBrains Rider helps you code faster and more smoothly in .NET. It supports comprehensive and extensible .NET development features, allowing you to focus on creativity rather than configuring tools. If you’re a .NET developer, Rider is the perfect companion for you!

The release of Jetbrains Rider 2023 for Mac provides .NET developers with a more powerful, cross-platform, and portable IDE. It integrates the latest code analysis and editing features and offers excellent performance. We believe that as its release progresses, more and more .NET developers will choose Rider to improve their development efficiency. It has the potential to become one of the most popular IDE tools in the .NET space.