JetBrains Rider 2018.2 Help

Managing and Applying Code Formatting Rules

Code | Reformat Code

An important aspect of code style is how to format the code, i.e., how to use whitespaces and blank lines to arrange and separate code blocks, whether and how to use tabs for indents, whether and how to wrap long lines, etc.

The extensive set of JetBrains Rider code formatting rules has a default configuration that takes into account numerous best practices. You can configure every detail of formatting rules and enforce the rules in your code. These rules are applied when JetBrains Rider produces new code with code completion and code generation features, applies code templates and performs refactorings. The formatting rules can also be applied to the existing code in the current selection, current file, or in a larger scope up to the entire solution.

Auto-formatting edited and pasted code

When you type code in the editor, JetBrains Rider reformats expressions as soon as you type a semicolon ; and reformats blocks of code as soon as you type a closing brace }. If necessary, you can disable these kinds of auto-formatting on the Editor | General | Typing Assistance page of JetBrains Rider settings (Ctrl+Alt+S).

JetBrains Rider also lets you automatically apply your formatting rules when you paste code. By default, pasted code is not fully reformatted but only indentation settings are applied. If you want to fully format pasted code, or disable formatting on paste, use the Auto-format on paste selector on the Editor | General | Editor Behavior page of JetBrains Rider settings (Ctrl+Alt+S).

Reformatting existing code

JetBrains Rider provides several ways to reformat existing code. In short, you can always use Ctrl+Alt+Enter, but there are a few details and alternatives described below.

To reformat existing code in any scope

  1. Select the scope where you want to reformat code:
    • Make a selection in the editor to reformat code in the selection.

    • Set the caret anywhere in the file to reformat code in the file.

    • Select one or more items in the Solution Explorer to reformat code in files under these items and their child items.

  2. Press Ctrl+Alt+Enter or choose Code | Reformat Code from the main menu. Alternatively, you can press Ctrl+Shift+A, start typing the command name in the pop-up, and then choose it there.

You can reformat code in the current selection right from the Alt+Enter action list.

To reformat code in the current selection

  1. In the editor, select a block of code that you want to reformat.

  2. Press Alt+Enter or click on the action indicator to the left of the caret to open the action list.

  3. Select ThemedIcon CodeCleanupOptionPage Screen Gray Format selection in the action list.

    Reformatting currently selected code

Alternatively, you can use code cleanup to reformat code in any scope. Code cleanup may be helpful if you want to combine code reformatting with applying other code styles.

To reformat code with Code Cleanup

  1. Select the scope where you want to reformat code:
    • Make a selection in the editor to reformat code in the selection.

    • Set the caret anywhere in the file to reformat code in the file.

    • Select one or more items in the Solution Explorer to reformat code in files under these items and their child items.

  2. Choose Code | Code Cleanup in the main menu.

  3. In the Code Cleanup dialog that opens, select the Default: Reformat Code profile.

  4. Click OK. JetBrains Rider will reformat code in the selected scope according to your formatting preferences.

Using code inspection to maintain formatting rules in C# and C++

In C# and C++, code formatting style can be also maintained using the code inspection features. JetBrains Rider provides several dozens of formatting inspections, which are all disabled by default.

Depending on the solution, your codebase may have hundreds of minor formatting violations — like different indent sizes across methods, different case-label indents in switch-statements, missing line breaks, etc — but enabling code inspections for all those violations could be too noisy.

On the other hand, there are formatting problems that decrease code readability or may influence your understanding of the code. For example:

  • multiple type members on one same line,

  • multiple statements on one line,

  • incorrect indent around child statement,

  • incorrect indent around declaration braces,

  • incorrect indent around declaration braces.

For such formatting problems, we recommend enabling code inspections.

Keeping existing formatting

You can apply some formatting rules 'softly', meaning that such rules will be applied when JetBrains Rider produces new code with code completion and code generation features, applies code templates and performs refactorings, but these rules will be ignored when you reformat existing code (for example, with Ctrl+Alt+Enter).

To keep formatting rules less strict, use the Keep existing..., Keep max blank lines, and Simple wrap preferences for specific contexts. You can check or change the configuration of those preferences in JetBrains Rider settings (Ctrl+Alt+S):

JetBrains Rider: keep existing formatting for selected rules

Reformatting code with different line-break styles

JetBrains Rider also allows you to use explicit actions rather than formatting rules to reformat similar code in different ways. These actions are most helpful when you opt to keep existing formatting for the related rules. However if you have stricter settings, then the corresponding explicit formatting actions will not work because such configurations mean that formatting rules should be always applied in the affected contexts. For example, if Keep existing... preferences are disabled, then the wrap/chop/spacious/compact commands described below will render the same result. If some wrapping rules are set to Chop..., code in the corresponding contexts will be always chopped even if you invoke wrap/compact commands.

Wrapping and chopping long lines

The Wrap long line and Chop long line actions become available when your caret is on a line, which is longer than the allowed maximum line length — you can configure it with the Right margin (columns) preference on the Editor | Code Style | C# | Line Breaks and Wrapping page of JetBrains Rider settings (Ctrl+Alt+S).

You can press Alt+Enter and choose one of the actions to add the necessary line breaks.

The Wrap long line will add just enough line breaks to make sure that the configured line length is not exceeded:

