C# - Line Breaks - Help

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();`

Right margin (columns)

Property names:

csharp_max_line_length, max_line_length

This option (similarly to the Editorconfig's 'max_line_length') defines the maximum number of characters in each line. It is applied during code reformatting if 'Wrap long lines' is enabled. Line breaks are added 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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

True

[Attribute]·class·C·{·}

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

always

[Attribute]·class·C·{·}

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

if_owner_is_single_line

[Attribute]·class·C·{·}

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

False

[Attribute]
class·C·{·}

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

never

[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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

True

interface·I
{
····[Attribute]·void·foo();
}

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

always

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
····}
}

False

interface·I
{
····[Attribute]
····void·foo();
}

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

never

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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

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;
········}
····}
}

if_owner_is_single_line

interface·I
{
····[Attribute]·int·Property·{·get;·}
}

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

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;
········}
····}
}

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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

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();
········}
····}
}

if_owner_is_single_line

interface·I
{
····int·Property·{·[Attribute]·get;·}
}

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

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();
········}
····}
}

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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

True

class·C
{
····[Attribute]·int·x;

····[Attribute]·MyObj·y·=·//·comment·
········new·MyObj();
}

always

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();
}

False

class·C
{
····[Attribute]
····int·x;

····[Attribute]
····MyObj·y·=·//·comment·
········new·MyObj();
}

never

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:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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

chop_if_long

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

wrap_if_long

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)
{
}

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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

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;
}

if_owner_is_single_line

class·A
{
····public·int·Foo()·=>·0;

····public·int·//·comment
········Foo1()·=>
········1;

····public·int·Foo2()·=>
········1·+·//·comment
········2;
}

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;
}

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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

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;
}

if_owner_is_single_line

class·A
{
····public·int·Foo·=>·0;

····public·int·//·comment
········Foo1·=>
········1;

····public·int·Foo2·=>
········1·+·//·comment
········2;
}

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;
}

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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

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;
····}
}

if_owner_is_single_line

class·A
{
····public·int·Foo
····{
········get·=>·0;
····}

····public·int·Foo1
····{
········get·=>
············1·+·//·comment
············2;
····}
}

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;
····}
}

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:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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

wrap_if_long

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:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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

chop_if_long

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

wrap_if_long

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 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:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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

chop_if_long

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

wrap_if_long

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:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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;
}

wrap_if_long

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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

True

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

always

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

if_owner_is_single_line

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

False

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

never

{
····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:

True: Always
always: Always
if_owner_is_single_line: If owner is singleline
False: Never
never: Never

Examples:

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;
}

if_owner_is_single_line

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

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;
}

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
};

Wrap object and collection initializer

Property names:

[resharper_]csharp_wrap_object_and_collection_initializer_style, [resharper_]wrap_object_and_collection_initializer_style

Possible values:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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

chop_if_long

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

wrap_if_long

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

Wrap array initializer

Property names:

[resharper_]csharp_wrap_array_initializer_style, [resharper_]wrap_array_initializer_style

Possible values:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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

chop_if_long

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

wrap_if_long

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:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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

chop_if_long

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

wrap_if_long

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);

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:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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();

wrap_if_long

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:

chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_if_long

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

wrap_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:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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

chop_if_long

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

wrap_if_long

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

Nested ternary expression style

Property names:

[resharper_]csharp_nested_ternary_style, [resharper_]nested_ternary_style

Possible values:

compact: Chop in compact style
expanded: Chop in expanded style
simple_wrap: Simple wrap/Do not change
autodetect: Chop in existing style

Examples:

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; }
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; }`

Arrangement of LINQ Expressions

Wrap LINQ expressions

Property names:

[resharper_]csharp_wrap_linq_expressions, [resharper_]wrap_linq_expressions

Possible values:

chop_always: Chop always
chop_if_long: Chop if long or multiline
wrap_if_long: Simple wrap

Examples:

chop_always

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;

wrap_if_long

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