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

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

true

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

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

true

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

false
`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 { }`

true

class·A
{
}

false
`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, 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·{·}`

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

False

[Attribute]
class·C·{·}

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

never
`[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· }`

if_owner_is_single_line

[Attribute]·class·C·{·}

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

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

True

[Attribute]·class·C·{·}

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

always
`[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 ····} }`

False

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

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

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

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

True

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

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

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

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

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

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

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

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

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

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

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

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

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

False

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

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

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

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

True

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

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

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

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

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

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

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

true

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

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

true

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

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

true

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

false
`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() ····{ ····} }`

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