JetBrains Rider 2018.2 Help

C# - Line Breaks

General

Keep existing line breaks

Property names:

[resharper_]csharp_keep_user_linebreaks, [resharper_]csharp_keep_existing_arrangement, [resharper_]csharp_keep_existing_linebreaks, [resharper_]keep_user_linebreaks, [resharper_]keep_existing_arrangement, [resharper_]keep_existing_linebreaks

Possible values:

true | false

Examples:

Before formatting

After formatting, true

int·var·=·condition ··?·SomeFunc1() ··:·SomeFunc2();

int·var·=·condition ····?·SomeFunc1() ····:·SomeFunc2();

Before formatting

After formatting, false

int·var·=·condition ··?·SomeFunc1() ··:·SomeFunc2();

int·var·=·condition·?·SomeFunc1()·:·SomeFunc2();

Hard wrap at

Property names:

csharp_max_line_length, max_line_length

This·option·(similarly·to·the·Editorconfig's·'max_line_length')·defines·the·desired·maximum·number·of·characters·in·each·line.·It·is·applied·during·code·reformatting·if·'Wrap·long·lines'·is·enabled.·Line·breaks·are·added,·if·possible,·at·the·positions·not·exceeding·the·specified·value,·according·to·the·language·syntax·and·other·line·wrapping·settings.

Possible values:

an integer

Prefer wrap before ","

Property names:

[resharper_]csharp_wrap_before_comma, [resharper_]wrap_before_comma

Possible values:

true | false

Examples:

true

CallMethod(arg1 ····,·arg2 ····,·arg3 ····,·arg4 ····,·arg5 ····,·arg6 ····,·arg7);

false

CallMethod(arg1, ····arg2, ····arg3, ····arg4, ····arg5, ····arg6, ····arg7);

Special "else if" treatment

Property names:

[resharper_]csharp_special_else_if_treatment, [resharper_]special_else_if_treatment

Possible values:

true | false

Examples:

true

if·(condition) { ····foo(); } else·if·(condition) { }

false

if·(condition) { ····foo(); } else ····if·(condition) ····{ ····}

Line feed at end of file

Property names:

csharp_insert_final_newline, insert_final_newline

Possible values:

true | false

Examples:

true

class·A { }

false

class·A { }

Arrangement of Attributes

Place attribute section list on separate line if it is longer than

Property names:

[resharper_]csharp_max_attribute_length_for_same_line, [resharper_]max_attribute_length_for_same_line

Attribute·sections·longer·than·specified·values·would·be·placed·on·separate·line

Possible values:

an integer

Keep existing arrangement of attributes

Property names:

[resharper_]csharp_keep_existing_attribute_arrangement, [resharper_]csharp_keep_existing_arrangement, [resharper_]keep_existing_attribute_arrangement, [resharper_]keep_existing_arrangement

Possible values:

true | false

Examples:

Before formatting

After formatting, true

[Attribute] class·C·{} [Attribute]·class·C1·{}

[Attribute] class·C·{·} [Attribute]·class·C1·{·}

Before formatting

After formatting, false

[Attribute] class·C·{} [Attribute]·class·C1·{}

[Attribute] class·C·{·} [Attribute] class·C1·{·}

Place type attribute on same line

Property names:

[resharper_]csharp_place_type_attribute_on_same_line, [resharper_]csharp_place_attribute_on_same_line, [resharper_]place_type_attribute_on_same_line, [resharper_]place_attribute_on_same_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

[Attribute] class·C·{·} [Attribute] class·C1 { ····//·comment· }

never

[Attribute] class·C·{·} [Attribute] class·C1 { ····//·comment· }

if_owner_is_single_line

[Attribute]·class·C·{·} [Attribute] class·C1 { ····//·comment· }

True

[Attribute]·class·C·{·} [Attribute]·class·C1 { ····//·comment· }

always

[Attribute]·class·C·{·} [Attribute]·class·C1 { ····//·comment· }

Place method attribute on same line

Property names:

[resharper_]csharp_place_method_attribute_on_same_line, [resharper_]csharp_place_attribute_on_same_line, [resharper_]place_method_attribute_on_same_line, [resharper_]place_attribute_on_same_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

interface·I { ····[Attribute] ····void·foo(); } class·C { ····[Attribute] ····void·foo() ····{ ········//·comment ····} }

never

interface·I { ····[Attribute] ····void·foo(); } class·C { ····[Attribute] ····void·foo() ····{ ········//·comment ····} }

if_owner_is_single_line

interface·I { ····[Attribute]·void·foo(); } class·C { ····[Attribute] ····void·foo() ····{ ········//·comment ····} }

True

interface·I { ····[Attribute]·void·foo(); } class·C { ····[Attribute]·void·foo() ····{ ········//·comment ····} }

always

interface·I { ····[Attribute]·void·foo(); } class·C { ····[Attribute]·void·foo() ····{ ········//·comment ····} }

Place property/indexer/event attribute on same line

Property names:

[resharper_]csharp_place_accessorholder_attribute_on_same_line, [resharper_]csharp_place_attribute_on_same_line, [resharper_]place_accessorholder_attribute_on_same_line, [resharper_]place_attribute_on_same_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

interface·I { ····[Attribute] ····int·Property·{·get;·} } class·C { ····[Attribute] ····int·Property ····{ ········get ········{ ············//·comment ············return·x; ········} ····} }

never

interface·I { ····[Attribute] ····int·Property·{·get;·} } class·C { ····[Attribute] ····int·Property ····{ ········get ········{ ············//·comment ············return·x; ········} ····} }

if_owner_is_single_line

interface·I { ····[Attribute]·int·Property·{·get;·} } class·C { ····[Attribute] ····int·Property ····{ ········get ········{ ············//·comment ············return·x; ········} ····} }

True

interface·I { ····[Attribute]·int·Property·{·get;·} } class·C { ····[Attribute]·int·Property ····{ ········get ········{ ············//·comment ············return·x; ········} ····} }

always

interface·I { ····[Attribute]·int·Property·{·get;·} } class·C { ····[Attribute]·int·Property ····{ ········get ········{ ············//·comment ············return·x; ········} ····} }

Place accessor attribute on same line

Property names:

[resharper_]csharp_place_accessor_attribute_on_same_line, [resharper_]csharp_place_attribute_on_same_line, [resharper_]place_accessor_attribute_on_same_line, [resharper_]place_attribute_on_same_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

interface·I { ····int·Property ····{ ········[Attribute] ········get; ····} } class·C { ····int·Property ····{ ········[Attribute] ········get·{·return·x;·} ········[Attribute] ········set ········{ ············x·=·value; ············NotifySomething(); ········} ····} }

never

interface·I { ····int·Property ····{ ········[Attribute] ········get; ····} } class·C { ····int·Property ····{ ········[Attribute] ········get·{·return·x;·} ········[Attribute] ········set ········{ ············x·=·value; ············NotifySomething(); ········} ····} }

if_owner_is_single_line

interface·I { ····int·Property·{·[Attribute]·get;·} } class·C { ····int·Property ····{ ········[Attribute]·get·{·return·x;·} ········[Attribute] ········set ········{ ············x·=·value; ············NotifySomething(); ········} ····} }

True

interface·I { ····int·Property·{·[Attribute]·get;·} } class·C { ····int·Property ····{ ········[Attribute]·get·{·return·x;·} ········[Attribute]·set ········{ ············x·=·value; ············NotifySomething(); ········} ····} }

always

interface·I { ····int·Property·{·[Attribute]·get;·} } class·C { ····int·Property ····{ ········[Attribute]·get·{·return·x;·} ········[Attribute]·set ········{ ············x·=·value; ············NotifySomething(); ········} ····} }

Place field attribute on same line

Property names:

[resharper_]csharp_place_field_attribute_on_same_line, [resharper_]csharp_place_attribute_on_same_line, [resharper_]place_field_attribute_on_same_line, [resharper_]place_attribute_on_same_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

class·C { ····[Attribute] ····int·x; ····[Attribute] ····MyObj·y·=·//·comment· ········new·MyObj(); }

never

class·C { ····[Attribute] ····int·x; ····[Attribute] ····MyObj·y·=·//·comment· ········new·MyObj(); }

if_owner_is_single_line

class·C { ····[Attribute]·int·x; ····[Attribute] ····MyObj·y·=·//·comment· ········new·MyObj(); }

True

class·C { ····[Attribute]·int·x; ····[Attribute]·MyObj·y·=·//·comment· ········new·MyObj(); }

always

class·C { ····[Attribute]·int·x; ····[Attribute]·MyObj·y·=·//·comment· ········new·MyObj(); }

Arrangement of Method Signatures

Wrap formal parameters

Property names:

[resharper_]csharp_wrap_parameters_style, [resharper_]wrap_parameters_style

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

interface·IA { ····void·M(int·p1,·int·p2); ····void·SomeMethod(int·p1, ········int·p2,·int·p3, ········int·p4); }

chop_if_long

interface·IA { ····void·M(int·p1,·int·p2); ····void·SomeMethod(int·p1, ········int·p2, ········int·p3, ········int·p4); }

chop_always

interface·IA { ····void·M(int·p1, ········int·p2); ····void·SomeMethod(int·p1, ········int·p2, ········int·p3, ········int·p4); }

Max formal parameters on a single line

Property names:

[resharper_]csharp_max_formal_parameters_on_line, [resharper_]max_formal_parameters_on_line

Possible values:

an integer

Examples:

value: 0

interface·IA { ····void·M(int·arg1); ····void·M(int·arg1, ········int·arg2); ····void·M(int·arg1, ········int·arg2, ········int·arg3); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5, ········int·arg6); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5, ········int·arg6, ········int·arg7); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5, ········int·arg6, ········int·arg7, ········int·arg8); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5, ········int·arg6, ········int·arg7, ········int·arg8, ········int·arg9); }

value: 1

interface·IA { ····void·M(int·arg1); ····void·M(int·arg1, ········int·arg2); ····void·M(int·arg1, ········int·arg2, ········int·arg3); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5, ········int·arg6); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5, ········int·arg6, ········int·arg7); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5, ········int·arg6, ········int·arg7, ········int·arg8); ····void·M(int·arg1, ········int·arg2, ········int·arg3, ········int·arg4, ········int·arg5, ········int·arg6, ········int·arg7, ········int·arg8, ········int·arg9); }

value: 2

interface·IA { ····void·M(int·arg1); ····void·M(int·arg1,·int·arg2); ····void·M(int·arg1,·int·arg2, ········int·arg3); ····void·M(int·arg1,·int·arg2, ········int·arg3,·int·arg4); ····void·M(int·arg1,·int·arg2, ········int·arg3,·int·arg4, ········int·arg5); ····void·M(int·arg1,·int·arg2, ········int·arg3,·int·arg4, ········int·arg5,·int·arg6); ····void·M(int·arg1,·int·arg2, ········int·arg3,·int·arg4, ········int·arg5,·int·arg6, ········int·arg7); ····void·M(int·arg1,·int·arg2, ········int·arg3,·int·arg4, ········int·arg5,·int·arg6, ········int·arg7,·int·arg8); ····void·M(int·arg1,·int·arg2, ········int·arg3,·int·arg4, ········int·arg5,·int·arg6, ········int·arg7,·int·arg8, ········int·arg9); }

Keep existing arrangement of parenthesis in declaration

Property names:

[resharper_]csharp_keep_existing_declaration_parens_arrangement, [resharper_]csharp_keep_existing_arrangement, [resharper_]keep_existing_declaration_parens_arrangement, [resharper_]keep_existing_arrangement

Possible values:

true | false

Examples:

Before formatting

After formatting, true

void·SomeMethod ( int·p1,·int·p2, int·p3,·int·p4 )·{}

void·SomeMethod ( ····int·p1,·int·p2, ····int·p3,·int·p4 ) { }

Before formatting

After formatting, false

void·SomeMethod ( int·p1,·int·p2, int·p3,·int·p4 )·{}

void·SomeMethod(int·p1,·int·p2, ····int·p3,·int·p4) { }

Prefer wrap before "(" in declaration

Property names:

[resharper_]csharp_wrap_before_declaration_lpar, [resharper_]wrap_before_declaration_lpar

Possible values:

true | false

Examples:

true

void·SomeMethod (int·p1,·int·p2, ····int·p3,·int·p4) { }

false

void·SomeMethod(int·p1,·int·p2, ····int·p3,·int·p4) { }

Prefer wrap after "(" in declaration

Property names:

[resharper_]csharp_wrap_after_declaration_lpar, [resharper_]wrap_after_declaration_lpar

Possible values:

true | false

Examples:

true

void·SomeMethod( ····int·p1,·int·p2, ····int·p3,·int·p4) { }

false

void·SomeMethod(int·p1,·int·p2, ····int·p3,·int·p4) { }

Prefer wrap before ")" in declaration

Property names:

[resharper_]csharp_wrap_before_declaration_rpar, [resharper_]wrap_before_declaration_rpar

Possible values:

true | false

Examples:

true

void·SomeMethod(int·p1,·int·p2, ····int·p3,·int·p4 ) { }

false

void·SomeMethod(int·p1,·int·p2, ····int·p3,·int·p4) { }

Allow constructor initializer on same line

Property names:

[resharper_]csharp_place_constructor_initializer_on_same_line, [resharper_]place_constructor_initializer_on_same_line

Possible values:

true | false

Examples:

true

class·C { ····public·C()·:·base() ····{ ····} }

false

class·C { ····public·C() ········:·base() ····{ ····} }

Arrangement of Expression Bodied Members

Keep existing arrangement of expression bodied members

Property names:

[resharper_]csharp_keep_existing_expr_member_arrangement, [resharper_]csharp_keep_existing_arrangement, [resharper_]keep_existing_expr_member_arrangement, [resharper_]keep_existing_arrangement

Possible values:

true | false

Examples:

Before formatting

After formatting, true

class·A { ··public·int·Foo()·=>·0; ··public·int·Foo1() ····=>·1; ··public·int·Foo2()·=> ····2; }

class·A { ····public·int·Foo()·=>·0; ····public·int·Foo1() ········=>·1; ····public·int·Foo2()·=> ········2; }

Before formatting

After formatting, false

class·A { ··public·int·Foo()·=>·0; ··public·int·Foo1() ····=>·1; ··public·int·Foo2()·=> ····2; }

class·A { ····public·int·Foo()·=>·0; ····public·int·Foo1()·=>·1; ····public·int·Foo2()·=>·2; }

Place method expression body on same line

Property names:

[resharper_]csharp_place_expr_method_on_single_line, [resharper_]place_expr_method_on_single_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

class·A { ····public·int·Foo()·=> ········0; ····public·int·//·comment ········Foo1()·=> ········1; ····public·int·Foo2()·=> ········1·+·//·comment ········2; }

never

class·A { ····public·int·Foo()·=> ········0; ····public·int·//·comment ········Foo1()·=> ········1; ····public·int·Foo2()·=> ········1·+·//·comment ········2; }

if_owner_is_single_line

class·A { ····public·int·Foo()·=>·0; ····public·int·//·comment ········Foo1()·=> ········1; ····public·int·Foo2()·=> ········1·+·//·comment ········2; }

True

class·A { ····public·int·Foo()·=>·0; ····public·int·//·comment ········Foo1()·=>·1; ····public·int·Foo2()·=>·1·+·//·comment ·························2; }

always

class·A { ····public·int·Foo()·=>·0; ····public·int·//·comment ········Foo1()·=>·1; ····public·int·Foo2()·=>·1·+·//·comment ·························2; }

Place property expression body on same line

Property names:

[resharper_]csharp_place_expr_property_on_single_line, [resharper_]place_expr_property_on_single_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

class·A { ····public·int·Foo·=> ········0; ····public·int·//·comment ········Foo1·=> ········1; ····public·int·Foo2·=> ········1·+·//·comment ········2; }

never

class·A { ····public·int·Foo·=> ········0; ····public·int·//·comment ········Foo1·=> ········1; ····public·int·Foo2·=> ········1·+·//·comment ········2; }

if_owner_is_single_line

class·A { ····public·int·Foo·=>·0; ····public·int·//·comment ········Foo1·=> ········1; ····public·int·Foo2·=> ········1·+·//·comment ········2; }

True

class·A { ····public·int·Foo·=>·0; ····public·int·//·comment ········Foo1·=>·1; ····public·int·Foo2·=>·1·+·//·comment ·······················2; }

always

class·A { ····public·int·Foo·=>·0; ····public·int·//·comment ········Foo1·=>·1; ····public·int·Foo2·=>·1·+·//·comment ·······················2; }

Place property accessor expression body on same line

Property names:

[resharper_]csharp_place_expr_accessor_on_single_line, [resharper_]place_expr_accessor_on_single_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

class·A { ····public·int·Foo ····{ ········get·=> ············0; ····} ····public·int·Foo1 ····{ ········get·=> ············1·+·//·comment ············2; ····} }

never

class·A { ····public·int·Foo ····{ ········get·=> ············0; ····} ····public·int·Foo1 ····{ ········get·=> ············1·+·//·comment ············2; ····} }

if_owner_is_single_line

class·A { ····public·int·Foo ····{ ········get·=>·0; ····} ····public·int·Foo1 ····{ ········get·=> ············1·+·//·comment ············2; ····} }

True

class·A { ····public·int·Foo ····{ ········get·=>·0; ····} ····public·int·Foo1 ····{ ········get·=>·1·+·//·comment ···············2; ····} }

always

class·A { ····public·int·Foo ····{ ········get·=>·0; ····} ····public·int·Foo1 ····{ ········get·=>·1·+·//·comment ···············2; ····} }

Prefer wrap before "=>" followed by expressions

Property names:

[resharper_]csharp_wrap_before_arrow_with_expressions, [resharper_]wrap_before_arrow_with_expressions

Possible values:

true | false

Examples:

true

class·A { ····public·int·Foo(int·y) ········=>·Br( ············y·*·y·+·y·<< ············y·+·y); ····Func<int,·int,·int> ········Method2() ····{ ········return·(xxx,·yyy) ············=>·Br(xxx·*·yyy); ····} }

false

class·A { ····public·int·Foo(int·y)·=> ········Br(y·*·y·+·y·<<·y·+·y); ····Func<int,·int,·int> ········Method2() ····{ ········return·(xxx,·yyy)·=> ············Br(xxx·*·yyy); ····} }

Arrangement of Type Parameters, Constraints and Base Types

Allow type constraints on same line

Property names:

[resharper_]csharp_place_type_constraints_on_same_line, [resharper_]place_type_constraints_on_same_line

Possible values:

true | false

Examples:

true

class·C<T>·where·T·:·IEnumerable { }

false

class·C<T> ····where·T·:·IEnumerable { }

Prefer wrap before first constraint

Property names:

[resharper_]csharp_wrap_before_first_type_parameter_constraint, [resharper_]wrap_before_first_type_parameter_constraint

Possible values:

true | false

Examples:

true

class·C<T1,·T2,·T3> ····where·T1·:·I1 ····where·T2·:·new() ····where·T3·:·class

false

class·C<T1,·T2,·T3>·where·T1·:·I1 ····where·T2·:·new() ····where·T3·:·class

Wrap multiple type parameter constraints

Property names:

[resharper_]csharp_wrap_multiple_type_parameter_constraints_style, [resharper_]wrap_multiple_type_parameter_constraints_style

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

class·C<T1,·T2,·T3>·where·T1·:·I1·where·T2·:·new() ····where·T3·:·class

chop_if_long

class·C<T1,·T2,·T3>·where·T1·:·I1 ····where·T2·:·new() ····where·T3·:·class

chop_always

class·C<T1,·T2,·T3>·where·T1·:·I1 ····where·T2·:·new() ····where·T3·:·class

Prefer wrap before type parameters opening angle

Property names:

[resharper_]csharp_wrap_before_type_parameter_langle, [resharper_]wrap_before_type_parameter_langle

Possible values:

true | false

Examples:

true

class·C <Type1,·Type2, ····Type3,·Type4> { }

false

class·C<Type1,·Type2, ····Type3,·Type4> { }

Prefer wrap before ":"

Property names:

[resharper_]csharp_wrap_before_extends_colon, [resharper_]wrap_before_extends_colon

Possible values:

true | false

Examples:

true

class·Derived ····:·BaseClass,·I1,·I2, ········I3,·I4 { }

false

class·Derived·:·BaseClass,·I1, ····I2, ····I3,·I4 { }

Wrap extends/implements list

Property names:

[resharper_]csharp_wrap_extends_list_style, [resharper_]wrap_extends_list_style

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

class·Derived·:·BaseClass,·I1, ····I2,·I3,·I4 { }

chop_if_long

class·Derived·:·BaseClass, ····I1, ····I2, ····I3, ····I4 { }

chop_always

class·Derived·:·BaseClass, ····I1, ····I2, ····I3, ····I4 { }

Arrangement of Declaration Blocks

Keep existing arrangement of declaration blocks

Property names:

[resharper_]csharp_keep_existing_declaration_block_arrangement, [resharper_]csharp_keep_existing_arrangement, [resharper_]keep_existing_declaration_block_arrangement, [resharper_]keep_existing_arrangement

Possible values:

true | false

Examples:

Before formatting

After formatting, true

interface·I{ ··int·Property·{ get;·set; } } interface·I{int·Property{get;set;}}

interface·I { ····int·Property ····{ ········get; ········set; ····} } interface·I { ····int·Property·{·get;·set;·} }

Before formatting

After formatting, false

interface·I{ ··int·Property·{ get;·set; } } interface·I{int·Property{get;set;}}

interface·I { ····int·Property·{·get;·set;·} } interface·I { ····int·Property·{·get;·set;·} }

Place abstract/auto property/indexer/event declaration on single line

Property names:

[resharper_]csharp_place_abstract_accessorholder_on_single_line, [resharper_]csharp_place_simple_blocks_on_single_line, [resharper_]csharp_place_simple_declaration_blocks_on_single_line, [resharper_]place_abstract_accessorholder_on_single_line, [resharper_]place_simple_blocks_on_single_line, [resharper_]place_simple_declaration_blocks_on_single_line

Possible values:

true | false

Examples:

true

interface·I { ····int·Property·{·get;·set;·} }

false

interface·I { ····int·Property ····{ ········get; ········set; ····} }

Place simple property/indexer/event declaration on single line

Property names:

[resharper_]csharp_place_simple_accessorholder_on_single_line, [resharper_]csharp_place_simple_blocks_on_single_line, [resharper_]csharp_place_simple_declaration_blocks_on_single_line, [resharper_]place_simple_accessorholder_on_single_line, [resharper_]place_simple_blocks_on_single_line, [resharper_]place_simple_declaration_blocks_on_single_line

Possible values:

true | false

Examples:

true

class·C { ····int·Property·{·get·{·return·x;·}·set·{·x·=·value;·}·} }

false

class·C { ····int·Property ····{ ········get·{·return·x;·} ········set·{·x·=·value;·} ····} }

Place it on single line even when it has attributes on accessors

Property names:

[resharper_]csharp_place_accessor_with_attrs_holder_on_single_line, [resharper_]csharp_place_simple_blocks_on_single_line, [resharper_]csharp_place_simple_declaration_blocks_on_single_line, [resharper_]place_accessor_with_attrs_holder_on_single_line, [resharper_]place_simple_blocks_on_single_line, [resharper_]place_simple_declaration_blocks_on_single_line

Possible values:

true | false

Examples:

true

class·C { ····int·Property ····{ ········[Attr]·get·{·return·x;·} ········[Attr]·set·{·x·=·value;·} ····} }

false

class·C { ····int·Property ····{ ········[Attr]·get·{·return·x;·} ········[Attr]·set·{·x·=·value;·} ····} }

Place simple accessor on single line

Property names:

[resharper_]csharp_place_simple_accessor_on_single_line, [resharper_]csharp_place_simple_blocks_on_single_line, [resharper_]csharp_place_simple_declaration_blocks_on_single_line, [resharper_]place_simple_accessor_on_single_line, [resharper_]place_simple_blocks_on_single_line, [resharper_]place_simple_declaration_blocks_on_single_line

Possible values:

true | false

Examples:

true

class·C { ····int·Property ····{ ········get·{·return·x;·} ········set ········{ ············if·(value·==·null)·throw·new·Exception(); ········} ····} }

false

class·C { ····int·Property ····{ ········get ········{ ············return·x; ········} ········set ········{ ············if·(value·==·null)·throw·new·Exception(); ········} ····} }

Place simple method on single line

Property names:

[resharper_]csharp_place_simple_method_on_single_line, [resharper_]csharp_place_simple_blocks_on_single_line, [resharper_]csharp_place_simple_declaration_blocks_on_single_line, [resharper_]place_simple_method_on_single_line, [resharper_]place_simple_blocks_on_single_line, [resharper_]place_simple_declaration_blocks_on_single_line

Possible values:

true | false

Examples:

true

class·C { ····void·Foo()·{·DoSomethingSimple();·} }

false

class·C { ····void·Foo() ····{ ········DoSomethingSimple(); ····} }

Arrangement of Enumerations

Keep existing arrangement of enumeration

Property names:

[resharper_]csharp_keep_existing_enum_arrangement, [resharper_]csharp_keep_existing_arrangement, [resharper_]keep_existing_enum_arrangement, [resharper_]keep_existing_arrangement

Possible values:

true | false

Examples:

Before formatting

After formatting, true

public·enum·Enum1·{·a,·b,·c·} public·enum·Enum2·{ a, b, c } public·enum·Enum3·{ a,·b, c,·d }

public·enum·Enum1·{·a,·b,·c·} public·enum·Enum2 { ····a, ····b, ····c } public·enum·Enum3 { ····a,·b, ····c,·d }

Before formatting

After formatting, false

public·enum·Enum1·{·a,·b,·c·} public·enum·Enum2·{ a, b, c } public·enum·Enum3·{ a,·b, c,·d }

public·enum·Enum1 { ····a, ····b, ····c } public·enum·Enum2 { ····a, ····b, ····c } public·enum·Enum3 { ····a, ····b, ····c, ····d }

Max enumeration members on a single line

Property names:

[resharper_]csharp_max_enum_members_on_line, [resharper_]max_enum_members_on_line

Possible values:

an integer

Examples:

value: 0

public·enum·Enum1 { ····val1 } public·enum·Enum2 { ····val1, ····val2 } public·enum·Enum3 { ····val1, ····val2, ····val3 } public·enum·Enum4 { ····val1, ····val2, ····val3, ····val4 } public·enum·Enum5 { ····val1, ····val2, ····val3, ····val4, ····val5 } public·enum·Enum6 { ····val1, ····val2, ····val3, ····val4, ····val5, ····val6 } public·enum·Enum7 { ····val1, ····val2, ····val3, ····val4, ····val5, ····val6, ····val7 } public·enum·Enum8 { ····val1, ····val2, ····val3, ····val4, ····val5, ····val6, ····val7, ····val8 } public·enum·Enum9 { ····val1, ····val2, ····val3, ····val4, ····val5, ····val6, ····val7, ····val8, ····val9 }

value: 1

public·enum·Enum1 { ····val1 } public·enum·Enum2 { ····val1, ····val2 } public·enum·Enum3 { ····val1, ····val2, ····val3 } public·enum·Enum4 { ····val1, ····val2, ····val3, ····val4 } public·enum·Enum5 { ····val1, ····val2, ····val3, ····val4, ····val5 } public·enum·Enum6 { ····val1, ····val2, ····val3, ····val4, ····val5, ····val6 } public·enum·Enum7 { ····val1, ····val2, ····val3, ····val4, ····val5, ····val6, ····val7 } public·enum·Enum8 { ····val1, ····val2, ····val3, ····val4, ····val5, ····val6, ····val7, ····val8 } public·enum·Enum9 { ····val1, ····val2, ····val3, ····val4, ····val5, ····val6, ····val7, ····val8, ····val9 }

value: 2

public·enum·Enum1 { ····val1 } public·enum·Enum2 { ····val1,·val2 } public·enum·Enum3 { ····val1,·val2, ····val3 } public·enum·Enum4 { ····val1,·val2, ····val3,·val4 } public·enum·Enum5 { ····val1,·val2, ····val3,·val4, ····val5 } public·enum·Enum6 { ····val1,·val2, ····val3,·val4, ····val5,·val6 } public·enum·Enum7 { ····val1,·val2, ····val3,·val4, ····val5,·val6, ····val7 } public·enum·Enum8 { ····val1,·val2, ····val3,·val4, ····val5,·val6, ····val7,·val8 } public·enum·Enum9 { ····val1,·val2, ····val3,·val4, ····val5,·val6, ····val7,·val8, ····val9 }

Place simple enumeration on single line

Property names:

[resharper_]csharp_place_simple_enum_on_single_line, [resharper_]csharp_place_simple_blocks_on_single_line, [resharper_]csharp_place_simple_declaration_blocks_on_single_line, [resharper_]place_simple_enum_on_single_line, [resharper_]place_simple_blocks_on_single_line, [resharper_]place_simple_declaration_blocks_on_single_line

Possible values:

true | false

Examples:

true

public·enum·Enum1·{·a,·b,·c·}

false

public·enum·Enum1 { ····a,·b,·c }

Wrap enumeration declaration

Property names:

[resharper_]csharp_wrap_enum_declaration, [resharper_]wrap_enum_declaration

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

public·enum·Enum1 { ····a,·b,·c } public·enum·Enum2 { ····aaaaa,·bbbbb,·ccccc, ····ddddd,·eeeee,·fffff }

chop_if_long

public·enum·Enum1 { ····a,·b,·c } public·enum·Enum2 { ····aaaaa, ····bbbbb, ····ccccc, ····ddddd, ····eeeee, ····fffff }

chop_always

public·enum·Enum1 { ····a, ····b, ····c } public·enum·Enum2 { ····aaaaa, ····bbbbb, ····ccccc, ····ddddd, ····eeeee, ····fffff }

Arrangement of Statements

Place "else" on new line

Property names:

csharp_new_line_before_else, new_line_before_else

Possible values:

true | false

Examples:

true

if·(condition) { ····foo(); } else { ····foo(); }

false

if·(condition) { ····foo(); }·else { ····foo(); }

Place "while" on new line

Property names:

[resharper_]csharp_new_line_before_while, [resharper_]new_line_before_while

Possible values:

true | false

Examples:

true

do { ····foo(); } while·(condition);

false

do { ····foo(); }·while·(condition);

Place "catch" on new line

Property names:

csharp_new_line_before_catch, new_line_before_catch

Possible values:

true | false

Examples:

true

try { ····foo(); } catch·(Exception·e) { ····foo(); } finally { ····foo(); }

false

try { ····foo(); }·catch·(Exception·e) { ····foo(); } finally { ····foo(); }

Place "finally" on new line

Property names:

csharp_new_line_before_finally, new_line_before_finally

Possible values:

true | false

Examples:

true

try { ····foo(); } catch·(Exception·e) { ····foo(); } finally { ····foo(); }

false

try { ····foo(); } catch·(Exception·e) { ····foo(); }·finally { ····foo(); }

Wrap "for" statement header

Property names:

[resharper_]csharp_wrap_for_stmt_header_style, [resharper_]wrap_for_stmt_header_style

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

for·(int·i·=·initial; ····i·<·loopLimit;·i++) { }

chop_if_long

for·(int·i·=·initial; ····i·<·loopLimit; ····i++) { }

chop_always

for·(int·i·=·initial; ····i·<·loopLimit; ····i++) { }

Wrap multiple declaration

Property names:

[resharper_]csharp_wrap_multiple_declaration_style, [resharper_]wrap_multiple_declaration_style

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

class·C { ····public·int·i·=·0,·j·=·0, ········k·=·2,·l·=·3,·m·=·4, ········n·=·5; }

chop_if_long

class·C { ····public·int·i·=·0, ········j·=·0, ········k·=·2, ········l·=·3, ········m·=·4, ········n·=·5; }

chop_always

class·C { ····public·int·i·=·0, ········j·=·0, ········k·=·2, ········l·=·3, ········m·=·4, ········n·=·5; }

Arrangement of Embedded Statements

Keep existing arrangement of embedded statements

Property names:

[resharper_]csharp_keep_existing_embedded_arrangement, [resharper_]csharp_keep_existing_arrangement, [resharper_]keep_existing_embedded_arrangement, [resharper_]keep_existing_arrangement

Possible values:

true | false

Examples:

Before formatting

After formatting, true

{ ··if·(condition)·DoSomething(); ··if·(condition1) ····DoSomething1(); }

{ ····if·(condition)·DoSomething(); ····if·(condition1) ········DoSomething1(); }

Before formatting

After formatting, false

{ ··if·(condition)·DoSomething(); ··if·(condition1) ····DoSomething1(); }

{ ····if·(condition)·DoSomething(); ····if·(condition1)·DoSomething1(); }

Place simple embedded statement on same line

Property names:

[resharper_]csharp_place_simple_embedded_statement_on_same_line, [resharper_]place_simple_embedded_statement_on_same_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

{ ····if·(condition) ········DoSomething(); ····if·(condition·&&·//·comment ········condition1) ········DoSomething(); }

never

{ ····if·(condition) ········DoSomething(); ····if·(condition·&&·//·comment ········condition1) ········DoSomething(); }

if_owner_is_single_line

{ ····if·(condition)·DoSomething(); ····if·(condition·&&·//·comment ········condition1) ········DoSomething(); }

True

{ ····if·(condition)·DoSomething(); ····if·(condition·&&·//·comment ········condition1)·DoSomething(); }

always

{ ····if·(condition)·DoSomething(); ····if·(condition·&&·//·comment ········condition1)·DoSomething(); }

Place simple "case" statement on same line

Property names:

[resharper_]csharp_place_simple_case_statement_on_same_line, [resharper_]place_simple_case_statement_on_same_line

Possible values:

  • False: Never

  • never: Never

  • if_owner_is_single_line: If owner is singleline

  • True: Always

  • always: Always

Examples:

False

switch·(foo) { ····case·1: ········return·a; ····case·2: ····case·3: ········return·a; }

never

switch·(foo) { ····case·1: ········return·a; ····case·2: ····case·3: ········return·a; }

if_owner_is_single_line

switch·(foo) { ····case·1:·return·a; ····case·2: ····case·3: ········return·a; }

True

switch·(foo) { ····case·1:·return·a; ····case·2: ····case·3:·return·a; }

always

switch·(foo) { ····case·1:·return·a; ····case·2: ····case·3:·return·a; }

Arrangement of Embedded Blocks

Keep existing arrangement of embedded blocks

Property names:

[resharper_]csharp_keep_existing_embedded_block_arrangement, [resharper_]csharp_keep_existing_arrangement, [resharper_]keep_existing_embedded_block_arrangement, [resharper_]keep_existing_arrangement

Possible values:

true | false

Examples:

Before formatting

After formatting, true

{ ··if·(condition)·{·DoSomething();·} ··if·(condition1) ··{ ····DoSomething1(); ··} }

{ ····if·(condition)·{·DoSomething();·} ····if·(condition1) ····{ ········DoSomething1(); ····} }

Before formatting

After formatting, false

{ ··if·(condition)·{·DoSomething();·} ··if·(condition1) ··{ ····DoSomething1(); ··} }

{ ····if·(condition) ····{ ········DoSomething(); ····} ····if·(condition1) ····{ ········DoSomething1(); ····} }

Place a block with a single simple statement on same line

Property names:

[resharper_]csharp_place_simple_embedded_block_on_same_line, [resharper_]csharp_place_simple_blocks_on_single_line, [resharper_]place_simple_embedded_block_on_same_line, [resharper_]place_simple_blocks_on_single_line

Possible values:

true | false

Examples:

true

if·(condition)·{·DoSomething();·}

false

if·(condition) { ····DoSomething(); }

Place simple anonymous method on single line

Property names:

[resharper_]csharp_place_simple_anonymousmethod_on_single_line, [resharper_]csharp_place_simple_blocks_on_single_line, [resharper_]place_simple_anonymousmethod_on_single_line, [resharper_]place_simple_blocks_on_single_line

Possible values:

true | false

Examples:

true

EventHandler·e·=·delegate·{·return;·};

false

EventHandler·e·=·delegate { ····return; };

Arrangement of Initializers

Keep existing arrangement of initializers

Property names:

[resharper_]csharp_keep_existing_initializer_arrangement, [resharper_]csharp_keep_existing_arrangement, [resharper_]keep_existing_initializer_arrangement, [resharper_]keep_existing_arrangement

Possible values:

true | false

Examples:

Before formatting

After formatting, true

{ ··var·result·=·new·{ ····A·=·0· ··}; ··var·result·=·new·{·A·=·0·}; }

{ ····var·result·=·new ····{ ········A·=·0 ····}; ····var·result·=·new·{A·=·0}; }

Before formatting

After formatting, false

{ ··var·result·=·new·{ ····A·=·0· ··}; ··var·result·=·new·{·A·=·0·}; }

{ ····var·result·=·new·{A·=·0}; ····var·result·=·new·{A·=·0}; }

Place simple array, object and collection on single line

Property names:

[resharper_]csharp_place_simple_initializer_on_single_line, [resharper_]place_simple_initializer_on_single_line

Possible values:

true | false

Examples:

true

var·result·=·new·{A·=·0};

false

var·result·=·new { ····A·=·0 };

Max object and collection initializer elements on a single line

Property names:

[resharper_]csharp_max_initializer_elements_on_line, [resharper_]max_initializer_elements_on_line

Possible values:

an integer

Examples:

value: 0

{ ····x·=·new·C()·{Prop1·=·1}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1, ········Prop6·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1, ········Prop6·=·1, ········Prop7·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1, ········Prop6·=·1, ········Prop7·=·1, ········Prop8·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1, ········Prop6·=·1, ········Prop7·=·1, ········Prop8·=·1, ········Prop9·=·1 ····}; }

value: 1

{ ····x·=·new·C()·{Prop1·=·1}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1, ········Prop6·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1, ········Prop6·=·1, ········Prop7·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1, ········Prop6·=·1, ········Prop7·=·1, ········Prop8·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1, ········Prop2·=·1, ········Prop3·=·1, ········Prop4·=·1, ········Prop5·=·1, ········Prop6·=·1, ········Prop7·=·1, ········Prop8·=·1, ········Prop9·=·1 ····}; }

value: 2

{ ····x·=·new·C()·{Prop1·=·1}; ····x·=·new·C()·{Prop1·=·1,·Prop2·=·1}; ····x·=·new·C() ····{ ········Prop1·=·1,·Prop2·=·1, ········Prop3·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1,·Prop2·=·1, ········Prop3·=·1,·Prop4·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1,·Prop2·=·1, ········Prop3·=·1,·Prop4·=·1, ········Prop5·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1,·Prop2·=·1, ········Prop3·=·1,·Prop4·=·1, ········Prop5·=·1,·Prop6·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1,·Prop2·=·1, ········Prop3·=·1,·Prop4·=·1, ········Prop5·=·1,·Prop6·=·1, ········Prop7·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1,·Prop2·=·1, ········Prop3·=·1,·Prop4·=·1, ········Prop5·=·1,·Prop6·=·1, ········Prop7·=·1,·Prop8·=·1 ····}; ····x·=·new·C() ····{ ········Prop1·=·1,·Prop2·=·1, ········Prop3·=·1,·Prop4·=·1, ········Prop5·=·1,·Prop6·=·1, ········Prop7·=·1,·Prop8·=·1, ········Prop9·=·1 ····}; }

Wrap object and collection initializer

Property names:

[resharper_]csharp_wrap_object_and_collection_initializer_style, [resharper_]wrap_object_and_collection_initializer_style

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

new·C() { ····PropertyX·=·1,·PropertyY·=·2, ····PropertyZ·=·3 }

chop_if_long

new·C() { ····PropertyX·=·1, ····PropertyY·=·2, ····PropertyZ·=·3 }

chop_always

new·C() { ····PropertyX·=·1, ····PropertyY·=·2, ····PropertyZ·=·3 }

Max array initializer elements on a single line

Property names:

[resharper_]csharp_max_array_initializer_elements_on_line, [resharper_]max_array_initializer_elements_on_line

Possible values:

an integer

Examples:

value: 0

{ ····x·=·new[]·{val1}; ····x·=·new[] ····{ ········val1, ········val2 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5, ········val6 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5, ········val6, ········val7 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5, ········val6, ········val7, ········val8 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5, ········val6, ········val7, ········val8, ········val9 ····}; }

value: 1

{ ····x·=·new[]·{val1}; ····x·=·new[] ····{ ········val1, ········val2 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5, ········val6 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5, ········val6, ········val7 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5, ········val6, ········val7, ········val8 ····}; ····x·=·new[] ····{ ········val1, ········val2, ········val3, ········val4, ········val5, ········val6, ········val7, ········val8, ········val9 ····}; }

value: 2

{ ····x·=·new[]·{val1}; ····x·=·new[]·{val1,·val2}; ····x·=·new[] ····{ ········val1,·val2, ········val3 ····}; ····x·=·new[] ····{ ········val1,·val2, ········val3,·val4 ····}; ····x·=·new[] ····{ ········val1,·val2, ········val3,·val4, ········val5 ····}; ····x·=·new[] ····{ ········val1,·val2, ········val3,·val4, ········val5,·val6 ····}; ····x·=·new[] ····{ ········val1,·val2, ········val3,·val4, ········val5,·val6, ········val7 ····}; ····x·=·new[] ····{ ········val1,·val2, ········val3,·val4, ········val5,·val6, ········val7,·val8 ····}; ····x·=·new[] ····{ ········val1,·val2, ········val3,·val4, ········val5,·val6, ········val7,·val8, ········val9 ····}; }

Wrap array initializer

Property names:

[resharper_]csharp_wrap_array_initializer_style, [resharper_]wrap_array_initializer_style

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

new·C[] { ····Element1,·ElementX,·ElementY, ····ElementZ,·ElementZzz }

chop_if_long

new·C[] { ····Element1, ····ElementX, ····ElementY, ····ElementZ, ····ElementZzz }

chop_always

new·C[] { ····Element1, ····ElementX, ····ElementY, ····ElementZ, ····ElementZzz }

Arrangement of Invocations

Wrap invocation arguments

Property names:

[resharper_]csharp_wrap_arguments_style, [resharper_]wrap_arguments_style

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

{ ····CallMethod(arg1,·arg2); ····CallMethod(arg1,·arg2, ········arg3,·arg4,·arg5); }

chop_if_long

{ ····CallMethod(arg1,·arg2); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5); }

chop_always

{ ····CallMethod(arg1, ········arg2); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5); }

Max invocation arguments on a single line

Property names:

[resharper_]csharp_max_invocation_arguments_on_line, [resharper_]max_invocation_arguments_on_line

Possible values:

an integer

Examples:

value: 0

{ ····CallMethod(arg1); ····CallMethod(arg1, ········arg2); ····CallMethod(arg1, ········arg2, ········arg3); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5, ········arg6); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5, ········arg6, ········arg7); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5, ········arg6, ········arg7, ········arg8); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5, ········arg6, ········arg7, ········arg8, ········arg9); }

value: 1

{ ····CallMethod(arg1); ····CallMethod(arg1, ········arg2); ····CallMethod(arg1, ········arg2, ········arg3); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5, ········arg6); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5, ········arg6, ········arg7); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5, ········arg6, ········arg7, ········arg8); ····CallMethod(arg1, ········arg2, ········arg3, ········arg4, ········arg5, ········arg6, ········arg7, ········arg8, ········arg9); }

value: 2

{ ····CallMethod(arg1); ····CallMethod(arg1,·arg2); ····CallMethod(arg1,·arg2, ········arg3); ····CallMethod(arg1,·arg2, ········arg3,·arg4); ····CallMethod(arg1,·arg2, ········arg3,·arg4, ········arg5); ····CallMethod(arg1,·arg2, ········arg3,·arg4, ········arg5,·arg6); ····CallMethod(arg1,·arg2, ········arg3,·arg4, ········arg5,·arg6, ········arg7); ····CallMethod(arg1,·arg2, ········arg3,·arg4, ········arg5,·arg6, ········arg7,·arg8); ····CallMethod(arg1,·arg2, ········arg3,·arg4, ········arg5,·arg6, ········arg7,·arg8, ········arg9); }

Keep existing arrangement of parenthesis in invocation

Property names:

[resharper_]csharp_keep_existing_invocation_parens_arrangement, [resharper_]csharp_keep_existing_arrangement, [resharper_]keep_existing_invocation_parens_arrangement, [resharper_]keep_existing_arrangement

Possible values:

true | false

Examples:

Before formatting

After formatting, true

CallMethod ( arg1,·arg2, arg3,·arg4,·arg5 );

CallMethod ( ····arg1,·arg2, ····arg3,·arg4,·arg5 );

Before formatting

After formatting, false

CallMethod ( arg1,·arg2, arg3,·arg4,·arg5 );

CallMethod(arg1,·arg2, ····arg3,·arg4,·arg5);

Prefer wrap before "(" in invocation

Property names:

[resharper_]csharp_wrap_before_invocation_lpar, [resharper_]wrap_before_invocation_lpar

Possible values:

true | false

Examples:

true

CallMethod (arg1,·arg2, ····arg3,·arg4,·arg5);

false

CallMethod(arg1,·arg2, ····arg3,·arg4,·arg5);

Prefer wrap after "(" in invocation

Property names:

[resharper_]csharp_wrap_after_invocation_lpar, [resharper_]wrap_after_invocation_lpar

Possible values:

true | false

Examples:

true

CallMethod( ····arg1,·arg2, ····arg3,·arg4,·arg5);

false

CallMethod(arg1,·arg2, ····arg3,·arg4,·arg5);

Prefer wrap before ")" in invocation

Property names:

[resharper_]csharp_wrap_before_invocation_rpar, [resharper_]wrap_before_invocation_rpar

Possible values:

true | false

Examples:

true

CallMethod(arg1,·arg2, ····arg3,·arg4,·arg5 );

false

CallMethod(arg1,·arg2, ····arg3,·arg4,·arg5);

Arrangement of Member Access Expressions

Prefer wrap after "."

Property names:

[resharper_]csharp_wrap_after_dot_in_method_calls, [resharper_]wrap_after_dot_in_method_calls

Possible values:

true | false

Examples:

true

obj.Method(). ····Method(). ····Method(). ····Method(). ····Method(). ····Method(). ····Method(). ····Method(). ····Method(). ····Method();

false

obj.Method() ····.Method() ····.Method() ····.Method() ····.Method() ····.Method() ····.Method() ····.Method() ····.Method() ····.Method();

Wrap chained method calls

Property names:

[resharper_]csharp_wrap_chained_method_calls, [resharper_]wrap_chained_method_calls

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

obj.Method().Method()·+ ····obj.Method().Method() ········.Method().Method() ········.Method().Method() ········.Method().Method() ········.Method().Method();

chop_if_long

obj.Method().Method()·+ ····obj.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method();

chop_always

obj.Method() ········.Method()·+ ····obj.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method() ········.Method();

Arrangement of Binary Expressions

Prefer wrap before operator in binary expression

Property names:

[resharper_]csharp_wrap_before_binary_opsign, [resharper_]wrap_before_binary_opsign

Possible values:

true | false

Examples:

true

myField1·=·expression1 ···········+·expression2 ···········+·expression3 ···········+·expression4 ···········+·expression5 ···········+·expression6 ···········+·expression7;

false

myField1·=·expression1·+ ···········expression2·+ ···········expression3·+ ···········expression4·+ ···········expression5·+ ···········expression6·+ ···········expression7;

Wrap chained binary expressions

Property names:

[resharper_]csharp_wrap_chained_binary_expressions, [resharper_]wrap_chained_binary_expressions

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

Examples:

wrap_if_long

b·=·a·!=·b·&&·c·!=·d·&&·e·&& ····f.IsSumOf(g,·h)·&& ····i.Value·==·j·&&·k·==·l·&& ····m·==·n·&&·o·==·p;

chop_if_long

b·=·a·!=·b·&& ····c·!=·d·&& ····e·&& ····f.IsSumOf(g,·h)·&& ····i.Value·==·j·&& ····k·==·l·&& ····m·==·n·&& ····o·==·p;

Force chop compound condition in "if" statement

Property names:

[resharper_]csharp_force_chop_compound_if_expression, [resharper_]force_chop_compound_if_expression

Possible values:

true | false

Examples:

true

if·(var1·==·null·|| ····var2·==·null) ····Foo();

false

if·(var1·==·null·||·var2·==·null) ····Foo();

Force chop compound condition in "while" statement

Property names:

[resharper_]csharp_force_chop_compound_while_expression, [resharper_]force_chop_compound_while_expression

Possible values:

true | false

Examples:

true

while·(var1·==·null·|| ·······var2·==·null) ····Foo();

false

while·(var1·==·null·||·var2·==·null) ····Foo();

Force chop compound condition in "do" statement

Property names:

[resharper_]csharp_force_chop_compound_do_expression, [resharper_]force_chop_compound_do_expression

Possible values:

true | false

Examples:

true

do { ····Foo(); }·while·(var1·==·null·|| ·········var2·==·null);

false

do { ····Foo(); }·while·(var1·==·null·||·var2·==·null);

Arrangement of Ternary Expressions

Prefer wrap before "?" and ":" in ternary expressions

Property names:

[resharper_]csharp_wrap_before_ternary_opsigns, [resharper_]wrap_before_ternary_opsigns

Possible values:

true | false

Examples:

true

return·hereGoesSomeBoolExpression ····?·returnThisIfTrue ····:·returnThatIfFalse;

false

return·hereGoesSomeBoolExpression·? ····returnThisIfTrue·: ····returnThatIfFalse;

Wrap ternary expression

Property names:

[resharper_]csharp_wrap_ternary_expr_style, [resharper_]wrap_ternary_expr_style

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

myField·=·someCondition·?·true ····:·false;

chop_if_long

myField·=·someCondition ····?·true ····:·false;

chop_always

myField·=·someCondition ····?·true ····:·false;

Nested ternary expression style

Property names:

[resharper_]csharp_nested_ternary_style, [resharper_]nested_ternary_style

Possible values:

  • simple_wrap: Simple wrap/Do not change

  • autodetect: Chop in existing style

  • compact: Chop in compact style

  • expanded: Chop in expanded style

Examples:

Before formatting

After formatting, simple_wrap

{ a·=·i·?·"am"·:·you·?·"are"·:·"is"; b·=·error·?·red·: ·warning·?·yellow·: ·green; c·=·tiger ·?·dangerous· :·cat ·?·cute· :·boring; d·=·roses·?·red· :·violets·?·blue· :·so_are_you; }

{ ····a·=·i·?·"am"·:·you·?·"are" ········:·"is"; ····b·=·error·?·red·: ········warning·?·yellow·: ········green; ····c·=·tiger ········?·dangerous ········:·cat ············?·cute ············:·boring; ····d·=·roses·?·red ········:·violets·?·blue ········:·so_are_you; }

Before formatting

After formatting, autodetect

{ a·=·i·?·"am"·:·you·?·"are"·:·"is"; b·=·error·?·red·: ·warning·?·yellow·: ·green; c·=·tiger ·?·dangerous· :·cat ·?·cute· :·boring; d·=·roses·?·red· :·violets·?·blue· :·so_are_you; }

{ ····a·=·i·?·"am"·: ········you·?·"are"·:·"is"; ····b·=·error·?·red·: ········warning·?·yellow·: ········green; ····c·=·tiger ········?·dangerous ········:·cat ············?·cute ············:·boring; ····d·=·roses·?·red ········:·violets·?·blue ········:·so_are_you; }

Before formatting

After formatting, compact

{ a·=·i·?·"am"·:·you·?·"are"·:·"is"; b·=·error·?·red·: ·warning·?·yellow·: ·green; c·=·tiger ·?·dangerous· :·cat ·?·cute· :·boring; d·=·roses·?·red· :·violets·?·blue· :·so_are_you; }

{ ····a·=·i·?·"am"·: ········you·?·"are"·:·"is"; ····b·=·error·?·red·: ········warning·?·yellow·: ········green; ····c·=·tiger·?·dangerous·: ········cat·?·cute·:·boring; ····d·=·roses·?·red·: ········violets·?·blue·: ········so_are_you; }

Before formatting

After formatting, expanded

{ a·=·i·?·"am"·:·you·?·"are"·:·"is"; b·=·error·?·red·: ·warning·?·yellow·: ·green; c·=·tiger ·?·dangerous· :·cat ·?·cute· :·boring; d·=·roses·?·red· :·violets·?·blue· :·so_are_you; }

{ ····a·=·i ········?·"am" ········:·you ············?·"are" ············:·"is"; ····b·=·error ········?·red ········:·warning ············?·yellow ············:·green; ····c·=·tiger ········?·dangerous ········:·cat ············?·cute ············:·boring; ····d·=·roses ········?·red ········:·violets ············?·blue ············:·so_are_you; }

Arrangement of LINQ Expressions

Wrap LINQ expressions

Property names:

[resharper_]csharp_wrap_linq_expressions, [resharper_]wrap_linq_expressions

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • chop_always: Chop always

Examples:

wrap_if_long

var·result·=·from·x·in·list ····where·cond(x)·select·x;

chop_if_long

var·result·=·from·x·in·list ····where·cond(x) ····select·x;

chop_always

var·result·=·from·x·in·list ····where·cond(x) ····select·x;

Prefer wrap before multiline LINQ expressions

Property names:

[resharper_]csharp_wrap_before_linq_expression, [resharper_]wrap_before_linq_expression

Possible values:

true | false

Examples:

true

var·result·= ····from·x·in·list ····where·cond(x) ····select·x;

false

var·result·=·from·x·in·list ····where·cond(x) ····select·x;

Place "into" on new line in LINQ expressions

Property names:

[resharper_]csharp_place_linq_into_on_new_line, [resharper_]place_linq_into_on_new_line

Possible values:

true | false

Examples:

true

var·q1·=·from·i·in·l ····select·i ····into·j ····where·j·!=·0 ····select·j;

false

var·q1·=·from·i·in·l ····select·i·into·j ····where·j·!=·0 ····select·j;

Arrangement of interpolated strings

Wrap verbatim interpolated strings

Property names:

[resharper_]csharp_wrap_verbatim_interpolated_strings, [resharper_]wrap_verbatim_interpolated_strings

Possible values:

  • wrap_if_long: Simple wrap

  • chop_if_long: Chop if long or multiline

  • no_wrap: Do not wrap even if long

Examples:

wrap_if_long

var·s·=·$@"id={id}·src={src ····}·dest={dest}"

chop_if_long

var·s·=·$@"id={ ········id ····}·src={ ········src ····}·dest={ ········dest ····}"

no_wrap

var·s·= ····$@"id={id}·src={src}·dest={dest}"

Last modified: 17 October 2018