What does JetBrains Rider offer a .NET team compared with Visual Studio, and what are the trade-offs?

1. Architecture: two processes

+-----------------------------+      protocol      +--------------------------------+
| IntelliJ platform front end | <----------------> | ReSharper backend (.NET process)|
| (JVM): editor, VCS, DB,     |                    | C# analysis, refactorings,      |
| HTTP client, UI             |                    | inspections, Roslyn analysers   |
+-----------------------------+                    +---------------+----------------+
                                                                   v
                                          .NET SDK + MSBuild (toolset chosen in settings)

Consequences of the split:

• The editor stays responsive while the backend indexes a big solution.
• Memory is used by two processes; each can be tuned separately (Help → Change Memory Settings for the front end, and the backend's own settings).
• If the backend restarts, the UI survives.

2. How Rider loads a solution

1. Rider resolves the .NET CLI and MSBuild to use, shown under Settings → Build, Execution, Deployment → Toolset and Build. By default it follows the SDK that global.json selects.
2. It evaluates each project with MSBuild and runs design-time builds to discover files, references and compiler options.
3. The backend indexes the code. Solution-wide analysis (optional) then reports errors across files you haven't opened.

If the toolset in step 1 differs from what dotnet --version reports in the repo folder, Rider can show errors the CLI build doesn't. Checking that setting is the first step when Rider and CI disagree.

3. Two analysis engines, one result

Both appear in the editor. Only Roslyn analysers run in dotnet build and CI, so a rule that matters to the team should be a Roslyn rule (or an agreed .editorconfig setting), not just a ReSharper inspection.

Suppressions differ too: // ReSharper disable once UnusedMember.Global for inspections, and #pragma warning disable CA1062 or [SuppressMessage] for Roslyn rules.

4. Settings layers

This computer (personal, global)
   +- Solution personal         -> <Solution>.sln.DotSettings.user (not committed)
        +- Solution team-shared  -> <Solution>.sln.DotSettings (committed)
.editorconfig values apply to the files they cover, and are shared with every IDE

The most specific layer wins. For a mixed team, keep formatting and severities in .editorconfig and use the team-shared layer only for Rider-specific options with no .editorconfig equivalent.

5. Feature comparison with Visual Studio

6. Licensing

7. Measuring before choosing

On your own solution, compare:

• time from opening the solution to a usable editor;
• memory of the IDE processes after an hour of normal work;
• inner-loop time from edit to passing tests;
• review noise (formatting-only diffs) before and after aligning .editorconfig.

8. Security and supply chain

Plugins from the JetBrains Marketplace run with your privileges, so treat them like any third-party dependency and keep an approved list. The decompiler is useful for debugging libraries, but respect the licence terms of third-party code you decompile.

9. Try it yourself

1. Open a solution in Rider and run Code → Inspect Code across the solution.
2. Check Toolset and Build and compare it with dotnet --version in the repo folder.
3. Change one formatting option, save it to the team-shared layer and look at the new .DotSettings file.
4. Export code style to .editorconfig and open the file in another editor to confirm it is picked up.
5. Create requests.http with a GET to your local API and run it from Rider.

Suppress a ReSharper inspection for a member called only through reflection (prefer fixing or documenting the reason):

namespace Payments.Worker;

public sealed class SettlementHandler
{
    // Invoked by the message broker through reflection, so the IDE cannot see a caller.
    // ReSharper disable once UnusedMember.Global
    public Task HandleAsync(CancellationToken cancellationToken) => Task.CompletedTask;
}

An .http file that Rider (and Visual Studio) can run:

@baseUrl = https://localhost:7181

GET {{baseUrl}}/health
Accept: application/json

.gitignore entries for Rider per-user state:

.idea/**/workspace.xml
.idea/**/tasks.xml
.idea/**/usage.statistics.xml
.idea/**/shelf/
*.DotSettings.user