Naming style
JetBrains Rider helps you define, control, and apply naming style for symbols in your code. Naming style is implemented as a set of rules, each of which targets specific identifiers with the set of constraints (for example, a rule can target static private readonly fields) . Each rule can have one or more associated styles that define suffixes, prefixes, capitalization of compound words, and so on.
These rules are taken into account when JetBrains Rider produces new code with code completion and code generation features, applies code templates and performs refactorings. JetBrains Rider also helps you detect and fix violations of naming rules. If necessary, the automatic checkup of naming rules can be configured or disabled.
Configure naming rules
Out of the box, JetBrains Rider provides a naming rule for each type of identifier. These rules are based on the Microsoft Naming Guidelines, .NET Platform Coding Style, and various best practices.
If your personal preferences or company standards differ from JetBrains Rider defaults, you can configure the naming style in a flexible way: for each type of identifier you can choose capitalization rules, prefixes and suffixes, variations for different access rights, abbreviations to preserve, and more.
Your naming style preferences are saved using the mechanism of layer-based settings. Among other things, this mechanism allows you to maintain different preferences for different solutions as well as to keep these preferences under a VCS and automatically share them with your team members.
Modify a default naming rule
In Rider settings Ctrl+Alt+S, go to and open the Naming tab.
Select the desired rule in the list on the left.
On the right of the page, check the existing style for the rule.
If the existing style is acceptable, but you would like to allow other styles for this rule, click Add
.png "Themed icon added parameter screen gray")
. When there are several styles for a single rule, JetBrains Rider does not detect code style violation if a corresponding symbol name matches at least one of these styles. Otherwise JetBrains Rider detects a code style violation and suggests renaming the symbol according to the default style (the first style in the list). To change the default style, use Move Up .png "Themed icon up screen gray")
and Move Down .png "Themed icon down screen gray")
buttons. To configure a specific style, select it in the list and configure prefix, suffix, and choose a naming style.
To remove an unnecessary style, select it in the list and click Remove
.png "Themed icon delete screen gray")
.If necessary, you can disable detection of code style violations associated with this rule, allowing JetBrains Rider to detect other code style violations. To do so, clear the Enable inspections checkbox.
Click Save in the dialog to apply the modifications and let JetBrains Rider choose where to save them, or save the modifications to a specific settings layer using the Save To list. For more information, see layer-based settings.
Use EditorConfig to configure naming rules
If you use EditorConfig to maintain code styles for your project, you can also configure naming rules from .editorconfig files.
To configure naming rules from EditorConfig, you have to select the Read settings from editorconfig, project settings and rule sets checkbox on the page of JetBrains Rider settings Ctrl+Alt+S.
You can also export naming styles that you already configured in JetBrains Rider settings to an .editorconfig file.
Naming style settings in .editorconfig files are configured using the properties of .NET naming conventions for EditorConfig: dotnet_naming_rule.*, dotnet_naming_style.*, dotnet_naming_symbols.* — will work if the specified kinds of symbols can be matched by kinds of symbols available in JetBrains Rider naming settings.
In addition to that, JetBrains Rider can use a number of custom properties to support cases not covered by .NET naming conventions. These properties mainly appear in .editorconfig files when you export JetBrains Rider naming settings.
import_to_resharperThis suffix allows specifying whether a specific property should be ignored by JetBrains Rider (
trueorfalse).When JetBrains Rider exports its settings to editorconfig, it could also write
as_predefined— don't change that manually. Example:dotnet_naming_rule.protected_rule_rule.import_to_resharper = falseresharper_descriptionAllows specifying a rule description for tooltips. Example:
dotnet_naming_rule.protected_rule_rule.resharper_description = Somethingresharper_guidJetBrains Rider can use this property when exporting, do not change it manually. Example:
dotnet_naming_rule.protected_rule_rule.resharper_guid = eb5720f3-bc0a-442d-9f3c-8dc32b7c5c12resharper_styleAllows specifying a list of possible styles, which can extend the list of .NET naming styles. Each style could be "style" or "prefix + style + suffix" or "prefix + style" or "style + suffix".
A style can be one of
AaBb,AaBb_AaBb,AaBb_aaBb,aaBb,aaBb_AaBb,aaBb_aaBb,AA_BB,aa_bb,Aa_bbYou can add
:do_not_checkat the end of the list to disable inspections.Example:
dotnet_naming_rule.protected_rule_rule.resharper_style = AA_BB, aa_bb, I+AaBb, aaBb_AaBb, AaBb+Localresharper_applicable_kindsIdentifier kind to apply the naming rule to:
namespace,type,test_type,class,pure_class,record,struct,interface,delegate,enum,type_member,test_member,method,async_method,extension_method,property,event,any_field,field(simple field, not readonly or constant),readonly_field,constant_field,enum_memberlocal,local_variable,catch_variable,local_constant,parameter,lambda_parameter,label,type_parameter,local_functionExample:
dotnet_naming_symbols.protected_rule_symbols.resharper_applicable_kinds = pure_classresharper_required_modifiersstatic,instance(none, one of these or both). Example:dotnet_naming_symbols.protected_rule_symbols.resharper_required_modifiers = static, instanceresharper_csharp_naming_ruleUse the same value as for
resharper_style, but this setting could only be used to specify one of predefined rules:types_and_namespaces,interfaces,type_parameters,method,property,event,locals,local_constants,parameters,public_fields,private_instance_fields,private_static_fields,constants,private_constants,static_readonly,private_static_readonly,enum_member,local_functions,otherExample:
resharper_csharp_naming_rule.private_instance_fields = I+AaBb_AaBb,_+aaBb:do_not_check
As EditorConfig convention suggests, JetBrains Rider will apply naming rules 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.
Ignore uppercase abbreviations that conflict with a CamelCase naming style
Sometimes you may want to use uppercase abbreviations, acronyms, or initialisms (such as MS for MicroSoft) in CamelCase symbol names. By default, JetBrains Rider detects that as inconsistent camel casing because several uppercase letters go in a row:
To avoid that, you can configure the list of abbreviations to be ignored by the naming style inspection.
It is important to note that uppercase abbreviations should not contradict the naming style defined for specific kind of identifier.
For example, if you added MS to the ignored abbreviations, MSBuilder will be an acceptable name for identifiers with the UpperCamelCase style, but not for identifiers with lowerCamelCase or all_lower naming styles.
Similarly, myMSBuilder will be OK for lowerCamelCase- but not for UpperCamelCase-styled identifiers.
Add an abbreviation to the ignore list
In the editor, set the caret at a highlighted symbol that uses the abbreviation in its name.
Press Alt+Enter or click the action indicator to the left of the caret to open the action list.
Choose Inspection 'Inconsistent Naming' | Add [abbreviation] to the abbreviations list
if necessary, you can select where to save this preference. For more information, see Layer-based settings
Detect and fix violations of naming rules
JetBrains Rider uses the 'Inconsistent Naming' code inspection to detect violations of naming rules in your code. By default, this inspection is always applied during the design-time code inspection and highlights the detected violations as warnings in the editor. For example, according to the default style, names of interfaces should have 'I' prefix. If an interface name does not match this rule, JetBrains Rider highlights this name and informs you about the problem when you hover the mouse over it:
If you want to find naming style violations beyond the current file, you can run the 'Inconsistent Naming' inspection in the project or in the entire solution.
Find naming style violations in a specific scope
In the editor, set the caret at a highlighted symbol that has inconsistent naming.
Press Alt+Enter or click the action indicator to the left of the caret to open the action list.
Choose Inspection 'Inconsistent Naming' | Find similar issues in file and then select the desired scope.
All found naming style violations will be displayed in the Inspection Results window.
You can double-click the detected problems to navigate to the code of the corresponding symbols.
For most of the naming style violations highlighted in the editor, JetBrains Rider suggests a quick-fix with a conforming name. You can press Alt+Enter and choose Rename to [conforming name] in the action list.
Automatic correction of naming style violations can also be performed in the current file, project or solution using the fix in scope feature.
However, if the symbol with the calculated conforming name already exists in the same namespace, the quick-fix is not suggested. You can fix the naming of such symbol with the Rename refactoring.
Configure and disable automatic naming rules checkup
If you do not want JetBrains Rider to check naming style in the existing codebase, you can either disable the code inspection that is responsible for it, or disable the automatic checkup of a specific rule. However, even if the automatic checkup is disabled, all naming rules will be respected when JetBrains Rider helps you produce new code with code completion, generation, refactorings, and templates.
Disable automatic checkup of naming style
On the page of JetBrains Rider settings Ctrl+Alt+S, start typing 'Inconsistent Naming', and then clear the checkbox next to the corresponding code inspection.
Disable automatic checkup of a specific naming rule
In Rider settings Ctrl+Alt+S, go to and open the Naming tab.
Select the desired rule in the list on the left.
In the Edit Rule Settings dialog that opens, clear the Enable inspections checkbox.
Click Save in the dialog to apply the modifications and let JetBrains Rider choose where to save them, or save the modifications to a specific settings layer using the Save To list. For more information, see layer-based settings.
Use C# naming rules from existing code
If you check out a solution from a public repo or temporarily join a team where a different code naming style is established, you will probably want to follow naming rules in this solution but at the same time not to change your globally configured naming rules.
JetBrains Rider will handle such situations automatically — when you open a new solution where symbol naming differs from your global settings, it will detect the naming rules that diverge from your global settings, modify these rules accordingly, and then save the modified rules to the 'Solution personal' settings layer (.sln.DotSettings.user file next to the solution).
If this happens when you open a new solution, JetBrains Rider will show a notification in the editor:
You can click Undo to revert these modifications or Configure to open the corresponding settings page ( ). On this settings page, the rules that were changed based on the solution code are highlighted with yellow. If you want to use JetBrains Rider's default naming rules or configure naming style in your own way, clear the Use auto-detected rules checkbox.