Before reformatting


After reformatting

var·reportHtml·=·CreateReport("359CD313-7C7E-49B2-A2AB-E12FDFD1319D",·DateTimeOffset.UtcNow.AddMonths(-1), ····DateTimeOffset.UtcNow,·useRichText:·true);

The Chop long line will add line breaks for each entity on the line:

Before reformatting


After reformatting

var·reportHtml·=·CreateReport("359CD313-7C7E-49B2-A2AB-E12FDFD1319D", ····DateTimeOffset.UtcNow.AddMonths(-1), ····DateTimeOffset.UtcNow, ····useRichText:·true);

Compact, spacious, and strict format for code blocks

Another set of actions for explicitly reformatting your code helps you enforce more compact (fewer line breaks) or more spacious (more line breaks) format in the selection.

To invoke these actions, select a block of code (you can use Ctrl+Alt+Right to select a logical block), press Alt+Enter and then choose one of the actions under Format selection.

If you have too many line breaks, which do not help reading the code, it may be a good idea to remove them. In the example below, the empty getters and setters do not bring any useful information and can be safely placed on single lines. You can do this with the Compact format (fewer line breaks) action:

Before reformatting

After reformatting

public·string·Name { ····get; ····set; } public·int·Age { ····get; ····set; }

public·string·Name·{·get;·set;·} public·int·Age·{·get;·set;·}

You may want to use Spacious format (chop) to make a multi-line code block even easier to read. For example, you may want to add more line breaks in a complicated if statement or a heavy XElement constructor call:

Before reformatting

summaryTable.Add(new·XElement("tr", ····new·XElement("td",·XmlHelpers.CreateHyperlink(inspection.Text, ············CodeInspectionHelpers.TryGetStaticHref(inspection.Id),·null,·true), ········new·XComment(compoundName)),·new·XElement("td",·GetSeverityLink(inspection.Severity))));

After reformatting

summaryTable.Add(new·XElement("tr", ····new·XElement("td", ········XmlHelpers.CreateHyperlink(inspection.Text, ············CodeInspectionHelpers.TryGetStaticHref(inspection.Id), ············null, ············true), ········new·XComment(compoundName)), ····new·XElement("td", ········GetSeverityLink(inspection.Severity))));

The Strict format action will reformat the selection ignoring any existing line breaks independently of how the Keep existing... preferences are configured.

Configuring code-formatting rules

Formatting rules can be configured to a very high level of detail. For example, you can define whether whitespaces should be placed around a specific operator or whether to indent nested using statements.

To configure code-formatting rules

  1. Press Ctrl+Alt+S, or alternatively choose File | Settings on Windows and Linux or JetBrains Rider | Preferences on macOS.

  2. Use the Editor | Code Style | [Language] pages to configure language-specific formatting preferences. On these pages, you can use the preview area at the bottom to view just how JetBrains Rider applies the specific preference to the code.

  3. Click Save 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 drop-down list. For more information, see layer-based settings. Click Save.

Using comments to configure formatter

JetBrains Rider allows you to deviate from the configured formatting rules without actually changing the rules. You can even disable formatter altogether in certain parts of your code.

To disable formatter, use the following comments:

  • // @formatter:off — disable formatter after this line

  • // @formatter:on — enable formatter after this line

If disabling formatter is too much, you can change any individual formatting rule with a comment.

To change an individual formatting rule with a comment

  1. Find the name of formatting rule that you want to tweak. You can look it up in JetBrains Rider settings ( Editor | Code Style | [Language]).

  2. When you know the name of the rule, you can look up its ID in the Index of EditorConfig properties — use search in your browser. For example, if you want to find the rule that triggers the space before the semicolon, search for before semicolon and you will find the ID: space_before_semicolon.

  3. When you found the ID of the rule on the index web page, click the description link to learn which values are allowed for this rule. Following the example with space_before_semicolon, it can accept true or false.

  4. Add the following comment before the code where you want to change the rule:
    // @formatter:<rule_ID> <value>, for example, to enable spaces before the semicolon, add
    // @formatter:space_before_semicolon true.

  5. The new value for the rule will apply until the end of the file. If you want to go back to the value configured in the settings, add the following comment:
    // @formatter:<rule_ID> restore, for example,
    // @formatter:space_before_semicolon restore.

Storing and sharing formatting rules

Rider stores its code formatting preferences using both directory-based settings (for web languages) and layer-based settings (for .NET languages). Both setting-management mechanisms support sharing of settings. Layer-based settings are also compatible with ReSharper.
In the Rider settings dialog, you can look at the icons to see which setting-management mechanism is used for specific language:

Rider: Code formatting settings

JetBrains Rider also supports formatting settings defined in EditorConfig. These settings can be stored in .editorconfig files on different levels of your solution hierarchy. The files are normally put under VCS so that settings defined there are shared among the project team.
JetBrains Rider lets you use EditorConfig to define any of its formatting preferences that are available in JetBrains Rider settings (in the Settings dialog). You can find names and descriptions of supported EditorConfig properties in the EditorConfig reference.

It is important to note that any formatting property defined in an .editorconfig file will override the same property defined in JetBrains Rider settings in the scope where this .editorconfig file applies.

Last modified: 21 December 2018