Configure code inspection settings

Configure design-time code inspection

By default, JetBrains Rider enables design-time code inspection in all files corresponding to the supported languages. If necessary, you can disable it. Regardless of whether or not the design-time code inspection is enabled, you can always run code inspection in specific scope.

You can quickly adjust inspection settings right from the editor, using the 'Pencils' widget or go for a more detailed configuration in the settings:

Switch context for multiple target frameworks

Results of code inspection can vary depending on the target .NET Framework because different versions of the framework have different features and capabilities, which can affect the behavior of the code. In most cases, each file belongs to a single project that targets a single .NET Framework, so JetBrains Rider can unambiguously set a specific framework version context for code inspection in that file.

However, there are two cases when a file can be compiled with different framework versions:

• Multiple framework versions are defined in the project file where the file belongs.

• A file belongs to several projects with different framework versions.

In both cases, the framework version of the current context appears in the editor breadcrumbs, and you can click it to switch the context to another version. In case of the multiple frameworks in the project, the context will be switched for the whole project; otherwise, only the file context will be changed.

In the example above there are two unresolved calls in the file — Exception() and ArgumentException() — but only the second call is highlighted as error because the first one if filtered out for .NETCoreApp 3.1 with the #IF directive and .NETCoreApp 2.0 is selected for analysis.

Exclude files and folders from code inspection

JetBrains Rider allows you to configure the list of files, file masks, and folders that should be excluded from code inspection. The excluded items are ignored by both design-time code inspection and code inspection in specific scope, but they are still indexed by JetBrains Rider, so that you can navigate to or refactor symbols excluded from code inspection.

You can also quickly exclude the current file from code inspection so that JetBrains Rider adds this file to the list of excluded files without opening the options.

You can recognize files where code inspection is disabled by the indicator in the top right corner of the editor.

Partly disable code inspection for generated code

You can also configure the list of files, folders, file masks, and regions that contain generated code. For these items, JetBrains Rider runs only those code inspections that check code for compiler errors and warnings. Some file masks and regions, which are typically used for generated code, for example *.designer.cs are included in this list by default, but you can change the default settings if necessary.

If you use .editorconfig in your solution, you can also mark generated code using the generated_code property. For example:

The list of items containing generated code can also be used for disabling code cleanup for generated code.

Change severity levels of code inspections

Each JetBrains Rider's code inspection has its own default severity level, which is set according to potential impact of code issues that it detects. Most of the inspections have configurable severity level, which you can change.

Note that inspections that detect compiler errors and warnings have corresponding severity levels, which cannot be changed. However, with some compiler warnings, you can use #pragma directives to suppress them. Look for the suppress with #pragma action in the action list upon a specific warning.

You can change severity level of an inspection right from the editor, where a code issue found by this inspection is highlighted.

Another way to save the modified severity level in a shared settings layer, or modifying severity levels of multiple inspections is using the JetBrains Rider Settings dialog Ctrl+Alt+S as described below.

Disable/enable specific code inspections

If some code inspection seems trivial or being of no interest to you, you can disable this inspection so that no relevant issues would be highlighted in the editor or detected when you run code inspection in specific scope. You can enable a disabled code inspection any time later. Some inspections are disabled by default and you can enable them if necessary.

You can disable any code inspection in one of the following ways:

• If there is a code issue highlighted by this inspection in the editor, place the caret at the highlighted code, press Alt+Enter and then choose Inspection [name of inspection] | Configure inspection severity | Do not show.

• On the Editor | Inspection Severity page of JetBrains Rider settings Ctrl+Alt+S, use the search field to find the inspection you want to disable or enable, and then use the checkbox next to it.

The disabled/enabled state of inspections is saved in the shared settings layers, exactly the same way as changes to severity levels.

Use EditorConfig to configure code inspections

If you use EditorConfig to maintain code styles for your project, you can also configure code inspections from .editorconfig files.

To configure code inspections from EditorConfig, you have to select the Read settings from editorconfig, project settings and rule sets checkbox on the Editor | Inspection Settings page of JetBrains Rider settings Ctrl+Alt+S.

As EditorConfig convention suggests, JetBrains Rider will apply inspection settings defined in files named .editorconfig in the directory of the current file and in all its parent directories until it reaches the root filepath or finds an EditorConfig file with root=true. File masks specified in .editorconfig files, for example *Test.cs are also taken into account.

Inspection settings in .editorconfig files are configured similarly to other properties — by adding the corresponding lines:

For example, you can change the severity level of the Possible 'System.NullReferenceException' inspection to Error with the following line:

or you can disable the Redundant argument with default value inspection with the following line:

You can find EditorConfig property for each inspection on pages in the Code inspection index section as well as on the Index of EditorConfig properties page. — just use the browser search to find the property for the desired inspection.

Suppress code inspections in specific scope

One way to ignore specific code issues is to disable the corresponding code inspection. In this case, all code issues detected by this inspection will be ignored everywhere.

Sometimes you may need to suppress a specific inspection in a specific place, while continue to detect other similar issues with this inspection in other places.

For example, JetBrains Rider considers some code to be 'dead' and you can see that it is true. The inspection is helpful and you do not want to disable it. However, you may want to use this code later and do not want it to be highlighted in the editor or appear in the inspection results. To do so, JetBrains Rider allows you to suppress inspections with comments or with attributes. Comments are more convenient for arbitrary pieces of code, attributes are preferable to suppress inspections in whole methods or types.

To suppress all inspections in a type or a method, add the following attribute: [SuppressMessage("ReSharper", "All")].