C# - Line Breaks
Preserve Existing Formatting
Keep existing line breaks
Property names:
[resharper_]csharp_keep_user_linebreaks, [resharper_]keep_user_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(); |
Break line in single embedded statement
Property names:
[resharper_]csharp_simple_embedded_statement_style, [resharper_]simple_embedded_statement_style
Possible values:
-
line_break: Force line breaks -
on_single_line: Force put on single line -
do_not_change: Do not change
Examples:
| Before formatting | After formatting, line_break |
{
··if·(condition)·DoSomething();
··if·(condition1)
····DoSomething1();
} | {
····if·(condition)
········DoSomething();
····if·(condition1)
········DoSomething1();
} |
| Before formatting | After formatting, on_single_line |
{
··if·(condition)·DoSomething();
··if·(condition1)
····DoSomething1();
} | {
····if·(condition)·DoSomething();
····if·(condition1)·DoSomething1();
} |
| Before formatting | After formatting, do_not_change |
{
··if·(condition)·DoSomething();
··if·(condition1)
····DoSomething1();
} | {
····if·(condition)·DoSomething();
····if·(condition1)
········DoSomething1();
} |
Break line in single "case" statement
Property names:
[resharper_]csharp_simple_case_statement_style, [resharper_]simple_case_statement_style
Possible values:
-
line_break: Force line breaks -
on_single_line: Force put on single line -
do_not_change: Do not change
Examples:
| Before formatting | After formatting, line_break |
switch(foo)·{
··case·1:·return·a;
··case·2:
····return·b;
} | switch·(foo)
{
····case·1:
········return·a;
····case·2:
········return·b;
} |
| Before formatting | After formatting, on_single_line |
switch(foo)·{
··case·1:·return·a;
··case·2:
····return·b;
} | switch·(foo)
{
····case·1:·return·a;
····case·2:·return·b;
} |
| Before formatting | After formatting, do_not_change |
switch(foo)·{
··case·1:·return·a;
··case·2:
····return·b;
} | switch·(foo)
{
····case·1:·return·a;
····case·2:
········return·b;
} |
Break line in a block with a single statement
Property names:
[resharper_]csharp_simple_embedded_block_style, [resharper_]simple_embedded_block_style
Possible values:
-
line_break: Force line breaks -
on_single_line: Force put on single line -
do_not_change: Do not change
Examples:
| Before formatting | After formatting, line_break |
{
··if·(condition)·{·DoSomething();·}
··if·(condition1)
··{
····DoSomething1();
··}
} | {
····if·(condition)
····{
········DoSomething();
····}
····if·(condition1)
····{
········DoSomething1();
····}
} |
| Before formatting | After formatting, on_single_line |
{
··if·(condition)·{·DoSomething();·}
··if·(condition1)
··{
····DoSomething1();
··}
} | {
····if·(condition)·{·DoSomething();·}
····if·(condition1)·{·DoSomething1();·}
} |
| Before formatting | After formatting, do_not_change |
{
··if·(condition)·{·DoSomething();·}
··if·(condition1)
··{
····DoSomething1();
··}
} | {
····if·(condition)·{·DoSomething();·}
····if·(condition1)
····{
········DoSomething1();
····}
} |
Place on New Line
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
{
} |
| false |
try
{
····foo();
}·catch·(Exception·e)
{
····foo();
}
finally
{
} |
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
{
} |
| false |
try
{
····foo();
}
catch·(Exception·e)
{
····foo();
}·finally
{
} |
Line Wrapping
Right margin (columns)
Property names:
csharp_max_line_length, max_line_length
Possible values:
an integer
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)
{
} |
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); |
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); |
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);
····}
} |
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(); |
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
{
} |
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++)
{
} |
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; |
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;
} |
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; |
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); |
Wrap multiple type parameter constraints
Property names:
[resharper_]csharp_wrap_multiple_type_parameer_constraints_style, [resharper_]wrap_multiple_type_parameer_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 |
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
} |
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 |
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>
{
} |
Other
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_]place_abstract_accessorholder_on_single_line, [resharper_]place_simple_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_]place_simple_accessorholder_on_single_line, [resharper_]place_simple_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_]place_accessor_with_attrs_holder_on_single_line, [resharper_]place_simple_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_]place_simple_accessor_on_single_line, [resharper_]place_simple_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_]place_simple_method_on_single_line, [resharper_]place_simple_blocks_on_single_line
Possible values:
true | false
Examples:
| true |
class·C
{
····void·Foo()·{·DoSomethingSimple();·}
} |
| false |
class·C
{
····void·Foo()
····{
········DoSomethingSimple();
····}
} |
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;
}; |
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:
| Before formatting | After formatting, true |
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
}; |
Place type attribute on same line
Property names:
[resharper_]csharp_place_type_attribute_on_same_line, [resharper_]place_type_attribute_on_same_line
Possible values:
true | false
Examples:
| true |
[Attribute]·class·C
{
} |
| false |
[Attribute]
class·C
{
} |
Place method attribute on same line
Property names:
[resharper_]csharp_place_method_attribute_on_same_line, [resharper_]place_method_attribute_on_same_line
Possible values:
true | false
Examples:
| true |
class·C
{
····[Attribute]·void·foo()
····{
····}
} |
| false |
class·C
{
····[Attribute]
····void·foo()
····{
····}
} |
Place property/indexer/event attribute on same line
Property names:
[resharper_]csharp_place_accessorholder_attribute_on_same_line, [resharper_]place_accessorholder_attribute_on_same_line
Possible values:
true | false
Examples:
| true |
class·C
{
····[Attribute]·int·Property
····{
········get·{·return·x;·}
········set·{·x·=·value;·}
····}
} |
| false |
class·C
{
····[Attribute]
····int·Property
····{
········get·{·return·x;·}
········set·{·x·=·value;·}
····}
} |
Place singleline accessor attribute on same line
Property names:
[resharper_]csharp_place_simple_accessor_attribute_on_same_line, [resharper_]place_simple_accessor_attribute_on_same_line
Possible values:
true | false
Examples:
| true |
class·C
{
····int·Property
····{
········[Attribute]·get·{·return·x;·}
········[Attribute]
········set
········{
············x·=·value;
············NotifySomething();
········}
····}
} |
| false |
class·C
{
····int·Property
····{
········[Attribute]
········get·{·return·x;·}
········[Attribute]
········set
········{
············x·=·value;
············NotifySomething();
········}
····}
} |
Place multiline accessor attribute on same line
Property names:
[resharper_]csharp_place_complex_accessor_attribute_on_same_line, [resharper_]place_complex_accessor_attribute_on_same_line
Possible values:
true | false
Examples:
| true |
class·C
{
····int·Property
····{
········[Attribute]·get·{·return·x;·}
········[Attribute]·set
········{
············x·=·value;
············NotifySomething();
········}
····}
} |
| false |
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_]place_field_attribute_on_same_line
Possible values:
true | false
Examples:
| true |
class·C
{
····[Attribute]·int·x;
} |
| false |
class·C
{
····[Attribute]
····int·x;
} |
Place 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()
····{
····}
} |
Place 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
{
} |
Allow comment after '{'
Property names:
[resharper_]csharp_allow_comment_after_lbrace, [resharper_]allow_comment_after_lbrace
Possible values:
true | false
Examples:
| true |
if·(condition)
{·//·comment
····statement;
} |
| false |
if·(condition)
{
····//·comment
····statement;
} |