C# - Tabs, Indents, Alignment
General
Indent style
Property names:
csharp_indent_style
, indent_style
Possible values:
tab
: Tabspace
: Spaces
Examples:
tab |
---|
if·(condition)
{
→if·(condition1)
→{
→→foo1();
→→foo2();
→}
→else
→{
→→foo3();
→→foo4();
→}
} |
space |
---|
if·(condition)
{
····if·(condition1)
····{
········foo1();
········foo2();
····}
····else
····{
········foo3();
········foo4();
····}
} |
Indent size
Property names:
csharp_indent_size
, indent_size
Possible values:
an integer
Examples:
value: 0 |
---|
if·(condition)
{
·if·(condition1)
·{
··foo1();
··foo2();
·}
·else
·{
··foo3();
··foo4();
·}
} |
value: 1 |
---|
if·(condition)
{
·if·(condition1)
·{
··foo1();
··foo2();
·}
·else
·{
··foo3();
··foo4();
·}
} |
value: 2 |
---|
if·(condition)
{
··if·(condition1)
··{
····foo1();
····foo2();
··}
··else
··{
····foo3();
····foo4();
··}
} |
Tab width
Property names:
csharp_tab_width
, tab_width
Possible values:
an integer
Examples:
value: 0 |
---|
if·(condition)
{
→if·(condition1)
→{
→→foo1();
→→foo2();
→}
→else
→{
→→foo3();
→→foo4();
→}
} |
value: 1 |
---|
if·(condition)
{
→if·(condition1)
→{
→→foo1();
→→foo2();
→}
→else
→{
→→foo3();
→→foo4();
→}
} |
value: 2 |
---|
if·(condition)
{
→if·(condition1)
→{
→→foo1();
→→foo2();
→}
→else
→{
→→foo3();
→→foo4();
→}
} |
Continuous line indent multiplier
Property names:
[resharper_]csharp_continuous_indent_multiplier
, [resharper_]continuous_indent_multiplier
Possible values:
an integer
Examples:
value: 0 |
---|
int·x·=·foo1()·+
foo2(); |
value: 1 |
---|
int·x·=·foo1()·+
····foo2(); |
value: 2 |
---|
int·x·=·foo1()·+
········foo2(); |
Nested Statements
Indent nested "using" statements
Property names:
[resharper_]csharp_indent_nested_usings_stmt
, [resharper_]indent_nested_usings_stmt
Possible values:
true | false
Examples:
true |
---|
using·(A·a·=·new·A())
····using·(B·b·=·new·B())
········using·(C·c·=·new·C())
········{
············foo();
········} |
false |
---|
using·(A·a·=·new·A())
using·(B·b·=·new·B())
using·(C·c·=·new·C())
{
····foo();
} |
Indent nested "fixed" statements
Property names:
[resharper_]csharp_indent_nested_fixed_stmt
, [resharper_]indent_nested_fixed_stmt
Possible values:
true | false
Examples:
true |
---|
fixed·(int*·a·=·&x)
····fixed·(int*·b·=·&y)
········fixed·(int*·c·=·&z)
········{
············foo();
········} |
false |
---|
fixed·(int*·a·=·&x)
fixed·(int*·b·=·&y)
fixed·(int*·c·=·&z)
{
····foo();
} |
Indent nested "lock" statements
Property names:
[resharper_]csharp_indent_nested_lock_stmt
, [resharper_]indent_nested_lock_stmt
Possible values:
true | false
Examples:
true |
---|
lock·(a)
····lock·(b)
········lock·(c)
········{
············foo();
········} |
false |
---|
lock·(a)
lock·(b)
lock·(c)
{
····foo();
} |
Indent nested "for" statements
Property names:
[resharper_]csharp_indent_nested_for_stmt
, [resharper_]indent_nested_for_stmt
Possible values:
true | false
Examples:
true |
---|
for·(int·a·=·0;·a·<·x;·a++)
····for·(int·b·=·0;·b·<·y;·b++)
········for·(int·c·=·0;·c·<·y;·c++)
········{
············foo();
········} |
false |
---|
for·(int·a·=·0;·a·<·x;·a++)
for·(int·b·=·0;·b·<·y;·b++)
for·(int·c·=·0;·c·<·y;·c++)
{
····foo();
} |
Indent nested "foreach" statements
Property names:
[resharper_]csharp_indent_nested_foreach_stmt
, [resharper_]indent_nested_foreach_stmt
Possible values:
true | false
Examples:
true |
---|
foreach·(var·a·in·x)
····foreach·(var·b·in·y)
········foreach·(var·c·in·z)
········{
············foo();
········} |
false |
---|
foreach·(var·a·in·x)
foreach·(var·b·in·y)
foreach·(var·c·in·z)
{
····foo();
} |
Indent nested "while" statements
Property names:
[resharper_]csharp_indent_nested_while_stmt
, [resharper_]indent_nested_while_stmt
Possible values:
true | false
Examples:
true |
---|
while·(a)
····while·(b)
········while·(c)
········{
············foo();
········} |
false |
---|
while·(a)
while·(b)
while·(c)
{
····foo();
} |
Parenthesis
Use continuous line indent inside parenthesis
Property names:
[resharper_]csharp_use_continuous_indent_inside_parens
, [resharper_]use_continuous_indent_inside_parens
Possible values:
true | false
Examples:
true |
---|
var·x·=·Method(
····parameter1,
····parameter2
); |
false |
---|
var·x·=·Method(
····parameter1,
····parameter2
); |
Indent method declarations' parenthesis
Property names:
[resharper_]csharp_indent_method_decl_pars
, [resharper_]indent_method_decl_pars
Possible values:
inside
: Inside parenthesis (BSD/K&R style)outside
: Parenthesis and inside equally (Whitesmiths style)outside_and_inside
: Parenthesis 1x, inside 2x (GNU style)none
: No indent
Examples:
inside |
---|
void·Method(
····int·parameter1,
····int·parameter2
); |
outside |
---|
void·Method(
····int·parameter1,
····int·parameter2
····); |
outside_and_inside |
---|
void·Method(
········int·parameter1,
········int·parameter2
····); |
none |
---|
void·Method(
int·parameter1,
int·parameter2
); |
Indent method calls' parenthesis
Property names:
[resharper_]csharp_indent_invocation_pars
, [resharper_]indent_invocation_pars
Possible values:
inside
: Inside parenthesis (BSD/K&R style)outside
: Parenthesis and inside equally (Whitesmiths style)outside_and_inside
: Parenthesis 1x, inside 2x (GNU style)none
: No indent
Examples:
inside |
---|
var·x·=·Method(
····parameter1,
····parameter2
); |
outside |
---|
var·x·=·Method(
····parameter1,
····parameter2
····); |
outside_and_inside |
---|
var·x·=·Method(
········parameter1,
········parameter2
····); |
none |
---|
var·x·=·Method(
parameter1,
parameter2
); |
Indent statement (if, while, for, etc) parenthesis
Property names:
[resharper_]csharp_indent_statement_pars
, [resharper_]indent_statement_pars
Possible values:
inside
: Inside parenthesis (BSD/K&R style)outside
: Parenthesis and inside equally (Whitesmiths style)outside_and_inside
: Parenthesis 1x, inside 2x (GNU style)none
: No indent
Examples:
inside |
---|
if·(
····condition1·&&
····condition2
)
····return; |
outside |
---|
if·(
····condition1·&&
····condition2
····)
····return; |
outside_and_inside |
---|
if·(
········condition1·&&
········condition2
····)
····return; |
none |
---|
if·(
condition1·&&
condition2
)
····return; |
Indent type parameter's angles
Property names:
[resharper_]csharp_indent_typeparam_angles
, [resharper_]indent_typeparam_angles
Possible values:
inside
: Inside parenthesis (BSD/K&R style)outside
: Parenthesis and inside equally (Whitesmiths style)outside_and_inside
: Parenthesis 1x, inside 2x (GNU style)none
: No indent
Examples:
inside |
---|
void·Method<
····T1,
····T2
>(); |
outside |
---|
void·Method<
····T1,
····T2
····>(); |
outside_and_inside |
---|
void·Method<
········T1,
········T2
····>(); |
none |
---|
void·Method<
T1,
T2
>(); |
Indent type argument's angles
Property names:
[resharper_]csharp_indent_typearg_angles
, [resharper_]indent_typearg_angles
Possible values:
inside
: Inside parenthesis (BSD/K&R style)outside
: Parenthesis and inside equally (Whitesmiths style)outside_and_inside
: Parenthesis 1x, inside 2x (GNU style)none
: No indent
Examples:
inside |
---|
var·x·=·Method<
····Class1,
····Class2
>(); |
outside |
---|
var·x·=·Method<
····Class1,
····Class2
····>(); |
outside_and_inside |
---|
var·x·=·Method<
········Class1,
········Class2
····>(); |
none |
---|
var·x·=·Method<
Class1,
Class2
>(); |
Indent other parenthesis and brackets
Property names:
[resharper_]csharp_indent_pars
, [resharper_]indent_pars
Possible values:
inside
: Inside parenthesis (BSD/K&R style)outside
: Parenthesis and inside equally (Whitesmiths style)outside_and_inside
: Parenthesis 1x, inside 2x (GNU style)none
: No indent
Examples:
inside |
---|
var·x·=·1·*·checked(
············5·+
············6
········); |
outside |
---|
var·x·=·1·*·checked(
············5·+
············6
············); |
outside_and_inside |
---|
var·x·=·1·*·checked(
················5·+
················6
············); |
none |
---|
var·x·=·1·*·checked(
········5·+
········6
········); |
Preprocessor Directives
Indent #if, #else, #elif, #endif
Property names:
[resharper_]csharp_indent_preprocessor_if
, [resharper_]indent_preprocessor_if
Possible values:
no_indent
: No indentusual_indent
: Indent as usualoutdent
: Outdentdo_not_change
: Do not change
Examples:
no_indent |
---|
namespace·N
{
····class·C
····{
#if·!HideSomething
········int·myField;
#endif
····}
} |
usual_indent |
---|
namespace·N
{
····class·C
····{
········#if·!HideSomething
········int·myField;
········#endif
····}
} |
outdent |
---|
namespace·N
{
····class·C
····{
····#if·!HideSomething
········int·myField;
····#endif
····}
} |
do_not_change |
---|
namespace·N
{
····class·C
····{
·#if·!HideSomething
········int·myField;
·#endif
····}
} |
Indent #region, #endregion
Property names:
[resharper_]csharp_indent_preprocessor_region
, [resharper_]indent_preprocessor_region
Possible values:
no_indent
: No indentusual_indent
: Indent as usualoutdent
: Outdentdo_not_change
: Do not change
Examples:
no_indent |
---|
namespace·N
{
····class·C
····{
#region·Fields
········int·myField;
#endregion
····}
} |
usual_indent |
---|
namespace·N
{
····class·C
····{
········#region·Fields
········int·myField;
········#endregion
····}
} |
outdent |
---|
namespace·N
{
····class·C
····{
····#region·Fields
········int·myField;
····#endregion
····}
} |
do_not_change |
---|
namespace·N
{
····class·C
····{
·#region·Fields
········int·myField;
·#endregion
····}
} |
Indent other preprocessor directives
Property names:
[resharper_]csharp_indent_preprocessor_other
, [resharper_]indent_preprocessor_other
Possible values:
no_indent
: No indentusual_indent
: Indent as usualoutdent
: Outdentdo_not_change
: Do not change
Examples:
no_indent |
---|
namespace·N
{
····class·C
····{
#pragma·warning·disable·CS3021
········int·myField;
#warning·Fixme
····}
} |
usual_indent |
---|
namespace·N
{
····class·C
····{
········#pragma·warning·disable·CS3021
········int·myField;
········#warning·Fixme
····}
} |
outdent |
---|
namespace·N
{
····class·C
····{
····#pragma·warning·disable·CS3021
········int·myField;
····#warning·Fixme
····}
} |
do_not_change |
---|
namespace·N
{
····class·C
····{
·#pragma·warning·disable·CS3021
········int·myField;
·#warning·Fixme
····}
} |
Other Indents
Indent "case" from "switch"
Property names:
csharp_indent_switch_labels
, indent_switch_labels
Possible values:
true | false
Examples:
true |
---|
switch·(expression)
{
····case·0:
········break;
} |
false |
---|
switch·(expression)
{
case·0:
····break;
} |
Indent type constraints
Property names:
[resharper_]csharp_indent_type_constraints
, [resharper_]indent_type_constraints
Possible values:
true | false
Examples:
true |
---|
class·C1<T1>
····where·T1·:·I1
{
} |
false |
---|
class·C1<T1>
where·T1·:·I1
{
} |
Don't indent comments started at first column
Property names:
[resharper_]csharp_stick_comment
, [resharper_]stick_comment
Possible values:
true | false
Examples:
Before formatting | After formatting, true |
---|---|
namespace·N·{
//·Some·comment
··class·C·{
··}
} |
namespace·N
{
//·Some·comment
····class·C
····{
····}
} |
Before formatting | After formatting, false |
---|---|
namespace·N·{
//·Some·comment
··class·C·{
··}
} |
namespace·N
{
····//·Some·comment
····class·C
····{
····}
} |
Align Multiline Constructs
How to align when tabs are used for indents
Property names:
[resharper_]csharp_alignment_tab_fill_style
, [resharper_]alignment_tab_fill_style
Possible values:
use_spaces
: Use spaces (looks aligned on any tab size)use_tabs_only
: Only use tabs (inaccurate)optimal_fill
: Mix tabs and spaces for optimal fill
Examples:
use_spaces |
---|
SomeMyMethod(param1,
·············param2); |
use_tabs_only |
---|
SomeMyMethod(param1,
→→→param2); |
optimal_fill |
---|
SomeMyMethod(param1,
→→→·param2); |
Method parameters
Property names:
[resharper_]csharp_align_multiline_parameter
, [resharper_]align_multiline_parameter
Possible values:
true | false
Examples:
true |
---|
void·fooCall(int·firstParameter,
·············int·secondParameter)
{
} |
false |
---|
void·fooCall(int·firstParameter,
····int·secondParameter)
{
} |
List of base classes and interfaces
Property names:
[resharper_]csharp_align_multiline_extends_list
, [resharper_]align_multiline_extends_list
Possible values:
true | false
Examples:
true |
---|
class·C·:·BaseClass,
··········SomeInterface
{
} |
false |
---|
class·C·:·BaseClass,
····SomeInterface
{
} |
LINQ query
Property names:
[resharper_]csharp_align_linq_query
, [resharper_]align_linq_query
Possible values:
true | false
Examples:
true |
---|
var·q·=·from·x·in·xs
········where·x·!=·null
········select·x; |
false |
---|
var·q·=·from·x·in·xs
····where·x·!=·null
····select·x; |
Chained binary expressions
Property names:
[resharper_]csharp_align_multiline_binary_expressions_chain
, [resharper_]align_multiline_binary_expressions_chain
Possible values:
true | false
Examples:
true |
---|
var·a·=·someOperand·+·operand2
····················+·operand3
····················+·operand4; |
false |
---|
var·a·=·someOperand·+·operand2
····+·operand3
····+·operand4; |
Outdent binary operators
Property names:
[resharper_]csharp_outdent_binary_ops
, [resharper_]outdent_binary_ops
Possible values:
true | false
Examples:
true |
---|
{
····var·a·=
········someOperand
······+·operand2
······+·operand3
······+·operand4;
····var·b·=·someOperand
··········+·operand2
··········+·operand3
··········+·operand4;
} |
false |
---|
{
····var·a·=
········someOperand
········+·operand2
········+·operand3
········+·operand4;
····var·b·=·someOperand
············+·operand2
············+·operand3
············+·operand4;
} |
Chained method calls
Property names:
[resharper_]csharp_align_multiline_calls_chain
, [resharper_]align_multiline_calls_chain
Possible values:
true | false
Examples:
true |
---|
MyVar.SomeMethod()
·····.OtherMethod()
·····.ThirdMethod(); |
false |
---|
MyVar.SomeMethod()
····.OtherMethod()
····.ThirdMethod(); |
Outdent dots in chained method calls
Property names:
[resharper_]csharp_outdent_dots
, [resharper_]outdent_dots
Possible values:
true | false
Examples:
true |
---|
{
····var·a·=
········MyVar
···········.SomeMethod()
··········?.OtherMethod()
···········.ThirdMethod();
····var·b·=·MyVar
·······.SomeMethod()
······?.OtherMethod()
·······.ThirdMethod();
} |
false |
---|
{
····var·a·=
········MyVar
············.SomeMethod()
············?.OtherMethod()
············.ThirdMethod();
····var·b·=·MyVar
········.SomeMethod()
········?.OtherMethod()
········.ThirdMethod();
} |
Array, object and collection initializer
Property names:
[resharper_]csharp_align_multiline_array_and_object_initializer
, [resharper_]align_multiline_array_and_object_initializer
Possible values:
true | false
Examples:
true |
---|
StudentName·student·=·new·StudentName
······················{
··························FirstName·=·"John",
··························LastName·=·"Smith",
··························ID·=·116
······················} |
false |
---|
StudentName·student·=·new·StudentName
{
····FirstName·=·"John",
····LastName·=·"Smith",
····ID·=·116
} |
Anonymous method body
Property names:
[resharper_]csharp_indent_anonymous_method_block
, [resharper_]indent_anonymous_method_block
Possible values:
true | false
Examples:
true |
---|
FooCall(delegate
········{
············DoSomething();
············return·0;
········}); |
false |
---|
FooCall(delegate
{
····DoSomething();
····return·0;
}); |
First call arguments by '('
Property names:
[resharper_]csharp_align_first_arg_by_paren
, [resharper_]align_first_arg_by_paren
Possible values:
true | false
Examples:
true |
---|
fooCall(
········firstParameter,
········secondParameter); |
false |
---|
fooCall(
····firstParameter,
····secondParameter); |
Call arguments
Property names:
[resharper_]csharp_align_multiline_argument
, [resharper_]align_multiline_argument
Possible values:
true | false
Examples:
true |
---|
fooCall(firstParameter,
········secondParameter); |
false |
---|
fooCall(firstParameter,
····secondParameter); |
Tuple components
Property names:
[resharper_]csharp_align_tuple_components
, [resharper_]align_tuple_components
Possible values:
true | false
Examples:
true |
---|
var·tuple·=·(firstParameter,
·············secondParameter); |
false |
---|
var·tuple·=·(firstParameter,
····secondParameter); |
Other expressions
Property names:
[resharper_]csharp_align_multiline_expression
, [resharper_]align_multiline_expression
Possible values:
true | false
Examples:
true |
---|
destination·=·source1
··················?·source2
··················:·source3 |
false |
---|
destination·=·source1
····?·source2
····:·source3 |
"for" statement header
Property names:
[resharper_]csharp_align_multiline_for_stmt
, [resharper_]align_multiline_for_stmt
Possible values:
true | false
Examples:
true |
---|
for·(int·i·=·0;
·····i·<·10;
·····i++)
{
} |
false |
---|
for·(int·i·=·0;
····i·<·10;
····i++)
{
} |
Multiple declarations
Property names:
[resharper_]csharp_align_multiple_declaration
, [resharper_]align_multiple_declaration
Possible values:
true | false
Examples:
true |
---|
class·C
{
····private·int·i·=·0,
················j·=·10;
} |
false |
---|
class·C
{
····private·int·i·=·0,
········j·=·10;
} |
Type parameters list
Property names:
[resharper_]csharp_align_multline_type_parameter_list
, [resharper_]align_multline_type_parameter_list
Possible values:
true | false
Examples:
true |
---|
class·Class<T1,
············T2,
············T3>
{
} |
false |
---|
class·Class<T1,
····T2,
····T3>
{
} |
Type parameter constraints
Property names:
[resharper_]csharp_align_multline_type_parameter_constrains
, [resharper_]align_multline_type_parameter_constrains
Possible values:
true | false
Examples:
true |
---|
class·C<T1,·T2>·where·T1·:·I1
················where·T2·:·I1
{
} |
false |
---|
class·C<T1,·T2>·where·T1·:·I1
····where·T2·:·I1
{
} |
Outdent commas
Property names:
[resharper_]csharp_outdent_commas
, [resharper_]outdent_commas
Possible values:
true | false
Examples:
true |
---|
class·Class<
····T1
··,·T3>·:
····Base
··,·SomeInterface
{
····void·fooCall(
········int·firstParameter
······,·int·secondParameter)
····{
········fooCall(
············firstParameter
··········,·secondParameter);
····}
} |
false |
---|
class·Class<
····T1
····,·T3>·:
····Base
····,·SomeInterface
{
····void·fooCall(
········int·firstParameter
········,·int·secondParameter)
····{
········fooCall(
············firstParameter
············,·secondParameter);
····}
} |
Align Similar Code in Columns
Fields and constants
Property names:
[resharper_]csharp_int_align_fields
, [resharper_]csharp_int_align
, [resharper_]int_align_fields
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
class·C
{
····[Attr]········private·string····x·····=·"x";
····[Attr(2)]·····public··SomeClass·xxxxx·=·"xxxxx";
····[Attr,·Attr3]·private·string····xxx;
} |
false |
---|
class·C
{
····[Attr]·private·string·x·=·"x";
····[Attr(2)]·public·SomeClass·xxxxx·=·"xxxxx";
····[Attr,·Attr3]·private·string·xxx;
} |
Properties and events
Property names:
[resharper_]csharp_int_align_properties
, [resharper_]csharp_int_align
, [resharper_]int_align_properties
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
class·C
{
····[Attr]········private·string····x······{·get;·set;·}·=·"x";
····[Attr(2)]·····public··SomeClass·xxxxx··{·get;·set;·}·=·SomeClass.Default;
····[Attr,·Attr3]·private·string····xxx····{·get;·}
····[Attr]········private·string····x2·····=>·"x";
····[Attr(2)]·····public··SomeClass·xxxxx2·=>·"xxxxx";
····[Attr,·Attr3]·private·string····xxx2···=>·"xxx";
} |
false |
---|
class·C
{
····[Attr]·private·string·x·{·get;·set;·}·=·"x";
····[Attr(2)]·public·SomeClass·xxxxx·{·get;·set;·}·=·SomeClass.Default;
····[Attr,·Attr3]·private·string·xxx·{·get;·}
····[Attr]·private·string·x2·=>·"x";
····[Attr(2)]·public·SomeClass·xxxxx2·=>·"xxxxx";
····[Attr,·Attr3]·private·string·xxx2·=>·"xxx";
} |
Simple methods, operators, delegates
Property names:
[resharper_]csharp_int_align_methods
, [resharper_]csharp_int_align
, [resharper_]int_align_methods
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
class·C
{
····[Attr]········private·string····x(int·p)·········{·return·"x"·+·p;·};
····[Attr(2)]·····public··SomeClass·xxxxx(string·b)··{·return·b.ToSomeClass();·}
····[Attr,·Attr3]·private·string····xxx()············{·return·null;·}
····[Attr]········private·string····x2(int·p)········=>·"x"·+·p;
····[Attr(2)]·····public··SomeClass·xxxxx2(string·b)·=>·b.ToSomeClass();
····[Attr,·Attr3]·private·string····xxx()············=>·null;
} |
false |
---|
class·C
{
····[Attr]·private·string·x(int·p)·{·return·"x"·+·p;·};
····[Attr(2)]·public·SomeClass·xxxxx(string·b)·{·return·b.ToSomeClass();·}
····[Attr,·Attr3]·private·string·xxx()·{·return·null;·}
····[Attr]·private·string·x2(int·p)·=>·"x"·+·p;
····[Attr(2)]·public·SomeClass·xxxxx2(string·b)·=>·b.ToSomeClass();
····[Attr,·Attr3]·private·string·xxx()·=>·null;
} |
Multiline method signature
Property names:
[resharper_]csharp_int_align_parameters
, [resharper_]csharp_int_align
, [resharper_]int_align_parameters
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
void·MyMethod(
····[Attr,·Attr3]·string····xxx,
····[Attr]········string····x·····=·"x",
····[Attr(2)]·····SomeClass·xxxxx·=·"xxxxx")
{
} |
false |
---|
void·MyMethod(
····[Attr,·Attr3]·string·xxx,
····[Attr]·string·x·=·"x",
····[Attr(2)]·SomeClass·xxxxx·=·"xxxxx")
{
} |
Variables and local constants
Property names:
[resharper_]csharp_int_align_variables
, [resharper_]csharp_int_align
, [resharper_]int_align_variables
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
{
····var·x·····=·1;
····var·xxxxx·=·2;
····var·xxx···=·2;
} |
false |
---|
{
····var·x·=·1;
····var·xxxxx·=·2;
····var·xxx·=·2;
} |
Other assignments and initializers
Property names:
[resharper_]csharp_int_align_assignments
, [resharper_]csharp_int_align
, [resharper_]int_align_assignments
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
{
····x·····=·1;
····xxxxx·=·2;
····xxx···=·2;
} |
false |
---|
{
····x·=·1;
····xxxxx·=·2;
····xxx·=·2;
} |
Nested ternary operators
Property names:
[resharper_]csharp_int_align_nested_ternary
, [resharper_]csharp_int_align
, [resharper_]int_align_nested_ternary
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
var·x·=
····y·==·"a"····?·1·:
····y·==·"aaaa"·?·4·:
····y·==·"aa"···?·2·:
··················0; |
false |
---|
var·x·=
····y·==·"a"·?·1·:
····y·==·"aaaa"·?·4·:
····y·==·"aa"·?·2·:
····0; |
Invocations of the same method
Property names:
[resharper_]csharp_int_align_invocations
, [resharper_]csharp_int_align
, [resharper_]int_align_invocations
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
[Attr("x",···············1234567)]
[Attr("xxxxx",···········1)]
[Attr(MyEnum.MyConstant,·124)]
void·MyMethod()
{
····CallMe("x",···············1234567);
····CallMe("xxxxx",···········1);
····CallMe(MyEnum.MyConstant,·124);
} |
false |
---|
[Attr("x",·1234567)]
[Attr("xxxxx",·1)]
[Attr(MyEnum.MyConstant,·124)]
void·MyMethod()
{
····CallMe("x",·1234567);
····CallMe("xxxxx",·1);
····CallMe(MyEnum.MyConstant,·124);
} |
Binary expressions
Property names:
[resharper_]csharp_int_align_binary_expressions
, [resharper_]csharp_int_align
, [resharper_]int_align_binary_expressions
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
if·(
····zzz·····························||
····someCondition·&&·otherCondition·||
····aa············&&·bb·············||
····x·······==·"a"··················||
····xxxxxxx·!=·"aaaa"···············||
····xx······>·"aa")
{
····DoSomething();
} |
false |
---|
if·(
····zzz·||
····someCondition·&&·otherCondition·||
····aa·&&·bb·||
····x·==·"a"·||
····xxxxxxx·!=·"aaaa"·||
····xx·>·"aa")
{
····DoSomething();
} |
End comments
Property names:
[resharper_]csharp_int_align_comments
, [resharper_]csharp_int_align
, [resharper_]int_align_comments
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
{
····DoSomething();·······//·I'm
····var·y·=·6;···········//·forced
····while·(y·>·0)·y--;···//·to
····DoSomethingElse();···/*·document·*/
····var·z·=·10;··········/*·my·code·*/
····while·(z·<·100)·z++;·/*·profusely·*/
} |
false |
---|
{
····DoSomething();·//·I'm
····var·y·=·6;·//·forced
····while·(y·>·0)·y--;·//·to
····DoSomethingElse();·/*·document·*/
····var·z·=·10;·/*·my·code·*/
····while·(z·<·100)·z++;·/*·profusely·*/
} |
Simple switch sections
Property names:
[resharper_]csharp_int_align_switch_sections
, [resharper_]csharp_int_align
, [resharper_]int_align_switch_sections
, [resharper_]int_align
Possible values:
true | false
Examples:
true |
---|
switch·(op)
{
····case·op.Add:······return·x·+·y;
····case·op.Subtract:·return·x·-·y;
····case·op.Multiply:·return·x·*·y;
····case·op.Divide:···return·x·/·y;
} |
false |
---|
switch·(op)
{
····case·op.Add:·return·x·+·y;
····case·op.Subtract:·return·x·-·y;
····case·op.Multiply:·return·x·*·y;
····case·op.Divide:·return·x·/·y;
} |