EditorConfig 属性索引

此页面列出了自定义 JetBrains Rider EditorConfig 属性，您可以使用它们来配置代码格式规则、代码检查严重性级别和代码语法样式规则。请注意，某些属性适用于一种语言，而其他属性同时适用于多种语言。然而，对于每个多语言属性，都有一个属性可以为特定语言覆盖它，例如， align_multiline_parameter 和 csharp_align_multiline_parameter。

属性名称	描述
`accessor_declaration_braces`	大括号布局 - 访问器声明（C#）
`accessor_owner_body`	代码体 - 属性、索引器和事件 (C#)
`accessor_owner_declaration_braces`	大括号布局 - 属性声明（C#）
`add_imports_to_deepest_scope`	引用限定和 'using' 指令 - 将 'using' 指令添加到最深作用域（C#）
`align_first_arg_by_paren`	对齐多行结构 - 按 '(' 对齐调用参数，可用于： C#
`align_linq_query`	对齐多行结构 - LINQ 查询（C#）
`align_multiline_argument`	对齐多行结构 - 调用参数，可用于： C#、 VB.NET
`align_multiline_array_and_object_initializer`	对齐多行结构 - 数组、对象和集合初始化器（C#）
`align_multiline_array_initializer`	对齐多行结构 - 数组初始化器（VB.NET）
`align_multiline_binary_expressions_chain`	对齐多行结构 - 二元表达式，可用于： C#
`align_multiline_binary_patterns`	对齐多行结构 - 二元模式（C#）
`align_multiline_calls_chain`	对齐多行结构 - 链式方法调用，可用于： C#
`align_multiline_comments`	对齐多行结构 - 使用星号对齐多行注释（C#）
`align_multiline_expression`	对齐多行结构 - 其他表达式，可用于： C#、 VB.NET
`align_multiline_extends_list`	对齐多行结构 - 基类和接口列表，可用于： C#
`align_multiline_for_stmt`	对齐多行结构 - 'for' 语句头部（C#）
`align_multiline_implements_list`	对齐多行结构 - Implements/handles 列表 (VB.NET)
`align_multiline_list_pattern`	对齐多行结构 - 列表模式和集合表达式（C#）
`align_multiline_parameter`	对齐多行结构 - 方法参数，可用于： C#、 VB.NET
`align_multiline_property_pattern`	对齐多行结构 - 属性模式（C#）
`align_multiline_statement_conditions`	对齐多行结构 - 括号内的语句条件（C#）
`align_multiline_switch_expression`	对齐多行结构 - Switch 表达式（C#）
`align_multiple_declaration`	对齐多行结构 - 多个声明，可用于： C#、 VB.NET
`align_multline_type_parameter_constrains`	对齐多行结构 - 类型参数约束（C#）
`align_multline_type_parameter_list`	对齐多行结构 - 类型参数列表（C#）
`align_ternary`	对齐多行结构 - ?: 运算符，可用于：
`align_tuple_components`	对齐多行结构 - 元组组件（C#）
`alignment_tab_fill_style`	对齐多行结构 - 使用制表符缩进时的对齐方式，可用于： C#、 ShaderLab、 VB.NET
`allow_alias`	引用限定和 'using' 指令 - 使用 using 别名指令解决冲突，可用于： C#、 VB.NET
`allow_comment_after_lbrace`	大括号布局 - 允许在 '{' 后添加注释，可用于： C#
`allow_far_alignment`	对齐多行结构 - 即使结果缩进过大也对齐，可用于： C#、 ShaderLab
`always_use_end_of_line_brace_style`	为 C# 覆盖大括号样式以始终使用 '行尾 (K&R 样式)'（Razor CSharp）
`anonymous_method_declaration_braces`	大括号布局 - Lambda 和委托（匿名方法声明），可用于： C#
`arguments_anonymous_function`	参数 - 匿名方法（委托和 lambda 表达式）（C#）
`arguments_literal`	参数 - 字面值（C#）
`arguments_named`	参数 - 命名表达式（变量、属性、方法等）（C#）
`arguments_other`	参数 - 其他（C#）
`arguments_skip_single`	参数 - 跳过单个参数（C#）
`arguments_string_literal`	参数 - 字符串字面值（C#）
`attribute_indent`	标签头部内部 - 属性缩进，可用于：
`attribute_style`	标签头部内部 - 属性格式，可用于：
`blank_line_after_pi`	处理指令 - 处理指令后留空行，可用于：
`blank_lines_after_block_statements`	代码中的空行 - 在带有子块的语句之后（C#）
`blank_lines_after_case`	代码中的空行 - 在 switch 语句中的 'case' 之后（C#）
`blank_lines_after_control_transfer_statements`	代码中的空行 - 在具有控制转移的语句之后 (C#)
`blank_lines_after_file_scoped_namespace_directive`	声明中的空行 - 在文件范围的命名空间指令之后（C#）
`blank_lines_after_imports`	空行 - 在 Imports 部分之后 (VB.NET)
`blank_lines_after_multiline_statements`	代码中的空行 - 在多行语句之后 (C#)
`blank_lines_after_options`	空行 - 在文件选项部分之后（VB.NET）
`blank_lines_after_start_comment`	声明中的空行 - 文件头注释后（C#）
`blank_lines_after_using_list`	声明中的空行 - 'using' 列表后（C#）
`blank_lines_around_accessor`	声明中的空行 - 属性/事件访问器周围（C#）
`blank_lines_around_auto_property`	声明中的空行 - 自动/抽象属性/事件周围（C#）
`blank_lines_around_block_case_section`	代码中的空行 - 在 switch 语句中带有块的 'case' 部分周围（C#）
`blank_lines_around_field`	声明中的空行 - 字段周围，可用于： C#、 VB.NET
`blank_lines_around_global_attribute`	空行 - 全局属性之后 (VB.NET)
`blank_lines_around_invocable`	声明中的空行 - 方法周围，可用于： C#、 VB.NET
`blank_lines_around_local_method`	代码中的空行 - 在局部函数周围（C#）
`blank_lines_around_multiline_case_section`	代码中的空行 - 多行 'case' 部分在 switch 语句中（C#）
`blank_lines_around_namespace`	声明中的空行 - 在命名空间周围，可用于： C#， VB.NET
`blank_lines_around_property`	声明中的空行 - 在属性/事件周围（C#）
`blank_lines_around_razor_functions`	Razor @functions 块周围的空行（Razor CSharp）
`在 Razor 辅助函数周围添加空行`	Razor 助手周围的空行（Razor CSharp）
`在 Razor 区段周围添加空行`	Razor 区段周围的空行 (Razor CSharp)
`在区域周围添加空行`	常规 - 区域周围，可用于： C#、 VB.NET
`在单行访问器周围添加空行`	声明中的空行 - 单行属性/事件访问器周围（C#）
`在单行自动属性周围添加空行`	声明中的空行 - 单行自动/抽象属性/事件周围（C#）
`在单行字段周围添加空行`	声明中的空行 - 单行字段周围，可用于： C#、 VB.NET
`在单行可调用成员周围添加空行`	声明中的空行 - 单行方法周围，可用于： C#、 VB.NET
`在单行本地方法周围添加空行`	代码中的空行 - 在单行局部函数周围（C#）
`在单行属性周围添加空行`	声明中的空行 - 在单行属性/事件周围（C#）
`在单行类型周围添加空行`	声明中的空行 - 在单行类型周围（C#）
`在类型周围添加空行`	声明中的空行 - 类型周围，可用于： C#、 VB.NET
`在代码块语句之前添加空行`	代码中的空行 - 带子块的语句之前（C#）
`在 case 语句之前添加空行`	代码中的空行 - switch 语句中的 'case' 之前（C#）
`在控制流转移语句之前添加空行`	代码中的空行 - 带控制转移的语句之前（C#）
`在多行语句之前添加空行`	代码中的空行 - 多行语句之前（C#）
`在单行注释之前添加空行`	通用 - 单行注释之前（C#）
`在 using 组之间添加空行`	声明中的空行 - 不同 'using' 组之间（C#）
`在命名空间内部添加空行`	声明中的空行 - 命名空间内（C#）
`在区域内部添加空行`	常规 - 区域内，可用于： C#、 VB.NET
`在类型内部添加空行`	声明中的空行 - 在类型内部（C#）
`大括号样式`	大括号布局样式（通用）
`do-while 使用大括号`	大括号 - 在 'do-while' 语句中（C#）
`fixed 使用大括号`	大括号 - 在 'fixed' 语句中（C#）
`for 使用大括号`	大括号 - 在 'for' 语句中（C#）
`foreach 使用大括号`	大括号 - 在 'foreach' 语句中（C#）
`if-else 使用大括号`	大括号 - 在 'if' 语句中（C#）
`lock 使用大括号`	大括号 - 在 'lock' 语句中（C#）
`using 使用大括号`	大括号 - 在 'using' 语句中（C#）
`while 使用大括号`	大括号 - 在 'while' 语句中（C#）
`删除冗余的大括号`	大括号 - 删除冗余的大括号（C#）
`内置类型应用于本机整数`	内置类型 - 也适用于本机大小的整数类型（C#）
`成员访问时使用内置类型引用样式`	内置类型 - 在成员访问表达式中，优先使用（C#）
`使用内置类型引用样式`	内置类型 - 在局部变量、成员和参数中，优先使用（C#）
`允许使用 global 别名`	引用限定和 'using' 指令 - 允许使用 'global::' 前缀（C#）
`case 代码块使用大括号`	大括号布局 - 'case' 标签下的块，可用于： C#
`构造函数或析构函数体`	代码主体 - 构造函数和析构函数（C#）
`连续缩进倍数`	通用 - 连续行缩进倍数（C#）
`C++ 大括号样式`	大括号布局样式（通用化）
`C++ 逗号后空格`	逗号后空格（通用）
`C++ 逗号前空格`	逗号前空格（通用）
`C++ 方法调用名称与左括号之间的空格`	方法调用括号之前的空格 (通用)
`csharp_accessor_declaration_braces`	大括号布局 - 访问器声明（C#）
`csharp_accessor_owner_body`	代码体 - 属性、索引器和事件 (C#)
`csharp_accessor_owner_declaration_braces`	大括号布局 - 属性声明（C#）
`csharp_add_imports_to_deepest_scope`	引用限定和 'using' 指令 - 将 'using' 指令添加到最深作用域（C#）
`csharp_align_first_arg_by_paren`	对齐多行结构 - 按 '(' 调用参数（C#）
`csharp_align_linq_query`	对齐多行结构 - LINQ 查询（C#）
`csharp_align_multiline_argument`	对齐多行结构 - 调用参数（C#）
`csharp_align_multiline_array_and_object_initializer`	对齐多行结构 - 数组、对象和集合初始化器（C#）
`csharp_align_multiline_binary_expressions_chain`	对齐多行结构 - 二元表达式（C#）
`csharp_align_multiline_binary_patterns`	对齐多行结构 - 二元模式（C#）
`csharp_align_multiline_calls_chain`	对齐多行结构 - 链式方法调用（C#）
`csharp_align_multiline_comments`	对齐多行结构 - 使用星号对齐多行注释（C#）
`csharp_align_multiline_expression`	对齐多行结构 - 其他表达式（C#）
`csharp_align_multiline_extends_list`	对齐多行结构 - 基类和接口列表（C#）
`csharp_align_multiline_for_stmt`	对齐多行结构 - 'for' 语句头部（C#）
`csharp_align_multiline_list_pattern`	对齐多行结构 - 列表模式和集合表达式（C#）
`csharp_align_multiline_parameter`	对齐多行结构 - 方法参数（C#）
`csharp_align_multiline_property_pattern`	对齐多行结构 - 属性模式（C#）
`csharp_align_multiline_statement_conditions`	对齐多行结构 - 括号内的语句条件（C#）
`csharp_align_multiline_switch_expression`	对齐多行结构 - Switch 表达式（C#）
`csharp_align_multiple_declaration`	对齐多行结构 - 多个声明（C#）
`csharp_align_multline_type_parameter_constrains`	对齐多行结构 - 类型参数约束（C#）
`csharp_align_multline_type_parameter_list`	对齐多行结构 - 类型参数列表（C#）
`csharp_align_tuple_components`	对齐多行结构 - 元组组件（C#）
`csharp_alignment_tab_fill_style`	对齐多行结构 - 使用制表符缩进时的对齐方式（C#）
`csharp_allow_alias`	引用限定和 'using' 指令 - 使用 using 别名指令解决冲突（C#）
`csharp_allow_comment_after_lbrace`	大括号布局 - 允许在 '{' 后添加注释（C#）
`csharp_allow_far_alignment`	对齐多行结构 - 即使结果缩进过大也对齐（C#）
`csharp_anonymous_method_declaration_braces`	大括号布局 - Lambda 和委托（匿名方法声明）（C#）
`csharp_arguments_anonymous_function`	参数 - 匿名方法（委托和 lambda 表达式）（C#）
`csharp_arguments_literal`	参数 - 字面值（C#）
`csharp_arguments_named`	参数 - 命名表达式（变量、属性、方法等）（C#）
`csharp_arguments_other`	参数 - 其他（C#）
`csharp_arguments_skip_single`	参数 - 跳过单个参数（C#）
`csharp_arguments_string_literal`	参数 - 字符串字面值（C#）
`csharp_blank_lines_after_block_statements`	代码中的空行 - 在带有子块的语句之后（C#）
`csharp_blank_lines_after_case`	代码中的空行 - 在 switch 语句中的 'case' 之后（C#）
`csharp_blank_lines_after_control_transfer_statements`	代码中的空行 - 在具有控制转移的语句之后 (C#)
`csharp_blank_lines_after_file_scoped_namespace_directive`	声明中的空行 - 在文件范围的命名空间指令之后（C#）
`csharp_blank_lines_after_multiline_statements`	代码中的空行 - 在多行语句之后（C#）
`csharp_blank_lines_after_start_comment`	声明中的空行 - 文件头注释后（C#）
`csharp_blank_lines_after_using_list`	声明中的空行 - 'using' 列表后（C#）
`csharp_blank_lines_around_accessor`	声明中的空行 - 属性/事件访问器周围（C#）
`csharp_blank_lines_around_auto_property`	声明中的空行 - 自动/抽象属性/事件周围（C#）
`csharp_blank_lines_around_block_case_section`	代码中的空行 - 在 switch 语句中带有块的 'case' 部分周围（C#）
`csharp_blank_lines_around_field`	声明中的空行 - 字段周围（C#）
`csharp_blank_lines_around_invocable`	声明中的空行 - 方法周围（C#）
`csharp_blank_lines_around_local_method`	代码中的空行 - 局部函数周围（C#）
`csharp_blank_lines_around_multiline_case_section`	代码中的空行 - 在 switch 语句中多行 'case' 部分周围（C#）
`csharp_blank_lines_around_namespace`	声明中的空行 - 命名空间周围（C#）
`csharp_blank_lines_around_property`	声明中的空行 - 属性/事件周围（C#）
`csharp_blank_lines_around_region`	通用 - 区域周围（C#）
`csharp_blank_lines_around_single_line_accessor`	声明中的空行 - 在单行属性/事件访问器周围（C#）
`csharp_blank_lines_around_single_line_auto_property`	声明中的空行 - 在单行自动/抽象属性/事件周围（C#）
`用于设置是否在单行字段之前和之后插入空行`	声明中的空行 - 在单行字段周围（C#）
`用于设置是否在单行可调用成员之前和之后插入空行`	声明中的空行 - 在单行方法周围（C#）
`用于设置是否在单行本地方法之前和之后插入空行`	代码中的空行 - 单行局部函数周围（C#）
`用于设置是否在单行属性之前和之后插入空行`	声明中的空行 - 单行属性/事件周围（C#）
`用于设置是否在单行类型定义之前和之后插入空行`	声明中的空行 - 单行类型周围（C#）
`用于设置是否在类型定义之前和之后插入空行`	声明中的空行 - 在类型周围（C#）
`用于设置是否在块语句之前插入空行`	代码中的空行 - 在带有子块的语句之前（C#）
`用于设置是否在 case 标签之前插入空行`	代码中的空行 - switch 语句中的 'case' 之前（C#）
`用于设置是否在控制流转移语句之前插入空行`	代码中的空行 - 带控制转移的语句之前（C#）
`用于设置是否在多行语句之前插入空行`	代码中的空行 - 在多行语句之前（C#）
`用于设置是否在单行注释之前插入空行`	通用 - 单行注释之前（C#）
`用于设置是否在 using 指令分组之间插入空行`	声明中的空行 - 不同 'using' 组之间（C#）
`用于设置是否在命名空间内部插入空行`	声明中的空行 - 命名空间内（C#）
`用于设置是否在 #region 块内部插入空行`	通用 - 在区域内部（C#）
`用于设置是否在类型内部插入空行`	声明中的空行 - 在类型内部（C#）
`用于设置大括号的样式`	大括号布局样式（通用化）
`用于设置 do-while 语句是否需要使用大括号`	大括号 - 在 'do-while' 语句中（C#）
`用于设置 fixed 语句是否需要使用大括号`	大括号 - 在 'fixed' 语句中（C#）
`csharp_braces_for_for`	大括号 - 在 'for' 语句中（C#）
`csharp_braces_for_foreach`	大括号 - 在 'foreach' 语句中（C#）
`csharp_braces_for_ifelse`	大括号 - 在 'if' 语句中（C#）
`csharp_braces_for_lock`	大括号 - 在 'lock' 语句中（C#）
`csharp_braces_for_using`	大括号 - 在 'using' 语句中（C#）
`csharp_braces_for_while`	大括号 - 在 'while' 语句中（C#）
`csharp_braces_redundant`	大括号 - 删除冗余的大括号（C#）
`csharp_builtin_type_apply_to_native_integer`	内置类型 - 也适用于本机大小的整数类型（C#）
`csharp_builtin_type_reference_for_member_access_style`	内置类型 - 在成员访问表达式中，优先使用（C#）
`csharp_builtin_type_reference_style`	内置类型 - 在局部变量、成员和参数中，优先使用（C#）
`csharp_can_use_global_alias`	引用限定和 'using' 指令 - 允许使用 'global::' 前缀 (C#)
`csharp_case_block_braces`	大括号布局 - 'case' 标签下的块（C#）
`csharp_constructor_or_destructor_body`	代码体 - 构造函数和析构函数（C#）
`csharp_continuous_indent_multiplier`	通用 - 连续行缩进倍数（C#）
`csharp_default_internal_modifier`	修饰符 - 更倾向于为类型使用显式/隐式 internal 修饰符（C#）
`csharp_default_private_modifier`	修饰符 - 更倾向于为类型成员使用显式/隐式 private 修饰符（C#）
`csharp_default_value_when_type_evident`	默认值 - 当类型从用法中显而易见时（C#）
`csharp_default_value_when_type_not_evident`	默认值 - 当类型从用法中不显而易见时 (C#)
`csharp_empty_block_style`	大括号布局 - 空大括号格式化（C#）
`csharp_extra_spaces`	保留现有格式 - 内部多余空格（C#）
`csharp_for_built_in_types`	声明中 'var' 的使用 - 对于内置类型（C#）
`csharp_for_other_types`	声明中 'var' 的使用 - 其他地方（C#）
`csharp_for_simple_types`	声明中 'var' 的使用 - 对于简单类型（C#）
`csharp_force_attribute_style`	属性 - 合并或分离节中的属性（C#）
`csharp_force_chop_compound_do_expression`	二元表达式的排列 - 强制在 'do' 语句中分割复合条件（C#）
`csharp_force_chop_compound_if_expression`	二元表达式的排列 - 强制在 'if' 语句中分割复合条件（C#）
`csharp_force_chop_compound_while_expression`	二元表达式的排列 - 强制在 'while' 语句中分割复合条件（C#）
`csharp_indent_anonymous_method_block`	对齐多行结构 - 匿名方法体（C#）
`csharp_indent_braces_inside_statement_conditions`	其他缩进 - 在语句条件内缩进大括号（C#）
`csharp_indent_inside_namespace`	大括号布局 - 在命名空间声明内缩进（C#）
`csharp_indent_invocation_pars`	括号 - 缩进方法调用的括号（C#）
`csharp_indent_method_decl_pars`	括号 - 缩进方法声明的括号（C#）
`csharp_indent_nested_fixed_stmt`	嵌套语句 - 缩进嵌套的“fixed”语句（C#）
`csharp_indent_nested_for_stmt`	嵌套语句 - 缩进嵌套的“for”语句（C#）
`csharp_indent_nested_foreach_stmt`	嵌套语句 - 缩进嵌套的 'foreach' 语句（C#）
`csharp_indent_nested_lock_stmt`	嵌套语句 - 缩进嵌套的“lock”语句（C#）
`csharp_indent_nested_usings_stmt`	嵌套语句 - 缩进嵌套的“using”语句（C#）
`csharp_indent_nested_while_stmt`	嵌套语句 - 缩进嵌套的 'while' 语句（C#）
`csharp_indent_pars`	括号 - 缩进其他括号和方括号（C#）
`csharp_indent_preprocessor_if`	预处理指令 - 缩进 #if、#else、#elif、#endif（C#）
`csharp_indent_preprocessor_other`	预处理指令 - 缩进其他预处理指令（C#）
`csharp_indent_preprocessor_region`	预处理指令 - 缩进 #region、#endregion（C#）
`csharp_indent_primary_constructor_decl_pars`	括号 - 主构造函数声明的括号缩进（C#）
`csharp_indent_raw_literal_string`	对齐多行结构 - 如何缩进原始字符串字面量（C#）
`csharp_indent_size`	通用 - 缩进大小 (C#)
`csharp_indent_statement_pars`	括号 - 缩进语句 (if、while、for 等) 的括号 (C#)
`csharp_indent_style`	通用 - 缩进样式 (C#)
`csharp_indent_switch_labels`	其他缩进 - 缩进 'case' 相对于 'switch'（C#）
`csharp_indent_type_constraints`	其他缩进 - 缩进类型约束 (C#)
`csharp_indent_typearg_angles`	括号 - 类型参数的角括号缩进（C#）
`csharp_indent_typeparam_angles`	括号 - 类型参数的角括号缩进（C#）
`csharp_initializer_braces`	大括号布局 - 表达式 (初始化器、switch 表达式、模式、集合表达式) (C#)
`csharp_insert_final_newline`	通用 - 文件末尾的换行符（C#）
`csharp_instance_members_qualify_declared_in`	实例成员限定 - 限定在（C#）中声明的成员
`csharp_instance_members_qualify_members`	实例成员限定 - 对其使用 'this.' 限定符 (C#)
`csharp_int_align`	对齐相似代码到列（通用化）
`csharp_int_align_assignments`	将相似代码对齐到列 - 其他赋值和初始化器（C#）
`csharp_int_align_binary_expressions`	对齐相似代码到列 - 二元表达式（C#）
`csharp_int_align_comments`	对齐相似代码为列 - 结束注释 (C#)
`csharp_int_align_fields`	对齐相似代码为列 - 字段和常量 (C#)
`csharp_int_align_fix_in_adjacent`	对齐相似代码到列 - 修复相邻行的列对齐（C#）
`csharp_int_align_invocations`	将相似代码对齐到列 - 相同方法的调用（C#）
`csharp_int_align_methods`	对齐相似代码为列 - 简单方法、运算符、委托 (C#)
`csharp_int_align_nested_ternary`	对齐相似代码为列 - 嵌套三元运算符 (C#)
`csharp_int_align_parameters`	对齐相似代码为列 - 多行方法签名 (C#)
`csharp_int_align_properties`	对齐相似代码为列 - 属性和事件 (C#)
`csharp_int_align_property_patterns`	对齐相似代码为列 - 属性模式 (C#)
`csharp_int_align_switch_expressions`	对齐相似代码为列 - switch 表达式 (C#)
`csharp_int_align_switch_sections`	对齐相似代码为列 - 简单 switch 部分 (C#)
`csharp_int_align_variables`	对齐相似代码为列 - 变量和局部常量 (C#)
`csharp_invocable_declaration_braces`	大括号布局 - 方法声明（C#）
`csharp_keep_blank_lines_in_code`	代码中的空行 - 保留代码中的最大空行数（C#）
`csharp_keep_blank_lines_in_declarations`	声明中的空行 - 保留声明中的最大空行数（C#）
`csharp_keep_existing_arrangement`	保持现有代码排列（单行/多行）（通用）
`csharp_keep_existing_attribute_arrangement`	属性排列 - 保留现有的属性排列（C#）
`csharp_keep_existing_declaration_block_arrangement`	声明块排列 - 保留声明块的现有排列 (C#)
`csharp_keep_existing_declaration_parens_arrangement`	方法签名排列 - 保持声明中括号的现有排列（C#）
`csharp_keep_existing_embedded_arrangement`	嵌套语句排列 - 保留嵌套语句的现有排列 (C#)
`csharp_keep_existing_embedded_block_arrangement`	嵌套块排列 - 保留嵌套块的现有排列 (C#)
`csharp_keep_existing_enum_arrangement`	枚举排列 - 保留枚举的现有排列 (C#)
`csharp_keep_existing_expr_member_arrangement`	表达式主体成员排列 - 保留现有表达式主体成员排列（C#）
`csharp_keep_existing_initializer_arrangement`	初始化器排列 - 保留初始化器的现有排列 (C#)
`csharp_keep_existing_invocation_parens_arrangement`	调用排列 - 保持调用中括号的现有排列（C#）
`csharp_keep_existing_linebreaks`	通用 - 保留现有换行（C#）
`csharp_keep_existing_list_patterns_arrangement`	列表模式排列 - 保留现有列表模式和集合表达式排列（C#）
`csharp_keep_existing_primary_constructor_declaration_parens_arrangement`	主构造函数签名排列 - 保持声明中括号的现有排列（C#）
`csharp_keep_existing_property_patterns_arrangement`	属性模式排列 - 保留属性模式的现有排列 (C#)
`csharp_keep_existing_switch_expression_arrangement`	switch 表达式排列 - 保留 switch 表达式的现有排列 (C#)
`csharp_keep_user_linebreaks`	通用 - 保留现有的换行（C#）
`csharp_local_function_body`	代码体 - 本地函数（C#）
`csharp_max_array_initializer_elements_on_line`	初始化器的排列 - 单行上的最大数组初始化器和集合表达式元素（C#）
`csharp_max_attribute_length_for_same_line`	属性排列 - 如果属性部分列表过长，则将其放在单独的行上 (C#)
`csharp_max_enum_members_on_line`	枚举排列 - 单行中的最大枚举成员数（C#）
`csharp_max_formal_parameters_on_line`	方法签名排列 - 单行中的最大正式参数数 (C#)
`csharp_max_initializer_elements_on_line`	初始化器排列 - 单行中的最大对象和集合初始化器元素数 (C#)
`csharp_max_invocation_arguments_on_line`	调用排列 - 单行中的最大调用参数数（C#）
`csharp_max_line_length`	通用 - 硬换行位置（C#）
`csharp_max_primary_constructor_parameters_on_line`	主构造函数签名排列 - 单行中的最大主构造函数参数数（C#）
`csharp_method_or_operator_body`	代码体 - 方法和运算符（C#）
`csharp_modifiers_order`	修饰符 - 修饰符顺序（C#）
`csharp_namespace_body`	代码体 - 命名空间（C#）
`csharp_nested_ternary_style`	三元表达式排列 - 嵌套三元表达式样式（C#）
`csharp_new_line_before_catch`	语句排列 - 将 'catch' 放在新行上（C#）
`csharp_new_line_before_else`	语句排列 - 将 'else' 放在新行上（C#）
`csharp_new_line_before_finally`	语句排列 - 将 'finally' 放在新行上（C#）
`csharp_new_line_before_while`	语句排列 - 将 'while' 放在新行上（C#）
`csharp_null_checking_pattern_style`	模式 - 空检查模式样式（C#）
`csharp_object_creation_when_type_evident`	对象创建 - 当创建的类型从用法中显而易见时（C#）
`csharp_object_creation_when_type_not_evident`	对象创建 - 当创建的类型从用法中不显而易见时（C#）
`csharp_old_engine`	ReSharper 其他 - 恢复旧的格式化引擎（C#）
`csharp_other_braces`	大括号布局 - 其他（C#）
`csharp_outdent_binary_ops`	对齐多行结构 - 减少二元操作符的缩进（C#）
`csharp_outdent_binary_pattern_ops`	对齐多行结构 - 减少二元模式的缩进（C#）
`csharp_outdent_commas`	对齐多行结构 - 减少逗号的缩进（C#）
`csharp_outdent_dots`	对齐多行结构 - 减少链式方法调用中点的缩进（C#）
`csharp_outdent_statement_labels`	其他缩进 - 减少语句标签的缩进（C#）
`csharp_parentheses_group_non_obvious_operations`	添加括号以避免不明显的优先级 - 当以下组的操作嵌套时（C#）
`csharp_parentheses_non_obvious_operations`	添加括号以避免不明显的优先级 - 在以下操作的操作数周围（C#）
`csharp_parentheses_redundancy_style`	括号 - 删除多余的括号（C#）
`csharp_parentheses_same_type_operations`	添加括号以避免不明显的优先级 - 即使是同类型操作的嵌套（C#）
`csharp_place_abstract_accessorholder_on_single_line`	声明块的排列 - 将抽象/自动属性/索引器/事件声明放在单行（C#）
`csharp_place_accessor_attribute_on_same_line`	属性的排列 - 将访问器属性放在同一行（C#）
`csharp_place_accessor_with_attrs_holder_on_single_line`	声明块的排列 - 即使访问器上有属性，也将其放在单行（C#）
`csharp_place_accessorholder_attribute_on_same_line`	属性的排列 - 将属性/索引器/事件属性放在同一行（C#）
`csharp_place_attribute_on_same_line`	将简单属性与所有者放在同一行（通用）
`csharp_place_comments_at_first_column`	其他缩进 - 在注释代码时将注释放在第一列 (C#)
`csharp_place_constructor_initializer_on_same_line`	方法签名的排列 - 允许构造函数初始化器放在同一行 (C#)
`csharp_place_expr_accessor_on_single_line`	表达式主体成员的排列 - 将属性访问器表达式主体放在同一行（C#）
`csharp_place_expr_method_on_single_line`	表达式主体成员的排列 - 将方法表达式主体放在同一行（C#）
`csharp_place_expr_property_on_single_line`	表达式主体成员的排列 - 将属性表达式主体放在同一行（C#）
`csharp_place_field_attribute_on_same_line`	属性的排列 - 将字段属性放在同一行（C#）
`csharp_place_linq_into_on_new_line`	LINQ 表达式的排列 - 在 LINQ 表达式中将 'into' 放在新行（C#）
`csharp_place_method_attribute_on_same_line`	属性的排列 - 将方法属性放在同一行（C#）
`csharp_place_record_field_attribute_on_same_line`	属性的排列 - 将记录字段属性放在同一行（C#）
`csharp_place_simple_accessor_on_single_line`	声明块的排列 - 将简单访问器放在单行（C#）
`csharp_place_simple_accessorholder_on_single_line`	声明块的排列 - 将简单属性/索引器/事件声明放在单行（C#）
`csharp_place_simple_anonymousmethod_on_single_line`	嵌套块的排列 - 将简单匿名方法放在单行（C#）
`csharp_place_simple_blocks_on_single_line`	将简单块放在单行（通用）
`csharp_place_simple_case_statement_on_same_line`	嵌套语句的排列 - 将简单 'case' 语句放在同一行（C#）
`csharp_place_simple_declaration_blocks_on_single_line`	将简单类型成员的块放在单行（通用）
`csharp_place_simple_embedded_block_on_same_line`	嵌套块的排列 - 将只有一个简单语句的块放在同一行 (C#)
`csharp_place_simple_embedded_statement_on_same_line`	嵌套语句的排列 - 将简单嵌套语句放在同一行（C#）
`csharp_place_simple_enum_on_single_line`	枚举的排列 - 将简单枚举放在单行（C#）
`csharp_place_simple_initializer_on_single_line`	初始化器的排列 - 将简单数组、对象和集合放在单行（C#）
`csharp_place_simple_list_pattern_on_single_line`	列表模式的排列 - 将简单列表模式和集合表达式放在单行（C#）
`csharp_place_simple_method_on_single_line`	声明块的排列 - 将简单方法放在单行（C#）
`csharp_place_simple_property_pattern_on_single_line`	属性模式的排列 - 将简单属性模式放在单行（C#）
`csharp_place_simple_switch_expression_on_single_line`	切换表达式的排列 - 将简单切换表达式放在单行（C#）
`csharp_place_type_attribute_on_same_line`	属性排列 - 将类型属性放在同一行 (C#)
`csharp_place_type_constraints_on_same_line`	类型参数、约束和基类型的排列 - 允许类型约束放在同一行 (C#)
`csharp_prefer_explicit_discard_declaration`	'var' 声明的使用 - 对于丢弃值使用 'var' 关键字 (C#)
`csharp_prefer_qualified_reference`	引用限定和 'using' 指令 - 优先使用完全限定的引用 (C#)
`csharp_prefer_separate_deconstructed_variables_declaration`	'var' 声明的使用 - 对解构变量优先使用单独的声明 (C#)
`csharp_qualified_using_at_nested_scope`	引用限定和 'using' 指令 - 在嵌套作用域中优先使用完全限定的 'using' 名称 (C#)
`csharp_remove_blank_lines_near_braces_in_code`	代码中的空行 - 移除代码中 '{' 后和 '}' 前的空行 (C#)
`csharp_remove_blank_lines_near_braces_in_declarations`	声明中的空行 - 移除声明中 '{' 后和 '}' 前的空行 (C#)
`csharp_sort_usings_with_system_first`	引用限定和 'using' 指令 - 排序 'using' 指令时优先放置 'System.' 和 'Windows.' 命名空间（C#）
`csharp_space_after_ampersand_op`	一元运算符后 - 不安全的取地址运算符 (&)（C#）
`csharp_space_after_asterik_op`	一元运算符后 - 不安全的星号运算符 (*)（C#）
`csharp_space_after_attribute_colon`	围绕冒号 - 在其他冒号之后 (C#)
`csharp_space_after_attributes`	属性 - 属性后（C#）
`csharp_space_after_cast`	其他 - 类型转换括号后 (C#)
`csharp_space_after_colon`	围绕冒号 - 在其他冒号之后 (C#)
`csharp_space_after_colon_in_case`	围绕冒号 - 在 'case' 语句中的冒号之后 (C#)
`csharp_space_after_colon_in_inheritance_clause`	冒号周围 - 基类型列表冒号后 (C#)
`csharp_space_after_comma`	逗号和分号周围 - 逗号后 (C#)
`csharp_space_after_keywords_in_control_flow_statements`	控制流语句括号前空格（通用）
`csharp_space_after_logical_not_op`	一元运算符后 - 逻辑非运算符 (!)（C#）
`csharp_space_after_operator_keyword`	其他 - 运算符关键字后 (C#)
`csharp_space_after_semicolon_in_for_statement`	逗号和分号周围 - 'for' 分号后 (C#)
`csharp_space_after_ternary_colon`	在三元运算符中 - 在 ':' 之后 (C#)
`csharp_space_after_ternary_quest`	在三元运算符中 - 在 '?' 之后 (C#)
`csharp_space_after_type_parameter_constraint_colon`	围绕冒号 - 在类型参数约束冒号之后 (C#)
`csharp_space_after_unary_minus_op`	一元运算符后 - 一元减号运算符 (-)（C#）
`csharp_space_after_unary_operator`	一元运算符后空格 (!, -, ~,...)（通用）
`csharp_space_after_unary_plus_op`	一元运算符后 - 一元加号运算符 (+)（C#）
`csharp_space_around_additive_op`	围绕二元运算符 - 加法运算符 (+,-) (C#)
`csharp_space_around_alias_eq`	其他 - 命名空间别名指令中的 '=' 周围 (C#)
`csharp_space_around_arrow_op`	二元运算符周围 - 不安全箭头运算符（->）（C#）
`csharp_space_around_assignment_op`	围绕二元运算符 - 赋值运算符 (如 '=' 和 '+=') (C#)
`csharp_space_around_binary_operator`	在二元运算符周围的空格（+，\|\|，=，...）（通用）
`csharp_space_around_bitwise_op`	在二元运算符周围 - 按位运算符（&，\|，^）（C#）
`csharp_space_around_dot`	其他 - 在点号周围 (C#)
`csharp_space_around_equality_op`	在二元运算符周围 - 相等运算符（==，!=）（C#）
`csharp_space_around_lambda_arrow`	其他 - Lambda 箭头周围（C#）
`csharp_space_around_logical_op`	二元运算符周围 - 逻辑运算符（&&、\|\|）（C#）
`csharp_space_around_member_access_operator`	在成员访问运算符周围的空格（.，->，...）（通用）
`csharp_space_around_multiplicative_op`	围绕二元运算符 - 乘法运算符 (*,/,%) (C#)
`csharp_space_around_nullcoalescing_op`	二元运算符周围 - 空合运算符（??）（C#）
`csharp_space_around_relational_op`	围绕二元运算符 - 关系运算符 (<,>,<=,>=) (C#)
`csharp_space_around_shift_op`	围绕二元运算符 - 移位运算符 (<<,>>,>>>) (C#)
`csharp_space_around_ternary_operator`	在三元运算符（?，:）周围的空格（通用）
`csharp_space_before_array_access_brackets`	围绕数组括号 - 在数组访问括号之前 (C#)
`csharp_space_before_array_rank_brackets`	数组括号周围 - 数组维度括号前（C#）
`csharp_space_before_attribute_colon`	冒号周围 - 其他冒号前（C#）
`csharp_space_before_catch_parentheses`	语句中的括号前 - 'catch' 括号（C#）
`csharp_space_before_checked_parentheses`	其他括号前 - 'checked' 和 'unchecked' 括号（C#）
`csharp_space_before_colon`	冒号周围 - 其他冒号前（C#）
`csharp_space_before_colon_in_case`	围绕冒号 - 在 'case' 语句中的冒号之前 (C#)
`csharp_space_before_colon_in_inheritance_clause`	冒号周围 - 基类型列表冒号前 (C#)
`csharp_space_before_comma`	逗号和分号周围 - 逗号前 (C#)
`csharp_space_before_default_parentheses`	在其他括号之前 - 'default' 括号 (C#)
`csharp_space_before_empty_method_call_parentheses`	在其他括号之前 - 方法调用空括号 (C#)
`csharp_space_before_empty_method_parentheses`	在其他括号之前 - 方法声明空括号 (C#)
`csharp_space_before_fixed_parentheses`	在语句中的括号之前 - 'fixed' 括号（C#）
`csharp_space_before_for_parentheses`	在语句中的括号之前 - 'for' 括号 (C#)
`csharp_space_before_foreach_parentheses`	在语句中的括号之前 - 'foreach' 括号（C#）
`csharp_space_before_if_parentheses`	在语句中的括号之前 - 'if' 括号（C#）
`csharp_space_before_lock_parentheses`	在语句中的括号之前 - 'lock' 括号（C#）
`csharp_space_before_method_call_parentheses`	在其他括号之前 - 方法调用括号 (C#)
`csharp_space_before_method_parentheses`	在其他括号之前 - 方法声明括号 (C#)
`csharp_space_before_nameof_parentheses`	在其他括号之前 - 'nameof' 括号 (C#)
`csharp_space_before_new_parentheses`	在其他括号之前 - 'new' 括号 (C#)
`csharp_space_before_nullable_mark`	其他 - 在可空标记之前 (C#)
`csharp_space_before_open_square_brackets`	括号前的空格（通用）
`csharp_space_before_pointer_asterik_declaration`	其他 - 在不安全指针声明之前 (C#)
`csharp_space_before_semicolon`	围绕逗号和分号 - 在分号之前 (C#)
`csharp_space_before_semicolon_in_for_statement`	逗号和分号周围 - 'for' 分号前 (C#)
`csharp_space_before_singleline_accessorholder`	围绕大括号 - 在单行访问器块之前 (C#)
`csharp_space_before_sizeof_parentheses`	在其他括号之前 - 'sizeof' 括号 (C#)
`csharp_space_before_switch_parentheses`	语句中括号之前 - 'switch' 括号（C#）
`csharp_space_before_ternary_colon`	三元运算符中 - ':' 之前（C#）
`csharp_space_before_ternary_quest`	三元运算符中 - '?' 之前（C#）
`csharp_space_before_trailing_comment`	其他 - 行尾注释之前（C#）
`csharp_space_before_type_argument_angle`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`csharp_space_before_type_parameter_angle`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`csharp_space_before_type_parameter_constraint_colon`	冒号周围 - 类型参数约束冒号之前（C#）
`csharp_space_before_typeof_parentheses`	其他括号之前 - 'typeof' 括号（C#）
`csharp_space_before_using_parentheses`	语句中括号之前 - 'using' 括号（C#）
`csharp_space_before_while_parentheses`	语句中括号之前 - 'while' 括号（C#）
`csharp_space_between_accessors_in_singleline_property`	大括号周围 - 在单行属性/事件访问器之间 (C#)
`csharp_space_between_attribute_sections`	属性 - 在属性部分之间 (C#)
`csharp_space_between_empty_square_brackets`	数组括号周围 - 在空数组维度括号内（C#）
`csharp_space_between_keyword_and_expression`	其他括号之前 - 关键字和表达式之间（C#）
`csharp_space_between_keyword_and_type`	其他括号之前 - 关键字和类型之间（C#）
`csharp_space_between_method_call_empty_parameter_list_parentheses`	其他括号内 - 方法调用空括号 (C#)
`csharp_space_between_method_call_name_and_opening_parenthesis`	方法调用括号之前的空格 (通用)
`csharp_space_between_method_call_parameter_list_parentheses`	其他括号内 - 方法调用括号 (C#)
`csharp_space_between_method_declaration_empty_parameter_list_parentheses`	其他括号内 - 方法声明空括号 (C#)
`csharp_space_between_method_declaration_name_and_open_parenthesis`	方法声明括号之前的空格 (通用)
`csharp_space_between_method_declaration_parameter_list_parentheses`	其他括号内 - 方法声明括号 (C#)
`csharp_space_between_parentheses_of_control_flow_statements`	控制流语句括号内的空格（通用）
`csharp_space_between_square_brackets`	括号内的空格（通用）
`csharp_space_between_typecast_parentheses`	其他括号内 - 类型转换括号（C#）
`csharp_space_in_singleline_accessorholder`	大括号周围 - 在单行访问器内 (C#)
`csharp_space_in_singleline_anonymous_method`	大括号周围 - 在单行匿名方法内 (C#)
`csharp_space_in_singleline_method`	大括号周围 - 在单行方法内 (C#)
`csharp_space_near_postfix_and_prefix_op`	一元运算符之后 - ++ 和 -- 之前/之后（C#）
`csharp_space_within_array_access_brackets`	数组括号周围 - 数组访问括号内（C#）
`csharp_space_within_array_rank_brackets`	数组括号周围 - 在数组维度括号内 (C#)
`csharp_space_within_array_rank_empty_brackets`	数组括号周围 - 在空数组维度括号内（C#）
`csharp_space_within_attribute_brackets`	属性 - 属性括号内（C#）
`csharp_space_within_catch_parentheses`	语句中括号内 - 'catch' 括号（C#）
`csharp_space_within_checked_parentheses`	其他括号内 - 'checked' 和 'unchecked' 括号（C#）
`csharp_space_within_default_parentheses`	其他括号内 - 'default' 括号 (C#)
`csharp_space_within_empty_braces`	大括号周围 - 空大括号之间的空格（C#）
`csharp_space_within_fixed_parentheses`	语句中括号内 - 'fixed' 括号（C#）
`csharp_space_within_for_parentheses`	语句中的括号内 - 'for' 括号 (C#)
`csharp_space_within_foreach_parentheses`	语句中的括号内 - 'foreach' 括号 (C#)
`csharp_space_within_if_parentheses`	语句中的括号 - 'if' 括号 (C#)
`csharp_space_within_list_pattern_brackets`	数组括号周围 - 列表模式和集合表达式括号内（C#）
`csharp_space_within_lock_parentheses`	语句中的括号 - 'lock' 括号 (C#)
`csharp_space_within_nameof_parentheses`	其他括号内 - 'nameof' 括号（C#）
`csharp_space_within_new_parentheses`	其他括号内 - 'new' 括号（C#）
`csharp_space_within_parentheses`	其他括号内 - 括号（C#）
`csharp_space_within_single_line_array_initializer_braces`	大括号周围 - 单行表达式大括号内（C#）
`csharp_space_within_sizeof_parentheses`	其他括号内 - 'sizeof' 括号（C#）
`csharp_space_within_slice_pattern`	其他 - 切片模式中 '..' 之后（C#）
`csharp_space_within_switch_parentheses`	语句中括号内 - 'switch' 括号（C#）
`csharp_space_within_type_argument_angles`	尖括号周围 - 类型参数尖括号（C#）
`csharp_space_within_type_parameter_angles`	尖括号周围 - 类型形参尖括号（C#）
`csharp_space_within_typeof_parentheses`	其他括号内 - 'typeof' 括号（C#）
`csharp_space_within_using_parentheses`	语句中括号内 - 'using' 括号（C#）
`csharp_space_within_while_parentheses`	语句中括号内 - 'while' 括号（C#）
`csharp_special_else_if_treatment`	通用 - 特殊的 'else if' 处理（C#）
`csharp_static_members_qualify_members`	静态成员限定 - 需要限定的成员（C#）
`csharp_static_members_qualify_with`	静态成员限定 - 使用名称限定（C#）
`csharp_stick_comment`	其他缩进 - 不缩进从第一列开始的注释（C#）
`csharp_tab_width`	常规 - 制表符宽度 (C#)
`csharp_trailing_comma_in_multiline_lists`	尾随逗号 - 多行列表中新行前 (C#)
`csharp_trailing_comma_in_singleline_lists`	尾随逗号 - 当最后一个元素后没有新行时 (C#)
`csharp_type_declaration_braces`	大括号布局 - 类型和命名空间声明 (C#)
`csharp_use_continuous_indent_inside_initializer_braces`	大括号布局 - 在表达式大括号内使用连续行缩进（C#）
`csharp_use_continuous_indent_inside_parens`	括号 - 在括号内使用连续行缩进（C#）
`csharp_use_heuristics_for_body_style`	代码主体 - 应用样式启发式规则 (C#)
`csharp_use_indent_from_previous_element`	其他缩进 - 在部分格式中使用前一个元素的缩进 (C#)
`csharp_use_roslyn_logic_for_evident_types`	声明中 'var' 的使用 - 偏好 Roslyn (Visual Studio) 的类型推断逻辑 (C#)
`csharp_wrap_after_declaration_lpar`	方法签名的排列 - 偏好在声明中 '(' 后换行 (C#)
`csharp_wrap_after_dot_in_method_calls`	成员访问表达式排列 - 优先在 '.' 后换行 (C#)
`csharp_wrap_after_invocation_lpar`	调用的排列 - 偏好在调用中 '(' 后换行 (C#)
`csharp_wrap_after_primary_constructor_declaration_lpar`	主构造函数签名排列 - 优先在声明中的 '(' 后换行 (C#)
`csharp_wrap_after_property_in_chained_method_calls`	成员访问表达式排列 - 优先在链式方法调用中的属性和字段后换行 (C#)
`用于设置参数换行样式`	调用的排列 - 换行调用参数 (C#)
`用于设置数组初始值设定项的换行样式`	初始化器排列 - 换行数组初始化器 (C#)
`用于设置箭头表达式之前是否换行`	表达式主体成员排列 - 优先在 '=>' 前换行并跟随表达式 (C#)
`用于设置二元操作符前是否换行`	二元表达式的排列 - 偏好在二元表达式中的运算符前换行 (C#)
`用于设置在二元模式操作符前是否换行`	二元表达式排列 - 优先在二元模式中的运算符前换行 (C#)
`用于设置逗号之前是否换行`	常规 - 更倾向于在 ',' 前换行 (C#)
`用于设置声明左括号之前是否换行`	方法签名的排列 - 偏好在声明中 '(' 前换行 (C#)
`用于设置声明右括号之前是否换行`	方法签名的排列 - 偏好在声明中 ')' 前换行 (C#)
`用于设置等号前是否换行`	通用 - 优先在 '=' 前换行（C#）
`用于设置继承冒号前是否换行`	类型参数、约束和基类型排列 - 优先在 ':' 前换行 (C#)
`用于设置首次方法调用前是否换行`	成员访问表达式排列 - 优先在第一个方法调用前换行 (C#)
`用于设置首次类型参数约束前是否换行`	类型参数、约束和基类型的排列 - 偏好在第一个约束前换行 (C#)
`用于设置调用左括号前是否换行`	调用的排列 - 偏好在调用中 '(' 前换行 (C#)
`用于设置调用右括号前是否换行`	调用的排列 - 偏好在调用中 ')' 前换行 (C#)
`用于设置 LINQ 表达式前是否换行`	LINQ 表达式排列 - 优先在多行 LINQ 表达式前换行 (C#)
`用于设置主构造函数声明左括号前是否换行`	主构造函数签名排列 - 优先在声明中的 '(' 前换行 (C#)
`用于设置主构造函数声明右括号前是否换行`	主构造函数签名排列 - 优先在声明中的 ')' 前换行 (C#)
`用于设置三目运算符符号前是否换行`	三元表达式的排列 - 偏好在三元表达式中的 '?' 和 ':' 前换行 (C#)
`用于设置类型参数左尖括号前是否换行`	类型参数、约束和基类型排列 - 优先在类型参数列表中的开尖括号前换行 (C#)
`用于设置是否换行链式二元表达式`	二元表达式的排列 - 换行链式二元表达式 (C#)
`用于设置是否换行链式二元模式`	二元表达式排列 - 换行复杂的二元模式 (C#)
`用于设置是否换行链式方法调用`	成员访问表达式的排列 - 换行链式方法调用 (C#)
`用于设置枚举声明换行样式`	枚举排列 - 换行枚举声明 (C#)
`用于设置继承列表换行样式`	类型参数、约束和基类型的排列 - 换行扩展/实现列表 (C#)
`用于设置 for 语句头部换行样式`	语句的排列 - 换行 'for' 语句头部 (C#)
`用于设置 LINQ 表达式整体换行样式`	LINQ 表达式排列 - 换行 LINQ 表达式 (C#)
`用于设置列表模式的换行样式`	列表模式排列 - 换行列表模式和集合表达式 (C#)
`用于设置多个声明的换行样式`	语句的排列 - 换行多重声明 (C#)
`用于设置多个类型参数约束的换行样式`	类型参数、约束和基类型的排列 - 换行多重类型参数约束 (C#)
`用于设置对象和集合初始值设定项的换行样式`	初始化器排列 - 换行对象和集合初始化器 (C#)
`用于设置参数的换行样式`	方法签名的排列 - 换行形式参数 (C#)
`用于设置主构造函数的参数换行样式`	主构造函数签名排列 - 换行主构造函数参数 (C#)
`用于设置属性模式的换行样式`	属性模式排列 - 换行属性模式 (C#)
`用于设置 switch 表达式的换行样式`	切换表达式排列 - 换行切换表达式 (C#)
`用于设置三元表达式的换行样式`	三元表达式的排列 - 换行三元表达式 (C#)
`用于设置逐字插值字符串的换行样式`	插值字符串的排列 - 换行插值字符串（C#）
`用于设置内部修饰符的默认值`	修饰符 - 更倾向于为类型使用显式/隐式 internal 修饰符（C#）
`用于设置私有修饰符的默认值`	修饰符 - 更倾向于为类型成员使用显式/隐式 private 修饰符（C#）
`当类型明显时用于设置是否使用默认值表达方式`	默认值 - 当类型从用法中显而易见时（C#）
`当类型不明显时用于设置是否使用默认值表达方式`	默认值 - 当类型从用法中不显而易见时 (C#)
`dotnet_sort_system_directives_first`	引用限定和 'using' 指令 - 排序 'using' 指令时优先放置 'System.' 和 'Windows.' 命名空间 (C#)
`empty_block_style`	大括号布局 - 空大括号格式化，可用于： C#
`extra_spaces`	保留现有格式 - 内部的额外空格，适用于： C#
`for_built_in_types`	声明中 'var' 的使用 - 对于内置类型（C#）
`for_other_types`	声明中 'var' 的使用 - 其他地方（C#）
`for_simple_types`	声明中 'var' 的使用 - 对于简单类型（C#）
`force_attribute_style`	属性 - 在部分中合并或分离属性（C#）
`force_chop_compound_do_expression`	二元表达式的排列 - 强制在 'do' 语句中分割复合条件（C#）
`force_chop_compound_if_expression`	二元表达式的排列 - 强制在 'if' 语句中分割复合条件（C#）
`force_chop_compound_while_expression`	二元表达式的排列 - 强制在 'while' 语句中分割复合条件（C#）
`html_blank_lines_around_razor_functions`	Razor @functions 块周围的空行（Razor CSharp）
`html_blank_lines_around_razor_helpers`	Razor 助手周围的空行（Razor CSharp）
`html_blank_lines_around_razor_sections`	Razor 区段周围的空行 (Razor CSharp)
`html_linebreaks_around_razor_statements`	Razor 语句周围的换行 (Razor CSharp)
`html_use_old_engine`	为 Razor 格式化使用旧引擎（Razor CSharp）
`indent_anonymous_method_block`	对齐多行结构 - 匿名方法体（C#）
`indent_braces_inside_statement_conditions`	其他缩进 - 在语句条件内缩进大括号（C#）
`indent_case_from_select`	其他 - 将“case”缩进到“select”（VB.NET）
`indent_child_elements`	标签内容 - 在不包含文本的元素内缩进，可用于：
`indent_inside_namespace`	大括号布局 - 在命名空间声明内缩进（C#）
`indent_invocation_pars`	括号 - 方法调用的括号缩进，可用于： C#
`缩进方法声明参数`	括号 - 方法声明的括号缩进，可用于： C#
`缩进嵌套 fixed 语句`	嵌套语句 - 缩进嵌套的 'fixed' 语句（C#）
`缩进嵌套 for 语句`	嵌套语句 - 缩进嵌套的“for”语句（C#）
`缩进嵌套 foreach 语句`	嵌套语句 - 缩进嵌套的“foreach”语句（C#）
`缩进嵌套 lock 语句`	嵌套语句 - 缩进嵌套的“lock”语句（C#）
`缩进嵌套 using 语句`	嵌套语句 - 缩进嵌套的 'using' 语句（C#）
`缩进嵌套 while 语句`	嵌套语句 - 缩进嵌套的“while”语句（C#）
`缩进参数`	括号 - 其他括号和方括号的缩进，可用于： C#
`缩进预处理器 if 指令`	预处理指令 - 缩进 #if、#else、#elif、#endif（C#）
`缩进其他预处理器指令`	预处理指令 - 缩进其他预处理指令（C#）
`缩进预处理器 region 指令`	预处理指令 - 缩进 #region、#endregion（C#）
`缩进主构造函数声明参数`	括号 - 主构造函数声明的括号缩进（C#）
`缩进原始字面值字符串`	对齐多行结构 - 如何缩进原始字符串字面量（C#）
`indent_size`	通用 - 缩进大小，可用于： C#、 ShaderLab、 VB.NET
`缩进语句参数`	括号 - 语句（if、while、for 等）的括号缩进，可用于： C#
`indent_style`	常规 - 缩进样式，可用于： C#、 ShaderLab、 VB.NET
`缩进 switch 标签`	其他缩进 - 从“switch”缩进“case”，可用于： C#
`缩进文本`	标签内容 - 在包含文本的元素内缩进，可用于：
`缩进类型约束`	其他缩进 - 类型约束的缩进，可用于： C#
`缩进类型参数尖括号`	括号 - 类型参数的角括号缩进（C#）
`缩进类型形参尖括号`	括号 - 类型参数的角括号缩进（C#）
`初始化器大括号`	大括号布局 - 表达式（初始化器、switch 表达式、模式、集合表达式）（C#）
`插入文件末尾换行符`	常规 - 文件末尾换行，可用于： C#
`限定声明中实例成员所属类型`	实例成员限定 - 限定在（C#）中声明的成员
`限定实例成员所属类型`	实例成员限定 - 对其使用 'this.' 限定符 (C#)
`内部对齐`	对齐相似代码到列（通用化）
`对齐赋值语句`	将相似代码对齐到列 - 其他赋值和初始化器（C#）
`对齐二进制表达式`	对齐相似代码到列 - 二元表达式（C#）
`对齐注释`	将相似代码对齐到列 - 结束注释，可用于： C#
`对齐字段`	将相似代码对齐到列 - 字段和常量（C#）
`在相邻行中修复对齐`	将相似代码对齐到列 - 修复相邻行的列对齐，可用于： C#
`对齐调用`	对齐相似代码为列 - 相同方法的调用 (C#)
`对齐方法`	将相似代码对齐到列 - 简单方法、运算符、委托（C#）
`对齐嵌套三元表达式`	对齐相似代码为列 - 嵌套三元运算符 (C#)
`对齐参数`	将相似代码对齐到列 - 多行方法签名（C#）
`对齐属性`	对齐相似代码为列 - 属性和事件 (C#)
`对齐属性模式`	对齐相似代码为列 - 属性模式 (C#)
`对齐 switch 表达式`	将相似代码对齐到列 - Switch 表达式（C#）
`对齐 switch 分段`	对齐相似代码为列 - 简单 switch 部分 (C#)
`对齐变量`	对齐相似代码为列 - 变量和局部常量 (C#)
`可调用声明的大括号`	大括号布局 - 方法声明，可用于： C#
`JavaScript 大括号样式`	大括号布局样式（通用）
`JavaScript 调用方法名与左括号之间添加空格`	方法调用括号之前的空格 (通用)
`JavaScript 方法声明名与左括号之间添加空格`	方法声明括号之前的空格 (通用)
`JavaScript 中方括号间添加空格`	括号内的空格（通用）
`保留声明之间的空行`	空行 - 声明之间的最大空行数，适用于：
`保留代码中的空行`	代码中的空行 - 保持代码中的最大空行数，适用于： C#、 VB.NET
`保留声明中的空行`	声明中的空行 - 保持声明中的最大空行数，适用于： C#、 VB.NET
`保留现有排列顺序`	保持现有代码排列（单行/多行）（通用）
`保留现有属性排列顺序`	属性排列 - 保留现有属性排列（C#）
`保留现有声明块排列顺序`	声明块排列 - 保留声明块的现有排列 (C#)
`保留现有声明括号排列顺序`	方法签名排列 - 保持声明中括号的现有排列（C#）
`保留现有嵌套结构排列顺序`	嵌套语句排列 - 保留嵌套语句的现有排列 (C#)
`保留现有嵌套块排列顺序`	嵌套块排列 - 保留嵌套块的现有排列 (C#)
`保留现有枚举排列顺序`	枚举排列 - 保留枚举的现有排列 (C#)
`保留现有表达成员排列顺序`	表达式主体成员排列 - 保留现有表达式主体成员排列 (C#)
`保留现有初始化器排列顺序`	初始化器排列 - 保留现有初始化器排列（C#）
`保留现有调用括号排列顺序`	调用排列 - 保持调用中括号的现有排列（C#）
`保留现有换行符`	通用 - 保留现有换行（C#）
`保留现有列表模式排列顺序`	列表模式排列 - 保留现有列表模式和集合表达式排列（C#）
`保留现有主构造函数声明括号排列顺序`	主构造函数签名排列 - 保持声明中括号的现有排列（C#）
`保留现有属性模式排列顺序`	属性模式排列 - 保留属性模式的现有排列 (C#)
`保留现有 switch 表达式排列顺序`	switch 表达式排列 - 保留 switch 表达式的现有排列 (C#)
`保留用户换行符`	通用 - 保持现有换行，适用于： C#、 VB.NET
`元素前换行`	标签周围 - 将以下元素放在新行，适用于：
`多行元素前换行`	标签周围 - 将多行元素放在新行，适用于：
`单行元素前换行`	标签周围 - 将单行元素放在新行，适用于：
`Razor 语句前后换行`	Razor 语句周围的换行 (Razor CSharp)
`为长于指定长度的元素在标签内换行`	标签内容 - 当元素长度超过时，在起始标签后和结束标签前换行，适用于：
`含子元素的元素在标签内换行`	标签周围 - 在包含其他元素且无文本的元素中，在起始标签后和结束标签前换行，适用于：
`多行元素在标签内换行`	标签周围 - 在多行元素中，在起始标签后和结束标签前换行，可用于：
`局部函数体`	代码体 - 本地函数（C#）
`每行最多数组初始化元素数`	初始化器排列 - 单行中的最大数组初始化器和集合表达式元素数（C#）
`同一行允许的最大属性长度`	属性排列 - 如果属性部分列表过长，则将其放在单独的行上 (C#)
`标签之间允许的最大空行数`	标签周围 - 标签之间的最大空行数，适用于：
`每行最多枚举成员数`	枚举排列 - 单行中的最大枚举成员数 (C#)
`每行最多形式参数数`	方法签名排列 - 单行中的最大正式参数数 (C#)
`每行最多初始化器元素数`	初始化器排列 - 单行中的最大对象和集合初始化器元素数（C#）
`每行最多调用参数数`	调用排列 - 单行中的最大调用参数数（C#）
`最大行长度`	通用 - 在以下位置硬换行： C#， VB.NET
`每行最多主构造函数参数数`	主构造函数签名排列 - 单行中的最大主构造函数参数数（C#）
`方法或运算符体`	代码体 - 方法和运算符（C#）
`修饰符顺序`	修饰符 - 修饰符顺序（C#）
`命名空间体`	代码主体 - 命名空间（C#）
`嵌套三元表达式样式`	三元表达式的排列 - 嵌套三元表达式样式（C#）
`catch 前换行`	语句的排列 - 将 'catch' 放在新行上，可用于： C#
`else 前换行`	语句的排列 - 将 'else' 放在新行上，可用于： C#
`finally 前换行`	语句的排列 - 将 'finally' 放在新行上，可用于： C#
`while 前换行`	语句的排列 - 将 'while' 放在新行上，可用于： C#
`空检查模式样式`	模式 - 空检查模式样式（C#）
`类型显然时对象创建方式`	对象创建 - 当创建的类型从用法中显而易见时（C#）
`类型不明显时对象创建方式`	对象创建 - 当创建的类型从用法中不显而易见时（C#）
`旧引擎`	ReSharper 其他 - 恢复旧的格式化引擎（C#）
`其他大括号`	大括号布局 - 其他，可用于： C#
`反缩进二元运算符`	对齐多行结构 - 减少二元操作符的缩进（C#）
`反缩进模式中的二元运算符`	对齐多行结构 - 减少二元模式的缩进（C#）
`反缩进逗号`	对齐多行结构 - 减少逗号的缩进，可用于： C#
`反缩进点号`	对齐多行结构 - 减少链式方法调用中点的缩进，可用于： C#
`反缩进语句标签`	其他缩进 - 减少语句标签的缩进（C#）
`使用括号集中非显而易见运算`	添加括号以避免不明显的优先级 - 当以下组的操作嵌套时（C#）
`非显而易见运算使用括号`	添加括号以避免不明显的优先级 - 在以下操作的操作数周围（C#）
`括号冗余样式`	括号 - 删除多余的括号（C#）
`相同类型运算使用括号`	添加括号以避免不明显的优先级 - 即使是同类型操作的嵌套（C#）
`处理指令属性样式`	处理指令 - 属性格式，可用于：
`处理指令属性缩进`	处理指令 - 属性缩进，可用于：
`将抽象访问器持有者放在同一行`	声明块的排列 - 将抽象/自动属性/索引器/事件声明放在单行上（C#）
`将访问器属性放在同一行`	属性的排列 - 将访问器属性放在同一行（C#）
`将带属性的访问器持有者放在同一行`	声明块的排列 - 即使访问器上有属性，也将其放在单行（C#）
`将访问器持有者属性放在同一行`	属性的排列 - 将属性/索引器/事件属性放在同一行（C#）
`将属性放在同一行`	将简单属性与所有者放在同一行（通用）
`将注释放在第一列`	其他缩进 - 注释代码时将注释放在第一列，可用于： C#
`将构造函数初始化器放在同一行`	方法签名的排列 - 允许构造函数初始化器在同一行（C#）
`将事件属性放在同一行`	属性 - 将事件属性放在同一行 (VB.NET)
`将表达访问器放在同一行`	表达式主体成员的排列 - 将属性访问器表达式主体放在同一行（C#）
`将表达方法放在同一行`	表达式主体成员的排列 - 将方法表达式主体放在同一行（C#）
`将表达属性放在同一行`	表达式主体成员的排列 - 将属性表达式主体放在同一行（C#）
`将字段属性放在同一行`	属性的排列 - 将字段属性放在同一行（C#）
`为 LINQ into 放置新行`	LINQ 表达式的排列 - 在 LINQ 表达式中将 'into' 放在新行（C#）
`将方法属性放在同一行`	属性的排列 - 将方法属性放在同一行（C#）
`将属性的特性放在同一行`	属性 - 将属性的属性放在同一行 (VB.NET)
`将记录字段的特性放在同一行`	属性的排列 - 将记录字段属性放在同一行（C#）
`将简单访问器放在单行上`	声明块的排列 - 将简单访问器放在单行（C#）
`将简单访问器持有者放在单行上`	声明块的排列 - 将简单属性/索引器/事件声明放在单行（C#）
`将简单匿名方法放在单行上`	嵌套块的排列 - 将简单匿名方法放在单行（C#）
`将简单代码块放在单行上`	将简单块放在单行（通用）
`将简单 case 语句放在同一行`	嵌套语句的排列 - 将简单 'case' 语句放在同一行（C#）
`将简单声明块放在单行上`	将简单类型成员的块放在单行（通用）
`将简单嵌入块放在同一行`	嵌套块的排列 - 将包含单个简单语句的块放在同一行（C#）
`将简单嵌入语句放在同一行`	嵌套语句的排列 - 将简单嵌套语句放在同一行（C#）
`将简单枚举放在单行上`	枚举的排列 - 将简单枚举放在单行（C#）
`将简单初始化器放在单行上`	初始化器的排列 - 将简单数组、对象和集合放在单行（C#）
`将简单列表模式放在单行上`	列表模式的排列 - 将简单列表模式和集合表达式放在单行（C#）
`将简单方法放在单行上`	声明块的排列 - 将简单方法放在单行（C#）
`将简单属性模式放在单行上`	属性模式的排列 - 将简单属性模式放在单行（C#）
`将简单 switch 表达式放在单行上`	切换表达式的排列 - 将简单切换表达式放在单行（C#）
`将类型的特性放在同一行`	属性排列 - 将类型属性放在同一行 (C#)
`将类型约束放在同一行`	类型参数、约束和基类型的排列 - 允许类型约束在同一行，可用于： C#
`偏好使用显式丢弃声明`	'var' 声明的使用 - 对丢弃值使用 'var' 关键字 (C#)
`偏好使用限定引用`	引用限定和 'using' 指令 - 优先使用完全限定的引用，可用于： C#、 Razor CSharp、 VB.NET
`偏好分别声明解构变量`	'var' 在声明中的使用 - 对解构变量优先使用单独声明 (C#)
`protobuf 大括号样式`	大括号布局样式（通用化）
`在嵌套作用域中使用限定 using`	引用限定和 'using' 指令 - 在嵌套作用域中优先使用完全限定的 'using' 名称 (C#)
`引号样式`	引号 - 引号样式，可用于：
`Razor 始终使用行尾大括号样式`	为 C# 覆盖大括号样式以始终使用 '行尾 (K&R 样式)'（Razor CSharp）
`Razor 偏好使用限定引用`	为 @inherits 和 @model 指令使用完全限定的名称 (Razor CSharp)
`Razor 删除大括号附近的空行`	在 @functions (Razor CSharp) 中删除 '{' 后和 '}' 前的空行
`Razor 移除 this 限定符`	始终删除 'this.' 限定符 (覆盖相应的 C# 设置) (Razor CSharp)
`删除大括号附近的空行`	在 @functions (Razor CSharp) 中删除 '{' 后和 '}' 前的空行
`删除代码中大括号附近的空行`	代码中的空行 - 删除代码中 '{' 后和 '}' 前的空行，适用于： C#
`删除声明中大括号附近的空行`	声明中的空行 - 删除声明中 '{' 后和 '}' 前的空行，可用于： C#
`移除 this 限定符`	始终删除 'this.' 限定符（覆盖相应的 C# 设置）(Razor CSharp)
`resharper_abstract_class_constructor_can_be_made_protected_highlighting`	代码检查：抽象类的构造函数可以设为受保护
`resharper_access_rights_in_text_highlighting`	代码检查：无法访问文本参数中的符号
`resharper_access_to_disposed_closure_highlighting`	代码检查：访问已释放的捕获变量
`resharper_access_to_for_each_variable_in_closure_highlighting`	代码检查：在闭包中访问 foreach 变量
`resharper_access_to_modified_closure_highlighting`	代码检查：访问已修改的捕获变量
`resharper_access_to_static_member_via_derived_type_highlighting`	代码检查：通过派生类型访问类型的静态成员
`resharper_accessor_declaration_braces`	大括号布局 - 访问器声明（C#）
`resharper_accessor_owner_body`	代码体 - 属性、索引器和事件 (C#)
`resharper_accessor_owner_declaration_braces`	大括号布局 - 属性声明（C#）
`resharper_add_imports_to_deepest_scope`	引用限定和 'using' 指令 - 将 'using' 指令添加到最深作用域（C#）
`resharper_address_of_marshal_by_ref_object_highlighting`	代码检查：对按引用传递的类的捕获字段引用可能导致运行时异常
`resharper_align_first_arg_by_paren`	对齐多行结构 - 按 '(' 对齐调用参数，可用于： C#
`resharper_align_linq_query`	对齐多行结构 - LINQ 查询（C#）
`resharper_align_multiline_argument`	对齐多行结构 - 调用参数，可用于： C#、 VB.NET
`resharper_align_multiline_array_and_object_initializer`	对齐多行结构 - 数组、对象和集合初始化器（C#）
`resharper_align_multiline_array_initializer`	对齐多行结构 - 数组初始化器（VB.NET）
`resharper_align_multiline_binary_expressions_chain`	对齐多行结构 - 二元表达式，可用于： C#
`resharper_align_multiline_binary_patterns`	对齐多行结构 - 二元模式（C#）
`resharper_align_multiline_calls_chain`	对齐多行结构 - 链式方法调用，可用于： C#
`resharper_align_multiline_comments`	对齐多行结构 - 使用星号对齐多行注释（C#）
`resharper_align_multiline_expression`	对齐多行结构 - 其他表达式，可用于： C#、 VB.NET
`resharper_align_multiline_extends_list`	对齐多行结构 - 基类和接口列表，可用于： C#
`resharper_align_multiline_for_stmt`	对齐多行结构 - 'for' 语句头部（C#）
`resharper_align_multiline_implements_list`	对齐多行结构 - Implements/handles 列表 (VB.NET)
`resharper_align_multiline_list_pattern`	对齐多行结构 - 列表模式和集合表达式（C#）
`resharper_align_multiline_parameter`	对齐多行结构 - 方法参数，可用于： C#、 VB.NET
`resharper_align_multiline_property_pattern`	对齐多行结构 - 属性模式（C#）
`resharper_align_multiline_statement_conditions`	对齐多行结构 - 括号内的语句条件（C#）
`resharper_align_multiline_switch_expression`	对齐多行结构 - Switch 表达式（C#）
`resharper_align_multiple_declaration`	对齐多行结构 - 多个声明，可用于： C#、 VB.NET
`resharper_align_multline_type_parameter_constrains`	对齐多行结构 - 类型参数约束（C#）
`resharper_align_multline_type_parameter_list`	对齐多行结构 - 类型参数列表（C#）
`resharper_align_ternary`	对齐多行结构 - ?: 运算符，可用于：
`resharper_align_tuple_components`	对齐多行结构 - 元组组件（C#）
`resharper_alignment_tab_fill_style`	对齐多行结构 - 使用制表符缩进时的对齐方式，可用于： C#、 ShaderLab、 VB.NET
`resharper_all_underscore_local_parameter_name_highlighting`	代码检查： Lambda 或局部函数中可能具有误导性的参数名称
`resharper_allow_alias`	引用限定和 'using' 指令 - 使用 using 别名指令解决冲突，可用于： C#、 VB.NET
`resharper_allow_comment_after_lbrace`	大括号布局 - 允许在 '{' 后添加注释，可用于： C#
`resharper_allow_far_alignment`	对齐多行结构 - 即使结果缩进过大也对齐，可用于： C#、 ShaderLab
`resharper_always_use_end_of_line_brace_style`	为 C# 覆盖大括号样式以始终使用 '行尾 (K&R 样式)'（Razor CSharp）
`resharper_amd_dependency_path_problem_highlighting`	代码检查：以与 require() 参数相同的方式检查 'amd-dependency'
`resharper_amd_external_module_highlighting`	代码检查： AMD 模块可以转换为外部模块
`resharper_angular_html_banana_highlighting`	代码检查： Angular 2 绑定中的 'Banana in a box' [()] 违规
`resharper_annotate_can_be_null_parameter_highlighting`	代码检查：声明的可空性已推断（参数被推断为可空）
`resharper_annotate_can_be_null_type_member_highlighting`	代码检查：声明的可空性已推断（类型成员被推断为可空）
`resharper_annotate_not_null_parameter_highlighting`	代码检查：声明的可空性已推断（参数被推断为非空）
`resharper_annotate_not_null_type_member_highlighting`	代码检查：声明的可空性已推断（类型成员被推断为非空）
`resharper_annotation_conflict_in_hierarchy_highlighting`	代码检查：层次结构中的注解冲突
`resharper_annotation_redundancy_at_value_type_highlighting`	代码检查：在 void 或值类型声明中使用可空性属性
`resharper_annotation_redundancy_in_hierarchy_highlighting`	代码检查：层次结构中的注解重复
`resharper_anonymous_method_declaration_braces`	大括号布局 - Lambda 和委托（匿名方法声明），可用于： C#
`resharper_append_to_collection_expression_highlighting`	代码检查：追加到集合表达式
`resharper_arguments_anonymous_function`	参数 - 匿名方法（委托和 lambda 表达式）（C#）
`resharper_arguments_literal`	参数 - 字面值（C#）
`resharper_arguments_named`	参数 - 命名表达式（变量、属性、方法等）（C#）
`resharper_arguments_other`	参数 - 其他（C#）
`resharper_arguments_skip_single`	参数 - 跳过单个参数（C#）
`resharper_arguments_string_literal`	参数 - 字符串字面值（C#）
`resharper_arguments_style_anonymous_function_highlighting`	代码检查：为匿名函数使用首选参数样式
`resharper_arguments_style_literal_highlighting`	代码检查：为字面值使用首选参数样式
`resharper_arguments_style_named_expression_highlighting`	代码检查：为命名表达式使用首选参数样式
`resharper_arguments_style_other_highlighting`	代码检查：使用首选参数样式
`resharper_arguments_style_string_literal_highlighting`	代码检查：为字符串字面值使用首选参数样式
`resharper_arrange_accessor_owner_body_highlighting`	代码检查：使用首选主体样式（转换为具有首选主体样式的属性、索引器或事件）
`resharper_arrange_attributes_highlighting`	代码检查：在部分中合并或分离属性
`resharper_arrange_constructor_or_destructor_body_highlighting`	代码检查：使用首选主体样式（转换为具有首选主体样式的构造函数或析构函数）
`resharper_arrange_default_value_when_type_evident_highlighting`	代码检查：当类型显而易见时，使用默认值表达式的首选样式
`resharper_arrange_default_value_when_type_not_evident_highlighting`	代码检查：当类型不显而易见时，使用默认值表达式的首选样式
`resharper_arrange_local_function_body_highlighting`	代码检查：使用首选主体样式（转换为具有首选主体样式的本地函数）
`resharper_arrange_method_or_operator_body_highlighting`	代码检查：使用首选主体样式（转换为具有首选主体样式的方法或运算符）
`resharper_arrange_missing_parentheses_highlighting`	代码检查：添加括号以避免不明显的优先级
`resharper_arrange_modifiers_order_highlighting`	代码检查：调整修饰符声明顺序
`resharper_arrange_namespace_body_highlighting`	代码检查：使用首选命名空间主体样式
`resharper_arrange_null_checking_pattern_highlighting`	代码检查：调整空值检查模式
`resharper_arrange_object_creation_when_type_evident_highlighting`	代码检查：当创建的类型显而易见时，使用 'new' 表达式的首选样式
`当类型不明确时整理对象创建的高亮显示`	代码检查：当创建的类型不显而易见时，使用 'new' 表达式的首选样式
`整理多余括号的高亮显示`	代码检查：移除多余的括号
`整理 static 成员限定符的高亮显示`	代码检查：为静态成员添加/移除限定符
`整理 this 限定符的高亮显示`	代码检查：添加/移除 'this.' 限定符
`整理多行列表中的结尾逗号的高亮显示`	代码检查：在多行列表中，在新行前使用尾随逗号的首选样式
`整理单行列表中的结尾逗号的高亮显示`	代码检查：当最后一个元素后没有新行时，使用尾随逗号的首选样式
`整理类型成员修饰符的高亮显示`	代码检查：为类型成员使用显式或隐式修饰符定义
`整理类型修饰符的高亮显示`	代码检查：为类型使用显式或隐式修饰符定义
`在解构声明中整理 var 关键字的高亮显示`	代码检查：在解构声明中合并或分离 'var'
`ASP 内容占位符无法解析的高亮显示`	代码检查：未知内容占位符
`ASP 自定义页面解析器筛选器类型的高亮显示`	代码检查：不支持的 pageParserFilterType
`ASP 无用代码的高亮显示`	代码检查： ASP.NET 无效代码
`ASP 图像的高亮显示`	代码检查：错误的图像大小
`ASP 控件类型无效的高亮显示`	代码检查：无效的控件类型
`ASP 无法解析的高亮显示`	代码检查：未知符号
`ASP ods 方法引用解析错误的高亮显示`	代码检查：对象数据源方法解析问题
`ASP 解析警告的高亮显示`	代码检查： ASP.NET 解析警告
`ASP 皮肤未解析的高亮显示`	代码检查：未知皮肤
`ASP 标记属性具有可选值的高亮显示`	代码检查：具有可选值的问题的属性
`ASP 主题未解析的高亮显示`	代码检查：未知主题
`ASP 未使用的 register 指令的高亮显示`	代码检查：未使用的注册指令
`ASP 警告的高亮显示`	代码检查： ASP.NET 警告
`将 null 赋值给带有 not null 属性的高亮显示`	代码检查：可能将 'null' 分配给非空实体
`赋值给常量的高亮显示`	代码检查：对常量的赋值
`在函数作用域中赋值给隐式全局变量的高亮显示`	代码检查：对隐式声明的全局变量的赋值
`赋值值从未使用的高亮显示`	代码检查：赋值的值从未使用
`赋值值不会分配给对应字段的高亮显示`	代码检查：在构造函数中分配的参数属性值不会分配给类属性
`条件表达式中的赋值的高亮显示`	代码检查：在条件语句中对变量的赋值
`条件三元表达式中的赋值的高亮显示`	代码检查：条件表达式中的赋值
`使用赋值代替丢弃操作的高亮显示`	代码检查：可疑地使用了具有丢弃样式名称的变量
`赋值值被完全丢弃的高亮显示`	代码检查：赋值结果被完全丢弃
`asxx 路径错误的高亮显示`	代码检查：路径错误
`调用异步迭代器但未使用 await foreach 的高亮显示`	代码检查：异步迭代器调用未使用 'await foreach'
`async void Lambda 表达式的高亮显示`	代码检查：避免在委托类型返回 'void' 时使用 'async' lambda
`async void 方法的高亮显示`	代码检查：避免使用返回类型为 'void' 的 'async' 方法
`属性缩进规则`	标签头部内部 - 属性缩进，可用于：
`属性样式规则`	标签头部内部 - 属性格式，可用于：
`自动属性可设为仅 get 的全局高亮显示`	代码检查：自动属性可以设置为仅 get（非私有访问性）
`自动属性可设为仅 get 的局部高亮显示`	代码检查：自动属性可以设置为仅 get（私有访问性）
`属性括号中的空格格式错误的高亮显示`	代码检查：属性周围的间距不正确
`大括号周围的空格格式错误的高亮显示`	代码检查：大括号周围的间距不正确
`子语句缩进错误的高亮显示`	代码检查：子语句周围的缩进不正确
`冒号后的空格格式错误的高亮显示`	代码检查：冒号周围的间距不正确
`逗号后的空格格式错误的高亮显示`	代码检查：逗号周围的间距不正确
`控制语句的大括号缩进错误的高亮显示`	代码检查：语句大括号周围的缩进不正确
`控制语句的大括号换行错误的高亮显示`	代码检查：语句大括号周围的换行不正确
`声明大括号缩进错误的高亮显示`	代码检查：声明大括号周围的缩进不正确
`声明大括号换行错误的高亮显示`	代码检查：声明大括号周围的换行不正确
`空大括号换行错误的高亮显示`	代码检查：空大括号周围的换行不正确
`表达式大括号缩进错误的高亮显示`	代码检查：表达式大括号周围的缩进不正确
`表达式大括号换行错误的高亮显示`	代码检查：表达式大括号周围的换行不正确
`泛型括号中的空格格式错误的高亮显示`	代码检查：泛型括号周围的间距不正确
`缩进格式错误的高亮显示`	代码检查：多余的缩进/缩出导致的缩进不正确
`LINQ 换行格式错误的高亮显示`	代码检查： LINQ 查询周围的换行不正确
`列表换行格式错误的高亮显示`	代码检查：列表中逗号周围的换行不正确
`成员访问符周围的空格格式错误的高亮显示`	代码检查：成员访问符号周围的间距不正确
`命名空间大括号缩进错误的高亮显示`	代码检查：命名空间大括号周围的缩进不正确
`括号换行格式错误的高亮显示`	代码检查：括号周围的换行不正确
`括号空间格式错误的高亮显示`	代码检查：括号周围的间距不正确
`预处理器指令缩进错误的高亮显示`	代码检查：预处理指令周围的缩进不正确
`分号后的空格格式错误的高亮显示`	代码检查：分号周围的间距不正确
`关键字后的空格格式错误的高亮显示`	代码检查：关键字与括号之间的间距不正确
`方括号中的空格格式错误的高亮显示`	代码检查：语句中方括号周围的间距不正确
`switch 大括号缩进错误的高亮显示`	代码检查： switch 语句周围的缩进不正确
`符号周围的空格格式错误的高亮显示`	代码检查：运算符号周围的间距不正确
`基成员具有 params 参数的高亮显示`	代码检查：基类成员具有 'params' 参数，但重写者没有
`调用带默认参数的基方法的高亮显示`	代码检查：调用基类成员时使用了隐式默认参数
`Object.Equals 仅为 object.Equals 的高亮显示`	代码检查：调用 'base.Equals(...)' 是引用相等
`GetHashCode 中调用 base.GetHashCode 的高亮显示`	代码检查：重写的 GetHashCode 调用了基类 'Object.GetHashCode()'
`未带 Flags 特性的枚举上使用位运算符的高亮显示`	代码检查：对枚举的按位操作未标记 [Flags] 属性
`处理指令后保留空行`	处理指令 - 处理指令后留空行，可用于：
`块语句后保留空行`	代码中的空行 - 在带有子块的语句之后（C#）
`case 后保留空行`	代码中的空行 - 在 switch 语句中的 'case' 之后（C#）
`控制流转移语句后保留空行`	代码中的空行 - 在带有控制转移的语句之后（C#）
`文件范围命名空间指令后保留空行`	声明中的空行 - 在文件范围的命名空间指令之后（C#）
`imports 后保留空行`	空行 - 在 Imports 部分之后 (VB.NET)
`多行语句后保留空行`	代码中的空行 - 在多行语句之后 (C#)
`选项后保留空行`	空行 - 在文件选项部分之后（VB.NET）
`起始注释后保留空行`	声明中的空行 - 文件头注释后（C#）
`using 列表后保留空行`	声明中的空行 - 'using' 列表后（C#）
`访问器前后保留空行`	声明中的空行 - 属性/事件访问器周围（C#）
`自动属性前后保留空行`	声明中的空行 - 自动/抽象属性/事件周围（C#）
`块状 case 分支前后保留空行`	代码中的空行 - 在 switch 语句中带有块的 'case' 部分周围（C#）
`字段前后保留空行`	声明中的空行 - 字段周围，可用于： C#、 VB.NET
`全局属性前后保留空行`	空行 - 全局属性之后 (VB.NET)
`可调用成员前后保留空行`	声明中的空行 - 方法周围，可用于： C#、 VB.NET
`本地方法前后保留空行`	代码中的空行 - 局部函数周围（C#）
`多行 case 分支前后保留空行`	代码中的空行 - 多行 'case' 部分在 switch 语句中（C#）
`命名空间前后保留空行`	声明中的空行 - 命名空间周围，可用于： C#、 VB.NET
`属性前后保留空行`	声明中的空行 - 属性/事件周围（C#）
`Razor functions 前后保留空行`	Razor @functions 块周围的空行（Razor CSharp）
`Razor helpers 前后保留空行`	Razor 助手周围的空行（Razor CSharp）
`Razor sections 前后保留空行`	Razor 区段周围的空行 (Razor CSharp)
`#region 区域前后保留空行`	常规 - 区域周围，可用于： C#、 VB.NET
`单行访问器前后保留空行`	声明中的空行 - 在单行属性/事件访问器周围（C#）
`单行自动属性前后保留空行`	声明中的空行 - 在单行自动/抽象属性/事件周围（C#）
`单行字段前后保留空行`	声明中的空行 - 单行字段周围，可用于： C#、 VB.NET
`单行可调用成员前后保留空行`	声明中的空行 - 单行方法周围，可用于： C#、 VB.NET
`单行本地方法前后保留空行`	代码中的空行 - 单行局部函数周围（C#）
`单行属性前后保留空行`	声明中的空行 - 单行属性/事件周围（C#）
`单行类型前后保留空行`	声明中的空行 - 在单行类型周围（C#）
`类型前后保留空行`	声明中的空行 - 类型周围，可用于： C#、 VB.NET
`在块语句前的空行`	代码中的空行 - 在带有子块的语句之前（C#）
`在 case 语句前的空行`	代码中的空行 - 在 switch 语句中的 'case' 之前（C#）
`在控制转移语句前的空行`	代码中的空行 - 在带有控制转移的语句之前（C#）
`在多行语句前的空行`	代码中的空行 - 多行语句之前（C#）
`在单行注释前的空行`	通用 - 单行注释之前（C#）
`using 组之间的空行`	声明中的空行 - 不同 'using' 组之间（C#）
`在命名空间内的空行`	声明中的空行 - 在命名空间内部（C#）
`在 #region 内的空行`	常规 - 区域内，可用于： C#、 VB.NET
`在类型内部的空行`	声明中的空行 - 在类型内部（C#）
`Blazor 编辑器所需的高亮显示`	代码检查：缺少必需属性的值
`块作用域中的重新声明高亮显示`	代码检查：重复声明 let/const
`大括号样式`	大括号布局样式（通用化）
`do-while 语句使用大括号`	大括号 - 在 'do-while' 语句中（C#）
`fixed 语句使用大括号`	大括号 - 在 'fixed' 语句中（C#）
`for 语句使用大括号`	大括号 - 在 'for' 语句中（C#）
`foreach 语句使用大括号`	大括号 - 在 'foreach' 语句中（C#）
`if-else 语句使用大括号`	大括号 - 在 'if' 语句中（C#）
`lock 语句使用大括号`	大括号 - 在 'lock' 语句中（C#）
`using 语句使用大括号`	大括号 - 在 'using' 语句中（C#）
`while 语句使用大括号`	大括号 - 在 'while' 语句中（C#）
`冗余的大括号`	大括号 - 删除冗余的大括号（C#）
`成员访问中内置类型引用样式的高亮显示`	代码检查：将内置类型引用替换为 CLR 类型名称或静态成员访问表达式中的关键字
`内置类型引用样式的高亮显示`	代码检查：将内置类型引用替换为 CLR 类型名称或关键字
`应用于本机整数的内置类型`	内置类型 - 也适用于本机大小的整数类型（C#）
`成员访问中内置类型引用的样式`	内置类型 - 在成员访问表达式中，优先使用（C#）
`内置类型引用样式`	内置类型 - 在局部变量、成员和参数中，优先使用（C#）
`ref 参数是 volatile 字段的高亮显示`	代码检查：对 'volatile' 字段的捕获引用不会被视为 'volatile'
`无效模块名称的构建警告高亮显示`	代码检查：不存在此名称的模块
`resharper_c_sharp_missing_plugin_dependency_highlighting`	代码检查：项目文件中缺少插件的依赖项
`resharper_c_sharp_warnings_ca2252_highlighting`	代码检查：在使用预览功能之前，请先选择加入
`resharper_c_sharp_warnings_cs0078_highlighting`	代码检查： 'l' 后缀容易与数字 '1' 混淆
`resharper_c_sharp_warnings_cs0108_cs0114_highlighting`	代码检查：需要关键字 'new'
`resharper_c_sharp_warnings_cs0109_highlighting`	代码检查：关键字 'new' 是多余的
`resharper_c_sharp_warnings_cs0162_highlighting`	代码检查：代码不可达
`resharper_c_sharp_warnings_cs0183_highlighting`	代码检查：给定表达式始终是提供的类型
`resharper_c_sharp_warnings_cs0184_highlighting`	代码检查：给定表达式从不是提供的类型
`resharper_c_sharp_warnings_cs0197_highlighting`	代码检查：对按引用传递的类字段取地址
`resharper_c_sharp_warnings_cs0252_cs0253_highlighting`	代码检查：可能无意的引用比较
`resharper_c_sharp_warnings_cs0282_highlighting`	代码检查：在部分结构的多个声明中，字段之间没有定义顺序。要指定顺序，所有实例字段必须在同一个声明中。
`resharper_c_sharp_warnings_cs0420_highlighting`	代码检查：对 volatile 字段的引用不会被视为 volatile
`resharper_c_sharp_warnings_cs0458_highlighting`	代码检查：表达式的结果始终为可空类型的 'null'
`resharper_c_sharp_warnings_cs0464_highlighting`	代码检查：与可空值类型的 null 比较总是产生 'false'
`resharper_c_sharp_warnings_cs0465_highlighting`	代码检查：引入 'Finalize' 方法可能会干扰析构函数的调用
`resharper_c_sharp_warnings_cs0469_highlighting`	代码检查： 'goto case' 值不能隐式转换为所需类型
`resharper_c_sharp_warnings_cs0472_highlighting`	代码检查：由于值类型的值永远不会等于 'null'，表达式的结果始终为 'true' 或 'false'
`resharper_c_sharp_warnings_cs0612_highlighting`	代码检查：使用已过时的符号（无消息）
`resharper_c_sharp_warnings_cs0618_highlighting`	代码检查：使用已过时的符号
`resharper_c_sharp_warnings_cs0628_highlighting`	代码检查：在密封类中声明新的受保护成员与将其声明为私有成员相同
`resharper_c_sharp_warnings_cs0642_highlighting`	代码检查：可能的错误空语句
`resharper_c_sharp_warnings_cs0652_highlighting`	代码检查：与整数常量的比较是无用的；该常量超出了类型 'type' 的范围。
`resharper_c_sharp_warnings_cs0657_highlighting`	代码检查： 'attribute modifier' 不是此声明的有效属性位置。此块中的所有属性都将被忽略
`resharper_c_sharp_warnings_cs0658_highlighting`	代码检查： 'attribute modifier' 不是一个被识别的属性位置。此块中的所有属性都将被忽略
`resharper_c_sharp_warnings_cs0659_highlighting`	代码检查：类重写了 Object.Equals(object o) 但未重写 Object.GetHashCode()
`resharper_c_sharp_warnings_cs0660_cs0661_highlighting`	代码检查：运算符 '==' 或运算符 '!=' 未重写 'Object.Equals(object o)' 和 'Object.GetHashCode()'
`resharper_c_sharp_warnings_cs0665_highlighting`	代码检查：条件表达式中的赋值
`resharper_c_sharp_warnings_cs0672_highlighting`	代码检查：成员重写了已过时的成员
`resharper_c_sharp_warnings_cs0675_highlighting`	代码检查：对符号扩展操作数使用按位或运算符。
`resharper_c_sharp_warnings_cs0693_highlighting`	代码检查：类型参数与外部类型的类型参数同名
`resharper_c_sharp_warnings_cs0728_highlighting`	代码检查：可能错误地将值分配给作为 'using' 或 'lock' 语句参数的局部变量
`resharper_c_sharp_warnings_cs1030_highlighting`	代码检查： '#warning' 指令
`resharper_c_sharp_warnings_cs1058_highlighting`	代码检查：之前的 catch 子句已捕获所有异常
`resharper_c_sharp_warnings_cs1066_highlighting`	代码检查：为参数指定的默认值将不起作用，因为它适用于不允许可选参数的上下文中的成员
`resharper_c_sharp_warnings_cs1522_highlighting`	代码检查：空的 switch 块
`resharper_c_sharp_warnings_cs1570_highlighting`	代码检查： XML 注释中的无效 XML
`resharper_c_sharp_warnings_cs1571_highlighting`	代码检查： XML 注释中重复的 param 标签
`resharper_c_sharp_warnings_cs1572_highlighting`	代码检查： XML 注释中有 'param' 标签用于 'Parameter'，但没有该名称的参数
`resharper_c_sharp_warnings_cs1573_highlighting`	代码检查：参数在 XML 注释中没有匹配的 param 标签
`resharper_c_sharp_warnings_cs1574_cs1584_cs1581_cs1580_highlighting`	代码检查：无法解析 XML 注释中的引用
`resharper_c_sharp_warnings_cs1574_highlighting`	代码检查： XML 注释中的引用不明确
`resharper_c_sharp_warnings_cs1580_highlighting`	代码检查： XML 注释中的签名不正确
`resharper_c_sharp_warnings_cs1584_highlighting`	代码检查： XML 注释中存在语法错误
`resharper_c_sharp_warnings_cs1587_highlighting`	代码检查： XML 注释未放置在有效的语言元素上
`resharper_c_sharp_warnings_cs1589_highlighting`	代码检查：无法包含 XML 片段
`resharper_c_sharp_warnings_cs1590_highlighting`	代码检查：无效的 XML 包含元素
`resharper_c_sharp_warnings_cs1591_highlighting`	代码检查：公开可见类型或成员缺少 XML 注释
`resharper_c_sharp_warnings_cs1592_highlighting`	代码检查：包含的注释文件中格式错误的 XML
`resharper_c_sharp_warnings_cs1710_highlighting`	代码检查： XML 注释中重复的 typeparam 标签
`resharper_c_sharp_warnings_cs1711_highlighting`	代码检查： XML 注释中有 'typeparam' 标签用于 'TypeParameter'，但没有该名称的类型参数
`resharper_c_sharp_warnings_cs1712_highlighting`	代码检查：类型参数在 XML 注释中没有匹配的 typeparam 标签
`resharper_c_sharp_warnings_cs1717_highlighting`	代码检查：对同一变量的赋值
`resharper_c_sharp_warnings_cs1723_highlighting`	代码检查： XML 注释中具有 cref 属性，该属性引用了类型参数
`resharper_c_sharp_warnings_cs1911_highlighting`	代码检查：通过匿名方法、lambda 表达式、查询表达式或迭代器中的 'base' 关键字访问成员会导致不可验证的代码
`resharper_c_sharp_warnings_cs1957_highlighting`	代码检查：运行时存在多个重写候选项
`resharper_c_sharp_warnings_cs1981_highlighting`	代码检查：使用 'is' 测试与 'dynamic' 的兼容性本质上与测试与 'Object' 的兼容性相同，并且对于所有非 null 值都会成功
`resharper_c_sharp_warnings_cs1998_highlighting`	代码检查：异步函数未包含 await 表达式
`resharper_c_sharp_warnings_cs4014_highlighting`	代码检查：异步方法调用未包含 await 表达式
`resharper_c_sharp_warnings_cs7022_highlighting`	代码检查：由于找到包含顶级语句的编译单元，'Main' 方法将不会用作入口点。
`resharper_c_sharp_warnings_cs7023_highlighting`	代码检查： 'is' 或 'as' 运算符中的静态类型。
`resharper_c_sharp_warnings_cs7095_highlighting`	代码检查：筛选表达式是常量，请考虑移除筛选器
`resharper_c_sharp_warnings_cs8073_highlighting`	代码检查：由于值类型的值永远不会等于 'null'，表达式的结果始终为 'true' 或 'false'
`resharper_c_sharp_warnings_cs8094_highlighting`	代码检查：对齐值 'value' 的幅度大于 'magnitude limit'，可能会导致生成较大的格式化字符串。
`resharper_c_sharp_warnings_cs8123_highlighting`	代码检查：元组元素名称被忽略，因为目标类型指定了不同的名称或未指定名称。
`resharper_c_sharp_warnings_cs8383_highlighting`	代码检查：元组元素名称被忽略，因为元组 == 或 != 运算符另一侧指定了不同的名称或未指定名称。
`resharper_c_sharp_warnings_cs8424_highlighting`	代码检查： 'EnumeratorCancellation' 属性仅在返回 'IAsyncEnumerable<>' 的异步迭代器方法中对类型为 'CancellationToken' 的参数有效。
`resharper_c_sharp_warnings_cs8425_highlighting`	代码检查：异步迭代器具有一个或多个类型为 'CancellationToken' 的参数，但没有任何参数带有 'EnumeratorCancellation' 属性。
`resharper_c_sharp_warnings_cs8500_highlighting`	代码检查：此操作获取托管类型的地址、大小或声明指针。
`resharper_c_sharp_warnings_cs8509_highlighting`	代码检查：切换表达式未处理所有可能的输入（不完整）。
`resharper_c_sharp_warnings_cs8519_highlighting`	代码检查：给定表达式从未匹配提供的模式。
`resharper_c_sharp_warnings_cs8520_highlighting`	代码检查：给定表达式始终匹配提供的常量。
`resharper_c_sharp_warnings_cs8524_highlighting`	代码检查：切换表达式未处理其输入类型的某些值（不完整），涉及未命名的枚举值。
`resharper_c_sharp_warnings_cs8597_highlighting`	代码检查：抛出的值可能为 null。
`resharper_c_sharp_warnings_cs8600_highlighting`	代码检查：将 null 字面值或可能的 null 值转换为非可空类型。
`resharper_c_sharp_warnings_cs8601_highlighting`	代码检查：可能的 null 引用赋值。
`resharper_c_sharp_warnings_cs8602_highlighting`	代码检查：可能的 null 引用解引用。
`resharper_c_sharp_warnings_cs8603_highlighting`	代码检查：可能的 null 引用返回。
`resharper_c_sharp_warnings_cs8604_highlighting`	代码检查：参数的可能 null 引用参数。
`resharper_c_sharp_warnings_cs8605_highlighting`	代码检查：拆箱可能的 null 值。
`resharper_c_sharp_warnings_cs8607_highlighting`	代码检查：可能的 null 值可能无法用于标记为 [NotNull] 或 [DisallowNull] 的类型。
`resharper_c_sharp_warnings_cs8608_highlighting`	代码检查：类型中引用类型的可空性与重写成员不匹配。
`resharper_c_sharp_warnings_cs8609_highlighting`	代码检查：返回类型中引用类型的可空性与重写成员不匹配。
`resharper_c_sharp_warnings_cs8610_highlighting`	代码检查：参数类型中引用类型的可空性与重写成员不匹配。
`resharper_c_sharp_warnings_cs8611_highlighting`	代码检查：参数类型中引用类型的可空性与部分方法声明不匹配。
`resharper_c_sharp_warnings_cs8612_highlighting`	代码检查：类型中引用类型的可空性与隐式实现的成员不匹配。
`resharper_c_sharp_warnings_cs8613_highlighting`	代码检查：返回类型中引用类型的可空性与隐式实现的成员不匹配。
`resharper_c_sharp_warnings_cs8614_highlighting`	代码检查：参数类型中引用类型的可空性与隐式实现的成员不匹配。
`resharper_c_sharp_warnings_cs8615_highlighting`	代码检查：类型中引用类型的可空性与实现的成员不匹配。
`resharper_c_sharp_warnings_cs8616_highlighting`	代码检查：返回类型中引用类型的可空性与实现的成员不匹配。
`resharper_c_sharp_warnings_cs8617_highlighting`	代码检查：参数类型中引用类型的可空性与实现的成员不匹配。
`resharper_c_sharp_warnings_cs8618_highlighting`	代码检查：非可空成员未初始化。
`resharper_c_sharp_warnings_cs8619_highlighting`	代码检查：源类型中引用类型的可空性与目标类型不匹配。
`resharper_c_sharp_warnings_cs8620_highlighting`	代码检查：由于引用类型的可空性差异，参数无法用于对应的参数。
`resharper_c_sharp_warnings_cs8621_highlighting`	代码检查：返回类型中引用类型的可空性与目标委托不匹配（可能是由于可空性属性）。
`resharper_c_sharp_warnings_cs8622_highlighting`	代码检查：参数类型中引用类型的可空性与目标委托不匹配（可能是由于可空性属性）。
`resharper_c_sharp_warnings_cs8624_highlighting`	代码检查：由于引用类型的可空性差异，参数无法作为输出用于参数。
`resharper_c_sharp_warnings_cs8625_highlighting`	代码检查：无法将 null 字面值转换为非可空引用类型。
`resharper_c_sharp_warnings_cs8629_highlighting`	代码检查：可空值类型可能为 null。
`resharper_c_sharp_warnings_cs8631_highlighting`	代码检查：类型参数的可空性与约束类型不匹配。
`resharper_c_sharp_warnings_cs8632_highlighting`	代码检查：可空引用类型的注解应仅在 '#nullable' 注解上下文中使用。
`resharper_c_sharp_warnings_cs8633_highlighting`	代码检查：类型参数的约束中存在可空性不匹配。
`resharper_c_sharp_warnings_cs8634_highlighting`	代码检查：类型参数的可空性与 'class' 约束不匹配。
`resharper_c_sharp_warnings_cs8643_highlighting`	代码检查：显式接口说明符中引用类型的可空性与类型实现的接口不匹配。
`resharper_c_sharp_warnings_cs8644_highlighting`	代码检查：基类型实现的接口中引用类型的可空性不匹配。
`resharper_c_sharp_warnings_cs8645_highlighting`	代码检查：接口列表中已列出类型，但引用类型的可空性不同。
`resharper_c_sharp_warnings_cs8655_highlighting`	代码检查：切换表达式未处理某些 null 输入（不完整）。
`resharper_c_sharp_warnings_cs8656_highlighting`	代码检查：从 'readonly' 成员调用非只读成员会导致 'this' 的隐式复制
`resharper_c_sharp_warnings_cs8667_highlighting`	代码检查：局部方法声明的类型参数的可空性不一致。
`resharper_c_sharp_warnings_cs8669_highlighting`	代码检查：可空引用类型的注解应仅在 '#nullable' 注解上下文中的代码中使用。自动生成的代码需要在源代码中显式添加 '#nullable' 指令。
`resharper_c_sharp_warnings_cs8670_highlighting`	代码检查：对象或集合初始化器隐式解引用了可能为空的成员。
`resharper_c_sharp_warnings_cs8714_highlighting`	代码检查：类型参数的可空性与 'notnull' 约束不匹配。
`resharper_c_sharp_warnings_cs8762_highlighting`	代码检查：参数在退出函数时必须有条件地具有非空值。
`resharper_c_sharp_warnings_cs8763_highlighting`	代码检查：标记为 [DoesNotReturn] 的方法不应返回。
`resharper_c_sharp_warnings_cs8764_highlighting`	代码检查：返回类型的可空性与被重写成员不匹配（可能是由于可空性属性导致）。
`resharper_c_sharp_warnings_cs8765_highlighting`	代码检查：参数类型的可空性与被重写成员不匹配（可能是由于可空性属性导致）。
`resharper_c_sharp_warnings_cs8766_highlighting`	代码检查：返回类型的可空性与隐式实现的成员不匹配（可能是由于可空性属性导致）。
`resharper_c_sharp_warnings_cs8767_highlighting`	代码检查：参数类型的可空性与隐式实现的成员不匹配（可能是由于可空性属性导致）。
`resharper_c_sharp_warnings_cs8768_highlighting`	代码检查：返回类型的可空性与实现的成员不匹配（可能是由于可空性属性导致）。
`resharper_c_sharp_warnings_cs8769_highlighting`	代码检查：参数类型的可空性与实现的成员不匹配（可能是由于可空性属性导致）。
`resharper_c_sharp_warnings_cs8770_highlighting`	代码检查：方法缺少 '[DoesNotReturn]' 注解以匹配实现或重写的成员。
`resharper_c_sharp_warnings_cs8774_highlighting`	代码检查：成员在退出时必须具有非空值。
`resharper_c_sharp_warnings_cs8775_highlighting`	代码检查：成员在退出函数时必须有条件地具有非空值。
`resharper_c_sharp_warnings_cs8776_highlighting`	代码检查：成员不能在此属性中使用。
`resharper_c_sharp_warnings_cs8777_highlighting`	代码检查：参数在退出时必须具有非空值。
`resharper_c_sharp_warnings_cs8794_highlighting`	代码检查：给定表达式始终匹配提供的模式
`resharper_c_sharp_warnings_cs8819_highlighting`	代码检查：返回类型中引用类型的可空性与局部方法声明不匹配。
`resharper_c_sharp_warnings_cs8824_highlighting`	代码检查：参数在退出时必须具有非空值，因为 [NotNullIfNotNull] 注解中提到的参数为非空。
`resharper_c_sharp_warnings_cs8825_highlighting`	代码检查：返回值必须为非空，因为 [NotNullIfNotNull] 注解中提到的参数为非空。
`resharper_c_sharp_warnings_cs8846_highlighting`	代码检查： switch 表达式未处理其输入类型的所有可能值（不完整）。但是，带有 'when' 子句的模式可能会成功匹配此值。
`resharper_c_sharp_warnings_cs8847_highlighting`	代码检查： switch 表达式未处理某些空输入（不完整）。但是，带有 'when' 子句的模式可能会成功匹配此值。
`resharper_c_sharp_warnings_cs8851_highlighting`	代码检查：记录定义了 'Equals' 但未定义 'GetHashCode'
`resharper_c_sharp_warnings_cs8860_highlighting`	代码检查：类型和别名不应命名为 'record'
`resharper_c_sharp_warnings_cs8892_highlighting`	代码检查：异步 'Main' 方法不会用作入口点，因为找到了同步入口点。
`resharper_c_sharp_warnings_cs8947_highlighting`	代码检查：参数出现在参数列表中插值字符串处理程序参数之后。
`resharper_c_sharp_warnings_cs8960_highlighting`	代码检查： CallerArgumentExpressionAttribute 将不起作用；它被 CallerLineNumberAttribute 覆盖
`resharper_c_sharp_warnings_cs8961_highlighting`	代码检查： CallerArgumentExpressionAttribute 将不起作用；它被 CallerFilePathAttribute 覆盖
`resharper_c_sharp_warnings_cs8962_highlighting`	代码检查： CallerArgumentExpressionAttribute 将不起作用；它被 CallerMemberNameAttribute 覆盖
`resharper_c_sharp_warnings_cs8963_highlighting`	代码检查： CallerArgumentExpressionAttribute 应用于无效的参数名称。
`resharper_c_sharp_warnings_cs8965_highlighting`	代码检查：应用于参数的 CallerArgumentExpressionAttribute 无效，因为它是自引用的
`resharper_c_sharp_warnings_cs8966_highlighting`	代码检查： CallerArgumentExpressionAttribute 将不起作用，因为它适用于在不允许可选参数的上下文中使用的成员
`resharper_c_sharp_warnings_cs8971_highlighting`	代码检查： [InterpolatedStringHandlerArgument] 应用于 lambda 参数时无效，并将在调用点被忽略。
`resharper_c_sharp_warnings_cs8974_highlighting`	代码检查：将方法组转换为非委托类型 'object'。
`resharper_c_sharp_warnings_cs8981_highlighting`	代码检查：类型名称仅包含小写 ASCII 字符。此类名称可能会成为语言的保留名称
`resharper_c_sharp_warnings_cs9042_highlighting`	代码检查：不应要求使用过时的成员。
`resharper_c_sharp_warnings_cs9073_highlighting`	代码检查：参数的 'scoped' 修饰符与目标委托不匹配。
`resharper_c_sharp_warnings_cs9074_highlighting`	代码检查：参数的 'scoped' 修饰符与被重写或实现的成员不匹配。
`resharper_c_sharp_warnings_cs9080_highlighting`	代码检查：在此上下文中使用变量可能会暴露其引用的变量超出声明范围。
`resharper_c_sharp_warnings_cs9081_highlighting`	代码检查：在此上下文中，stackalloc 表达式的结果可能会暴露在包含方法之外。
`resharper_c_sharp_warnings_cs9082_highlighting`	代码检查：局部变量通过引用返回，但被初始化为无法通过引用返回的值。
`resharper_c_sharp_warnings_cs9083_highlighting`	代码检查：变量的成员通过引用返回，但被初始化为无法通过引用返回的值
`resharper_c_sharp_warnings_cs9084_highlighting`	代码检查：结构体成员通过引用返回 'this' 或其他实例成员。
`resharper_c_sharp_warnings_cs9085_highlighting`	代码检查：此操作将表达式通过引用赋值给具有更窄逃逸范围的变量。
`resharper_c_sharp_warnings_cs9086_highlighting`	代码检查： ref 条件运算符的分支引用了声明范围不兼容的变量。
`resharper_c_sharp_warnings_cs9087_highlighting`	代码检查：此操作通过引用返回了一个参数，但它不是 ref 参数。
`resharper_c_sharp_warnings_cs9088_highlighting`	代码检查：此操作通过引用返回了一个参数，但它的作用域仅限于当前方法。
`resharper_c_sharp_warnings_cs9089_highlighting`	代码检查：此操作通过引用返回了参数的一个成员，但该成员不是 ref 或 out 参数。
`resharper_c_sharp_warnings_cs9090_highlighting`	代码检查：此操作通过引用返回了参数的一个成员，但该成员的作用域仅限于当前方法。
`resharper_c_sharp_warnings_cs9091_highlighting`	代码检查：此操作通过引用返回了一个局部变量，但它不是 ref 局部变量。
`resharper_c_sharp_warnings_cs9092_highlighting`	代码检查：此操作通过引用返回了局部变量的一个成员，但它不是 ref 局部变量。
`resharper_c_sharp_warnings_cs9093_highlighting`	代码检查：此操作 ref 赋值了一个值，该值只能通过 return 语句从当前方法中逃逸。
`resharper_c_sharp_warnings_cs9094_highlighting`	代码检查：此操作通过 ref 参数按引用返回了一个参数；但它只能通过 return 语句安全返回。
`resharper_c_sharp_warnings_cs9095_highlighting`	代码检查：此操作通过 ref 参数按引用返回了参数的一个成员；但它只能通过 return 语句安全返回。
`resharper_c_sharp_warnings_cs9097_highlighting`	代码检查：此操作 ref 赋值了一个值，该值的逃逸范围比目标更广，从而允许通过目标赋值具有更窄逃逸范围的值。
`resharper_c_sharp_warnings_cs9099_highlighting`	代码检查：目标委托类型中的默认参数值不匹配。
`resharper_c_sharp_warnings_cs9100_highlighting`	代码检查：参数在 lambda 中具有 params 修饰符，但在目标委托类型中没有。
`resharper_c_sharp_warnings_cs9107_highlighting`	代码检查：参数被捕获到封闭类型的状态中，其值也被传递给基类构造函数。该值可能也会被基类捕获。
`resharper_c_sharp_warnings_cs9124_highlighting`	代码检查：参数被捕获到封闭类型的状态中，其值也被用于初始化字段、属性或事件。
`resharper_c_sharp_warnings_cs9154_highlighting`	代码检查：可拦截方法和拦截器方法的签名不匹配
`resharper_c_sharp_warnings_cs9158_highlighting`	代码检查：参数类型中的引用类型的可空性与可拦截方法不匹配
`resharper_c_sharp_warnings_cs9159_highlighting`	代码检查：拦截器方法中返回类型的引用类型的可空性与可拦截方法不匹配
`resharper_c_sharp_warnings_cs9179_highlighting`	代码检查：主构造函数参数被基类类型的成员遮蔽。
`resharper_c_sharp_warnings_cs9181_highlighting`	代码检查：内联数组索引器不会用于元素访问表达式。
`resharper_c_sharp_warnings_cs9182_highlighting`	代码检查：内联数组的 'Slice' 方法不会用于元素访问表达式。
`resharper_c_sharp_warnings_cs9183_highlighting`	代码检查：内联数组转换运算符不会用于从声明类型的表达式进行转换。
`resharper_c_sharp_warnings_cs9184_highlighting`	代码检查： '内联数组'语言特性不支持具有 'ref' 字段或类型无效作为类型参数的元素字段的内联数组类型。
`resharper_c_sharp_warnings_cs9191_highlighting`	代码检查：与 'in' 参数对应的参数的 'ref' 修饰符等同于 'in'。建议改用 'in'。
`resharper_c_sharp_warnings_cs9192_highlighting`	代码检查：与 'in' 参数对应的参数的 'ref' 修饰符等同于 'in'。建议改用 'in'。
`resharper_c_sharp_warnings_cs9193_highlighting`	代码检查：参数应为变量，因为它被传递给 'ref readonly' 参数。
`resharper_c_sharp_warnings_cs9195_highlighting`	代码检查：参数应使用 'in' 关键字传递。
`resharper_c_sharp_warnings_cs9196_highlighting`	代码检查：参数的引用类型修饰符与重写或实现的成员中的对应参数不匹配。
`resharper_c_sharp_warnings_cs9200_highlighting`	代码检查：为 'ref readonly' 参数指定了默认值，但 'ref readonly' 应仅用于引用。建议将参数声明为 'in'。
`resharper_c_sharp_warnings_cs9208_highlighting`	代码检查：集合表达式可能会导致意外的堆分配
`resharper_c_sharp_warnings_cs9209_highlighting`	代码检查：由于使用了 '..' 展开，集合表达式可能会导致意外的堆分配
`resharper_c_sharp_warnings_wme006_highlighting`	代码检查：命名空间应为此项目的默认命名空间
`resharper_caller_callee_using_error_highlighting`	代码检查：在 'strict mode' 中使用 'arguments.caller' 和 'arguments.callee'
`resharper_caller_callee_using_highlighting`	代码检查：使用 'arguments.caller' 和 'arguments.callee'
`resharper_can_simplify_dictionary_lookup_with_try_add_highlighting`	代码检查：字典查找可以通过 'TryAdd' 简化
`resharper_can_simplify_dictionary_lookup_with_try_get_value_highlighting`	代码检查：字典查找可以通过 'TryGetValue' 简化
`resharper_can_simplify_dictionary_removing_with_single_call_highlighting`	代码检查：字典项移除可以通过单个 'Remove' 简化
`resharper_can_simplify_dictionary_try_get_value_with_get_value_or_default_highlighting`	代码检查：字典查找可以通过 'GetValueOrDefault' 简化
`resharper_can_simplify_set_adding_with_single_call_highlighting`	代码检查：可以在 'Add' 之前简化 'Contains'
`resharper_can_use_global_alias`	引用限定和 'using' 指令 - 允许使用 'global::' 前缀（C#）
`resharper_cannot_apply_equality_operator_to_type_highlighting`	代码检查：与标记为 'CannotApplyEqualityOperatorAttribute' 的类型进行 '==' 比较
`resharper_case_block_braces`	大括号布局 - 'case' 标签下的块，可用于： C#
`resharper_check_for_reference_equality_instead_1_highlighting`	代码检查：检查引用相等性
`resharper_check_for_reference_equality_instead_2_highlighting`	代码检查：检查引用相等性
`resharper_check_for_reference_equality_instead_3_highlighting`	代码检查：检查引用相等性
`resharper_check_for_reference_equality_instead_4_highlighting`	代码检查：检查引用相等性
`resharper_check_namespace_highlighting`	代码检查：命名空间与文件位置不对应
`resharper_class_can_be_sealed_global_highlighting`	代码检查：类可以设为密封类（不可继承）（非私有可访问性）
`resharper_class_can_be_sealed_local_highlighting`	代码检查：类可以设为密封类（不可继承）（私有可访问性）
`resharper_class_cannot_be_instantiated_highlighting`	代码检查：类无法实例化
`resharper_class_highlighting`	代码检查：类模拟可以转换为类
`resharper_class_never_instantiated_global_highlighting`	代码检查：类从未被实例化（非私有可访问性）
`resharper_class_never_instantiated_local_highlighting`	代码检查：类从未被实例化（私有可访问性）
`resharper_class_with_virtual_members_never_inherited_global_highlighting`	代码检查：具有虚拟（可重写）成员的类从未被继承（非私有可访问性）
`resharper_class_with_virtual_members_never_inherited_local_highlighting`	代码检查：具有虚拟（可重写）成员的类从未被继承（私有可访问性）
`resharper_closure_on_modified_variable_highlighting`	代码检查：闭包引用了在外部作用域循环中修改的变量
`resharper_co_variant_array_conversion_highlighting`	代码检查：协变数组转换
`resharper_coerced_equals_using_highlighting`	代码检查：使用强制相等（使用强制相等运算符）
`resharper_coerced_equals_using_with_null_undefined_highlighting`	代码检查：使用强制相等（使用强制相等运算符与 'null' 或 'undefined'）
`resharper_collection_never_queried_global_highlighting`	代码检查：集合内容从未被查询（非私有可访问性）
`resharper_collection_never_queried_local_highlighting`	代码检查：集合内容从未被查询（私有可访问性）
`resharper_collection_never_updated_global_highlighting`	代码检查：集合从未被更新（非私有可访问性）
`resharper_collection_never_updated_local_highlighting`	代码检查：集合从未被更新（私有可访问性）
`resharper_comma_not_valid_here_highlighting`	代码检查：此处逗号无效
`resharper_comment_typo_highlighting`	代码检查：注释中有拼写错误
`resharper_common_js_external_module_highlighting`	代码检查： CommonJs 模块可以转换为外部模块
`resharper_compare_non_constrained_generic_with_null_highlighting`	代码检查：可能将值类型与 'null' 进行比较
`resharper_compare_of_floats_by_equality_operator_highlighting`	代码检查：浮点数的相等比较
`resharper_condition_is_always_const_highlighting`	代码检查：条件始终为常量
`resharper_condition_is_always_true_or_false_according_to_nullable_api_contract_highlighting`	代码检查：根据可空引用类型的注解，表达式始终为 'true' 或 'false'
`resharper_condition_is_always_true_or_false_highlighting`	代码检查：表达式始终为 'true' 或始终为 'false'
`resharper_conditional_access_qualifier_is_non_nullable_according_to_api_contract_highlighting`	代码检查：根据可空引用类型的注解，条件访问限定符表达式不为 null
`resharper_conditional_ternary_equal_branch_highlighting`	代码检查： '?:' 表达式的 true 和 false 分支相同
`resharper_confusing_char_as_integer_in_constructor_highlighting`	代码检查：字符可能被无意中用作整数
`resharper_constant_conditional_access_qualifier_highlighting`	代码检查：条件访问限定符表达式已知为 null 或非 null
`resharper_constant_null_coalescing_condition_highlighting`	代码检查： '??' 条件已知为 null 或非 null
`resharper_constructor_call_not_used_highlighting`	代码检查：构造函数调用未被使用或可能仅用于副作用
`resharper_constructor_initializer_loop_highlighting`	代码检查：可能存在循环构造函数调用
`resharper_constructor_or_destructor_body`	代码主体 - 构造函数和析构函数（C#）
`resharper_constructor_with_must_dispose_resource_attribute_base_is_not_annotated_highlighting`	代码检查： [MustDisposeResource] 注解未从基构造函数继承，应显式添加
`resharper_container_annotation_redundancy_highlighting`	代码检查：容器可空性属性用于非容器类型的声明
`resharper_continuous_indent_multiplier`	通用 - 连续行缩进倍数（C#）
`resharper_contract_annotation_not_parsed_highlighting`	代码检查：契约注解定义中存在问题
`resharper_convert_closure_to_method_group_highlighting`	代码检查：将 lambda 表达式转换为方法组
`resharper_convert_conditional_ternary_expression_to_switch_expression_highlighting`	代码检查：用 'switch' 表达式替换三元表达式
`resharper_convert_constructor_to_member_initializers_highlighting`	代码检查：将构造函数转换为成员初始化器
`resharper_convert_if_do_to_while_highlighting`	代码检查：将 'if do while' 转换为 'while'
`resharper_convert_if_statement_to_conditional_ternary_expression_highlighting`	代码检查： 'if' 语句可以重写为 '?:' 表达式
`resharper_convert_if_statement_to_null_coalescing_assignment_highlighting`	代码检查： 'if' 语句可以重写为 '??=' 赋值
`resharper_convert_if_statement_to_null_coalescing_expression_highlighting`	代码检查： 'if' 语句可以重写为 '??' 表达式
`resharper_convert_if_statement_to_return_statement_highlighting`	代码检查： 'if-return' 语句可以重写为 'return' 语句
`resharper_convert_if_statement_to_switch_statement_highlighting`	代码检查：将 'if' 语句转换为 'switch'
`resharper_convert_if_to_or_expression_highlighting`	代码检查：将 'if' 转换为 '\|\|'
`resharper_convert_nullable_to_short_form_highlighting`	代码检查：将 'Nullable<T>' 转换为 'T?'
`resharper_convert_switch_statement_to_switch_expression_highlighting`	代码检查：用 'switch' 表达式替换 'switch' 语句
`resharper_convert_to_auto_property_highlighting`	代码检查：将属性转换为自动属性
`resharper_convert_to_auto_property_when_possible_highlighting`	代码检查：将属性转换为自动属性（如果可能）
`resharper_convert_to_auto_property_with_private_setter_highlighting`	代码检查：将属性转换为带私有 setter 的自动属性
`resharper_convert_to_compound_assignment_highlighting`	代码检查：使用复合赋值
`resharper_convert_to_constant_global_highlighting`	代码检查：将局部变量或字段转换为常量（非私有可访问性）
`resharper_convert_to_constant_local_highlighting`	代码检查：将局部变量或字段转换为常量（私有可访问性）
`resharper_convert_to_lambda_expression_highlighting`	代码检查：转换为 lambda 表达式
`resharper_convert_to_local_function_highlighting`	代码检查：将委托变量转换为局部函数
`resharper_convert_to_null_coalescing_compound_assignment_highlighting`	代码检查：使用复合赋值
`resharper_convert_to_primary_constructor_highlighting`	代码检查：将构造函数转换为主构造函数
`resharper_convert_to_static_class_highlighting`	代码检查：转换为静态类
`resharper_convert_to_using_declaration_highlighting`	代码检查：转换为 'using' 声明
`resharper_convert_to_vb_auto_property_highlighting`	代码检查：将属性转换为自动属性
`resharper_convert_to_vb_auto_property_when_possible_highlighting`	代码检查：将属性转换为自动属性（如果可能）
`resharper_convert_to_vb_auto_property_with_private_setter_highlighting`	代码检查：将属性转换为带私有 setter 的自动属性
`resharper_convert_type_check_pattern_to_null_check_highlighting`	代码检查：使用空检查模式代替对任何非空值成功的类型检查
`resharper_convert_type_check_to_null_check_highlighting`	代码检查：使用空检查代替对任何非空值成功的类型检查
`resharper_cpp_brace_style`	大括号布局样式（通用化）
`resharper_cpp_space_after_comma`	逗号后空格（通用）
`resharper_cpp_space_before_comma`	逗号前空格（通用）
`resharper_cpp_space_between_method_call_name_and_opening_parenthesis`	方法调用括号之前的空格 (通用)
`resharper_create_specialized_overload_highlighting`	代码检查：字符串字面量的使用允许创建专用重载
`resharper_csharp_accessor_declaration_braces`	大括号布局 - 访问器声明（C#）
`resharper_csharp_accessor_owner_body`	代码体 - 属性、索引器和事件 (C#)
`resharper_csharp_accessor_owner_declaration_braces`	大括号布局 - 属性声明（C#）
`resharper_csharp_add_imports_to_deepest_scope`	引用限定和 'using' 指令 - 将 'using' 指令添加到最深作用域（C#）
`resharper_csharp_align_first_arg_by_paren`	对齐多行结构 - 按 '(' 调用参数（C#）
`resharper_csharp_align_linq_query`	对齐多行结构 - LINQ 查询（C#）
`resharper_csharp_align_multiline_argument`	对齐多行结构 - 调用参数（C#）
`resharper_csharp_align_multiline_array_and_object_initializer`	对齐多行结构 - 数组、对象和集合初始化器（C#）
`resharper_csharp_align_multiline_binary_expressions_chain`	对齐多行结构 - 二元表达式（C#）
`resharper_csharp_align_multiline_binary_patterns`	对齐多行结构 - 二元模式（C#）
`resharper_csharp_align_multiline_calls_chain`	对齐多行结构 - 链式方法调用（C#）
`resharper_csharp_align_multiline_comments`	对齐多行结构 - 使用星号对齐多行注释（C#）
`resharper_csharp_align_multiline_expression`	对齐多行结构 - 其他表达式（C#）
`resharper_csharp_align_multiline_extends_list`	对齐多行结构 - 基类和接口列表（C#）
`resharper_csharp_align_multiline_for_stmt`	对齐多行结构 - 'for' 语句头部（C#）
`resharper_csharp_align_multiline_list_pattern`	对齐多行结构 - 列表模式和集合表达式（C#）
`resharper_csharp_align_multiline_parameter`	对齐多行结构 - 方法参数（C#）
`resharper_csharp_align_multiline_property_pattern`	对齐多行结构 - 属性模式（C#）
`resharper_csharp_align_multiline_statement_conditions`	对齐多行结构 - 括号内的语句条件（C#）
`resharper_csharp_align_multiline_switch_expression`	对齐多行结构 - Switch 表达式（C#）
`resharper_csharp_align_multiple_declaration`	对齐多行结构 - 多个声明（C#）
`resharper_csharp_align_multline_type_parameter_constrains`	对齐多行结构 - 类型参数约束（C#）
`resharper_csharp_align_multline_type_parameter_list`	对齐多行结构 - 类型参数列表（C#）
`resharper_csharp_align_tuple_components`	对齐多行结构 - 元组组件（C#）
`resharper_csharp_alignment_tab_fill_style`	对齐多行结构 - 使用制表符缩进时的对齐方式（C#）
`resharper_csharp_allow_alias`	引用限定和 'using' 指令 - 使用 using 别名指令解决冲突（C#）
`resharper_csharp_allow_comment_after_lbrace`	大括号布局 - 允许在 '{' 后添加注释（C#）
`resharper_csharp_allow_far_alignment`	对齐多行结构 - 即使结果缩进过大也对齐（C#）
`resharper_csharp_anonymous_method_declaration_braces`	大括号布局 - Lambda 和委托（匿名方法声明）（C#）
`resharper_csharp_arguments_anonymous_function`	参数 - 匿名方法（委托和 lambda 表达式）（C#）
`resharper_csharp_arguments_literal`	参数 - 字面值（C#）
`resharper_csharp_arguments_named`	参数 - 命名表达式（变量、属性、方法等）（C#）
`resharper_csharp_arguments_other`	参数 - 其他（C#）
`resharper_csharp_arguments_skip_single`	参数 - 跳过单个参数（C#）
`resharper_csharp_arguments_string_literal`	参数 - 字符串字面值（C#）
`resharper_csharp_blank_lines_after_block_statements`	代码中的空行 - 在带有子块的语句之后（C#）
`resharper_csharp_blank_lines_after_case`	代码中的空行 - 在 switch 语句中的 'case' 之后（C#）
`resharper_csharp_blank_lines_after_control_transfer_statements`	代码中的空行 - 在带有控制转移的语句之后（C#）
`resharper_csharp_blank_lines_after_file_scoped_namespace_directive`	声明中的空行 - 在文件范围的命名空间指令之后（C#）
`resharper_csharp_blank_lines_after_multiline_statements`	代码中的空行 - 在多行语句之后 (C#)
`resharper_csharp_blank_lines_after_start_comment`	声明中的空行 - 文件头注释后（C#）
`resharper_csharp_blank_lines_after_using_list`	声明中的空行 - 'using' 列表后（C#）
`resharper_csharp_blank_lines_around_accessor`	声明中的空行 - 属性/事件访问器周围（C#）
`resharper_csharp_blank_lines_around_auto_property`	声明中的空行 - 自动/抽象属性/事件周围（C#）
`resharper_csharp_blank_lines_around_block_case_section`	代码中的空行 - 在 switch 语句中带有块的 'case' 部分周围（C#）
`resharper_csharp_blank_lines_around_field`	声明中的空行 - 字段周围（C#）
`resharper_csharp_blank_lines_around_invocable`	声明中的空行 - 方法周围（C#）
`resharper_csharp_blank_lines_around_local_method`	代码中的空行 - 在局部函数周围（C#）
`resharper_csharp_blank_lines_around_multiline_case_section`	代码中的空行 - 在 switch 语句中多行 'case' 部分周围（C#）
`resharper_csharp_blank_lines_around_namespace`	声明中的空行 - 命名空间周围（C#）
`resharper_csharp_blank_lines_around_property`	声明中的空行 - 属性/事件周围（C#）
`resharper_csharp_blank_lines_around_region`	通用 - 区域周围（C#）
`resharper_csharp_blank_lines_around_single_line_accessor`	声明中的空行 - 单行属性/事件访问器周围（C#）
`resharper_csharp_blank_lines_around_single_line_auto_property`	声明中的空行 - 单行自动/抽象属性/事件周围（C#）
`resharper_csharp_blank_lines_around_single_line_field`	声明中的空行 - 在单行字段周围（C#）
`resharper_csharp_blank_lines_around_single_line_invocable`	声明中的空行 - 在单行方法周围（C#）
`resharper_csharp_blank_lines_around_single_line_local_method`	代码中的空行 - 单行局部函数周围（C#）
`resharper_csharp_blank_lines_around_single_line_property`	声明中的空行 - 在单行属性/事件周围（C#）
`resharper_csharp_blank_lines_around_single_line_type`	声明中的空行 - 单行类型周围（C#）
`resharper_csharp_blank_lines_around_type`	声明中的空行 - 在类型周围（C#）
`resharper_csharp_blank_lines_before_block_statements`	代码中的空行 - 在带有子块的语句之前（C#）
`resharper_csharp_blank_lines_before_case`	代码中的空行 - 在 switch 语句中的 'case' 之前（C#）
`resharper_csharp_blank_lines_before_control_transfer_statements`	代码中的空行 - 在带有控制转移的语句之前（C#）
`resharper_csharp_blank_lines_before_multiline_statements`	代码中的空行 - 多行语句之前（C#）
`resharper_csharp_blank_lines_before_single_line_comment`	通用 - 在单行注释之前（C#）
`resharper_csharp_blank_lines_between_using_groups`	声明中的空行 - 在不同的 'using' 组之间（C#）
`resharper_csharp_blank_lines_inside_namespace`	声明中的空行 - 在命名空间内部（C#）
`resharper_csharp_blank_lines_inside_region`	通用 - 在区域内部（C#）
`resharper_csharp_blank_lines_inside_type`	声明中的空行 - 在类型内部（C#）
`resharper_csharp_brace_style`	大括号布局样式（通用）
`resharper_csharp_braces_for_dowhile`	大括号 - 在 'do-while' 语句中（C#）
`resharper_csharp_braces_for_fixed`	大括号 - 在 'fixed' 语句中（C#）
`resharper_csharp_braces_for_for`	大括号 - 在 'for' 语句中（C#）
`resharper_csharp_braces_for_foreach`	大括号 - 在 'foreach' 语句中（C#）
`resharper_csharp_braces_for_ifelse`	大括号 - 在 'if' 语句中（C#）
`resharper_csharp_braces_for_lock`	大括号 - 在 'lock' 语句中（C#）
`resharper_csharp_braces_for_using`	大括号 - 在 'using' 语句中（C#）
`resharper_csharp_braces_for_while`	大括号 - 在 'while' 语句中（C#）
`resharper_csharp_braces_redundant`	大括号 - 删除冗余的大括号（C#）
`resharper_csharp_builtin_type_apply_to_native_integer`	内置类型 - 也适用于本机大小的整数类型（C#）
`resharper_csharp_builtin_type_reference_for_member_access_style`	内置类型 - 在成员访问表达式中，优先使用（C#）
`resharper_csharp_builtin_type_reference_style`	内置类型 - 在局部变量、成员和参数中，优先使用（C#）
`resharper_csharp_can_use_global_alias`	引用限定和 'using' 指令 - 允许使用 'global::' 前缀 (C#)
`resharper_csharp_case_block_braces`	大括号布局 - 'case' 标签下的块（C#）
`resharper_csharp_constructor_or_destructor_body`	代码体 - 构造函数和析构函数（C#）
`resharper_csharp_continuous_indent_multiplier`	通用 - 连续行缩进倍数（C#）
`resharper_csharp_default_internal_modifier`	修饰符 - 更倾向于为类型使用显式/隐式 internal 修饰符（C#）
`resharper_csharp_default_private_modifier`	修饰符 - 更倾向于为类型成员使用显式/隐式 private 修饰符（C#）
`resharper_csharp_default_value_when_type_evident`	默认值 - 当类型从用法中显而易见时（C#）
`resharper_csharp_default_value_when_type_not_evident`	默认值 - 当类型从用法中不显而易见时 (C#)
`resharper_csharp_empty_block_style`	大括号布局 - 空大括号格式化（C#）
`resharper_csharp_extra_spaces`	保留现有格式 - 内部多余空格（C#）
`resharper_csharp_for_built_in_types`	声明中 'var' 的使用 - 对于内置类型（C#）
`resharper_csharp_for_other_types`	声明中 'var' 的使用 - 其他地方（C#）
`resharper_csharp_for_simple_types`	声明中 'var' 的使用 - 对于简单类型（C#）
`resharper_csharp_force_attribute_style`	属性 - 合并或分离节中的属性（C#）
`resharper_csharp_force_chop_compound_do_expression`	二元表达式的排列 - 强制在 'do' 语句中分割复合条件（C#）
`resharper_csharp_force_chop_compound_if_expression`	二元表达式的排列 - 强制在 'if' 语句中分割复合条件（C#）
`resharper_csharp_force_chop_compound_while_expression`	二元表达式的排列 - 强制在 'while' 语句中分割复合条件（C#）
`resharper_csharp_indent_anonymous_method_block`	对齐多行结构 - 匿名方法体（C#）
`resharper_csharp_indent_braces_inside_statement_conditions`	其他缩进 - 在语句条件内缩进大括号（C#）
`resharper_csharp_indent_inside_namespace`	大括号布局 - 在命名空间声明内缩进（C#）
`resharper_csharp_indent_invocation_pars`	括号 - 缩进方法调用的括号（C#）
`resharper_csharp_indent_method_decl_pars`	括号 - 缩进方法声明的括号（C#）
`resharper_csharp_indent_nested_fixed_stmt`	嵌套语句 - 缩进嵌套的“fixed”语句（C#）
`resharper_csharp_indent_nested_for_stmt`	嵌套语句 - 缩进嵌套的 'for' 语句（C#）
`resharper_csharp_indent_nested_foreach_stmt`	嵌套语句 - 缩进嵌套的“foreach”语句（C#）
`resharper_csharp_indent_nested_lock_stmt`	嵌套语句 - 缩进嵌套的“lock”语句（C#）
`resharper_csharp_indent_nested_usings_stmt`	嵌套语句 - 缩进嵌套的“using”语句（C#）
`resharper_csharp_indent_nested_while_stmt`	嵌套语句 - 缩进嵌套的“while”语句（C#）
`resharper_csharp_indent_pars`	括号 - 缩进其他括号和方括号（C#）
`resharper_csharp_indent_preprocessor_if`	预处理指令 - 缩进 #if、#else、#elif、#endif（C#）
`resharper_csharp_indent_preprocessor_other`	预处理指令 - 缩进其他预处理指令（C#）
`resharper_csharp_indent_preprocessor_region`	预处理指令 - 缩进 #region、#endregion（C#）
`resharper_csharp_indent_primary_constructor_decl_pars`	括号 - 主构造函数声明的括号缩进（C#）
`resharper_csharp_indent_raw_literal_string`	对齐多行结构 - 如何缩进原始字符串字面量（C#）
`resharper_csharp_indent_size`	通用 - 缩进大小（C#）
`resharper_csharp_indent_statement_pars`	括号 - 缩进语句（if、while、for 等）的括号（C#）
`resharper_csharp_indent_style`	通用 - 缩进样式（C#）
`resharper_csharp_indent_type_constraints`	其他缩进 - 缩进类型约束（C#）
`resharper_csharp_indent_typearg_angles`	括号 - 类型参数的角括号缩进（C#）
`resharper_csharp_indent_typeparam_angles`	括号 - 类型参数的角括号缩进（C#）
`resharper_csharp_initializer_braces`	大括号布局 - 表达式（初始化器、switch 表达式、模式、集合表达式）（C#）
`resharper_csharp_insert_final_newline`	通用 - 文件末尾的换行符（C#）
`resharper_csharp_instance_members_qualify_declared_in`	实例成员限定 - 限定在（C#）中声明的成员
`resharper_csharp_instance_members_qualify_members`	实例成员限定 - 对其使用 'this.' 限定符（C#）
`resharper_csharp_int_align`	将相似代码对齐到列（通用）
`resharper_csharp_int_align_assignments`	将相似代码对齐到列 - 其他赋值和初始化器（C#）
`resharper_csharp_int_align_binary_expressions`	对齐相似代码到列 - 二元表达式（C#）
`resharper_csharp_int_align_comments`	对齐相似代码为列 - 结束注释 (C#)
`resharper_csharp_int_align_fields`	对齐相似代码为列 - 字段和常量 (C#)
`resharper_csharp_int_align_fix_in_adjacent`	对齐相似代码到列 - 修复相邻行的列对齐（C#）
`resharper_csharp_int_align_invocations`	将相似代码对齐到列 - 相同方法的调用（C#）
`resharper_csharp_int_align_methods`	将相似代码对齐到列 - 简单方法、运算符、委托（C#）
`resharper_csharp_int_align_nested_ternary`	对齐相似代码为列 - 嵌套三元运算符 (C#)
`resharper_csharp_int_align_parameters`	将相似代码对齐到列 - 多行方法签名（C#）
`resharper_csharp_int_align_properties`	对齐相似代码为列 - 属性和事件 (C#)
`resharper_csharp_int_align_property_patterns`	对齐相似代码为列 - 属性模式 (C#)
`resharper_csharp_int_align_switch_expressions`	对齐相似代码为列 - switch 表达式 (C#)
`resharper_csharp_int_align_switch_sections`	对齐相似代码为列 - 简单 switch 部分 (C#)
`resharper_csharp_int_align_variables`	对齐相似代码为列 - 变量和局部常量 (C#)
`resharper_csharp_invocable_declaration_braces`	大括号布局 - 方法声明（C#）
`resharper_csharp_keep_blank_lines_in_code`	代码中的空行 - 保留代码中的最大空行数（C#）
`resharper_csharp_keep_blank_lines_in_declarations`	声明中的空行 - 保留声明中的最大空行数（C#）
`resharper_csharp_keep_existing_arrangement`	保持现有代码排列（单行/多行）（通用）
`resharper_csharp_keep_existing_attribute_arrangement`	属性排列 - 保留现有属性排列（C#）
`resharper_csharp_keep_existing_declaration_block_arrangement`	声明块排列 - 保留现有声明块排列（C#）
`resharper_csharp_keep_existing_declaration_parens_arrangement`	方法签名排列 - 保持声明中括号的现有排列（C#）
`resharper_csharp_keep_existing_embedded_arrangement`	嵌套语句排列 - 保留嵌套语句的现有排列 (C#)
`resharper_csharp_keep_existing_embedded_block_arrangement`	嵌套块排列 - 保留嵌套块的现有排列 (C#)
`resharper_csharp_keep_existing_enum_arrangement`	枚举排列 - 保留枚举的现有排列 (C#)
`resharper_csharp_keep_existing_expr_member_arrangement`	表达式主体成员排列 - 保留现有表达式主体成员排列 (C#)
`resharper_csharp_keep_existing_initializer_arrangement`	初始化器排列 - 保留现有初始化器排列（C#）
`resharper_csharp_keep_existing_invocation_parens_arrangement`	调用排列 - 保持调用中括号的现有排列（C#）
`resharper_csharp_keep_existing_linebreaks`	通用 - 保留现有的换行（C#）
`resharper_csharp_keep_existing_list_patterns_arrangement`	列表模式排列 - 保留列表模式和集合表达式的现有排列 (C#)
`resharper_csharp_keep_existing_primary_constructor_declaration_parens_arrangement`	主构造函数签名排列 - 保持声明中括号的现有排列（C#）
`resharper_csharp_keep_existing_property_patterns_arrangement`	属性模式排列 - 保留属性模式的现有排列 (C#)
`resharper_csharp_keep_existing_switch_expression_arrangement`	switch 表达式排列 - 保留 switch 表达式的现有排列 (C#)
`resharper_csharp_keep_user_linebreaks`	通用 - 保留现有换行（C#）
`resharper_csharp_local_function_body`	代码主体 - 局部函数（C#）
`resharper_csharp_max_array_initializer_elements_on_line`	初始化器的排列 - 单行上的最大数组初始化器和集合表达式元素（C#）
`resharper_csharp_max_attribute_length_for_same_line`	属性排列 - 如果属性部分列表过长，则将其放在单独的行上 (C#)
`resharper_csharp_max_enum_members_on_line`	枚举排列 - 单行中的最大枚举成员数 (C#)
`resharper_csharp_max_formal_parameters_on_line`	方法签名排列 - 单行中的最大正式参数数 (C#)
`resharper_csharp_max_initializer_elements_on_line`	初始化器排列 - 单行中的最大对象和集合初始化器元素数 (C#)
`resharper_csharp_max_invocation_arguments_on_line`	调用排列 - 单行中的最大调用参数数（C#）
`resharper_csharp_max_line_length`	通用 - 硬换行位置（C#）
`resharper_csharp_max_primary_constructor_parameters_on_line`	主构造函数签名排列 - 单行中的最大主构造函数参数数（C#）
`resharper_csharp_method_or_operator_body`	代码主体 - 方法和运算符（C#）
`resharper_csharp_modifiers_order`	修饰符 - 修饰符顺序（C#）
`resharper_csharp_namespace_body`	代码体 - 命名空间（C#）
`resharper_csharp_nested_ternary_style`	三元表达式的排列 - 嵌套三元表达式样式（C#）
`resharper_csharp_new_line_before_while`	语句排列 - 将 'while' 放在新行上（C#）
`resharper_csharp_null_checking_pattern_style`	模式 - 空检查模式样式（C#）
`resharper_csharp_object_creation_when_type_evident`	对象创建 - 当创建的类型从用法中显而易见时（C#）
`resharper_csharp_object_creation_when_type_not_evident`	对象创建 - 当创建的类型从用法中不显而易见时（C#）
`resharper_csharp_old_engine`	ReSharper 其他 - 恢复旧的格式化引擎（C#）
`resharper_csharp_other_braces`	大括号布局 - 其他（C#）
`resharper_csharp_outdent_binary_ops`	对齐多行结构 - 减少二元操作符的缩进（C#）
`resharper_csharp_outdent_binary_pattern_ops`	对齐多行结构 - 减少二元模式的缩进（C#）
`resharper_csharp_outdent_commas`	对齐多行结构 - 减少逗号的缩进（C#）
`resharper_csharp_outdent_dots`	对齐多行结构 - 减少链式方法调用中点的缩进（C#）
`resharper_csharp_outdent_statement_labels`	其他缩进 - 减少语句标签的缩进（C#）
`resharper_csharp_parentheses_group_non_obvious_operations`	添加括号以避免不明显的优先级 - 当以下组的操作嵌套时（C#）
`resharper_csharp_parentheses_non_obvious_operations`	添加括号以避免不明显的优先级 - 在以下操作的操作数周围（C#）
`resharper_csharp_parentheses_redundancy_style`	括号 - 删除多余的括号（C#）
`resharper_csharp_parentheses_same_type_operations`	添加括号以避免不明显的优先级 - 即使是同类型操作的嵌套（C#）
`resharper_csharp_place_abstract_accessorholder_on_single_line`	声明块的排列 - 将抽象/自动属性/索引器/事件声明放在单行（C#）
`resharper_csharp_place_accessor_attribute_on_same_line`	属性的排列 - 将访问器属性放在同一行（C#）
`resharper_csharp_place_accessor_with_attrs_holder_on_single_line`	声明块的排列 - 即使访问器上有属性，也将其放在单行（C#）
`resharper_csharp_place_accessorholder_attribute_on_same_line`	属性的排列 - 将属性/索引器/事件属性放在同一行（C#）
`resharper_csharp_place_attribute_on_same_line`	将简单属性与所有者放在同一行（通用）
`resharper_csharp_place_comments_at_first_column`	其他缩进 - 在注释代码时将注释放在第一列 (C#)
`resharper_csharp_place_constructor_initializer_on_same_line`	方法签名的排列 - 允许构造函数初始化器放在同一行 (C#)
`在单行上放置表达式访问器`	表达式主体成员的排列 - 将属性访问器表达式主体放在同一行（C#）
`在单行上放置表达式方法`	表达式主体成员的排列 - 将方法表达式主体放在同一行（C#）
`在单行上放置表达式属性`	表达式主体成员的排列 - 将属性表达式主体放在同一行（C#）
`将字段属性放在同一行`	属性的排列 - 将字段属性放在同一行（C#）
`将 LINQ 的 into 关键字另起一行`	LINQ 表达式的排列 - 在 LINQ 表达式中将 'into' 放在新行（C#）
`将方法属性放在同一行`	属性的排列 - 将方法属性放在同一行（C#）
`将记录字段属性放在同一行`	属性的排列 - 将记录字段属性放在同一行（C#）
`在单行上放置简单访问器`	声明块的排列 - 将简单访问器放在单行（C#）
`在单行上放置简单访问器容器`	声明块的排列 - 将简单属性/索引器/事件声明放在单行（C#）
`在单行上放置简单匿名方法`	嵌套块的排列 - 将简单匿名方法放在单行（C#）
`在单行上放置简单代码块`	将简单块放在单行（通用）
`将简单 case 语句放在同一行`	嵌套语句的排列 - 将简单 'case' 语句放在同一行（C#）
`在单行上放置简单声明代码块`	将简单类型成员的块放在单行（通用）
`将简单嵌套代码块放在同一行`	嵌套块的排列 - 将包含单个简单语句的块放在同一行（C#）
`将简单嵌套语句放在同一行`	嵌套语句的排列 - 将简单嵌套语句放在同一行（C#）
`在单行上放置简单枚举`	枚举的排列 - 将简单枚举放在单行（C#）
`在单行上放置简单初始化器`	初始化器的排列 - 将简单数组、对象和集合放在单行（C#）
`在单行上放置简单列表模式`	列表模式的排列 - 将简单列表模式和集合表达式放在单行（C#）
`在单行上放置简单方法`	声明块的排列 - 将简单方法放在单行（C#）
`在单行上放置简单属性模式`	属性模式的排列 - 将简单属性模式放在单行（C#）
`在单行上放置简单 switch 表达式`	切换表达式的排列 - 将简单切换表达式放在单行（C#）
`将类型属性放在同一行`	属性排列 - 将类型属性放在同一行 (C#)
`将类型约束放在同一行`	类型参数、约束和基类型的排列 - 允许类型约束放在同一行 (C#)
`倾向使用显式舍弃声明`	'var' 声明的使用 - 对于丢弃值使用 'var' 关键字 (C#)
`倾向使用限定引用`	引用限定和 'using' 指令 - 优先使用完全限定的引用 (C#)
`倾向将解构变量声明分开`	'var' 在声明中的使用 - 对解构变量优先使用单独声明 (C#)
`在嵌套作用域中使用限定 using`	引用限定和 'using' 指令 - 在嵌套作用域中优先使用完全限定的 'using' 名称 (C#)
`移除代码中括号附近的空行`	代码中的空行 - 移除代码中 '{' 后和 '}' 前的空行 (C#)
`移除声明中括号附近的空行`	声明中的空行 - 移除声明中 '{' 后和 '}' 前的空行 (C#)
`使用 System 开头对 using 排序`	引用限定和 'using' 指令 - 排序 'using' 指令时优先放置 'System.' 和 'Windows.' 命名空间 (C#)
`resharper_csharp_space_after_ampersand_op`	一元运算符后 - 不安全的取地址运算符 (&)（C#）
`在乘法运算符 * 后添加空格`	一元运算符后 - 不安全的星号运算符 (*)（C#）
`在属性冒号后添加空格`	围绕冒号 - 在其他冒号之后 (C#)
`在属性后添加空格`	属性 - 属性后（C#）
`在冒号后添加空格`	围绕冒号 - 在其他冒号之后 (C#)
`在 case 中的冒号后添加空格`	围绕冒号 - 在 'case' 语句中的冒号之后 (C#)
`在逻辑非运算符 ! 后添加空格`	一元运算符后 - 逻辑非运算符 (!)（C#）
`在 operator 关键字后添加空格`	其他 - 运算符关键字后（C#）
`在三元运算符的冒号后添加空格`	在三元运算符中 - 在 ':' 之后 (C#)
`在三元运算符的问号后添加空格`	在三元运算符中 - 在 '?' 之后 (C#)
`在类型参数约束冒号后添加空格`	围绕冒号 - 在类型参数约束冒号之后 (C#)
`在一元负号运算符 - 后添加空格`	一元运算符后 - 一元减号运算符 (-)（C#）
`在一元运算符后添加空格`	一元运算符后空格 (!, -, ~,...)（通用）
`在一元正号运算符 + 后添加空格`	一元运算符后 - 一元加号运算符 (+)（C#）
`在加法运算符两边添加空格`	围绕二元运算符 - 加法运算符 (+,-) (C#)
`在别名赋值符号 == 两边添加空格`	其他 - 在命名空间别名指令中的 '=' 周围 (C#)
`在箭头运算符 => 两边添加空格`	在二元运算符周围 - 不安全箭头运算符（->）（C#）
`在赋值运算符两边添加空格`	围绕二元运算符 - 赋值运算符 (如 '=' 和 '+=') (C#)
`在二元运算符两边添加空格`	在二元运算符周围的空格（+，\|\|，=，...）（通用）
`在按位运算符两边添加空格`	围绕二元运算符 - 按位运算符 (&,\|,^) (C#)
`在点操作符 . 两边添加空格`	其他 - 在点号周围 (C#)
`在等值运算符两边添加空格`	在二元运算符周围 - 相等运算符（==，!=）（C#）
`在 lambda 箭头两边添加空格`	其他 - 在 lambda 箭头周围（C#）
`在逻辑运算符两边添加空格`	在二元运算符周围 - 逻辑运算符（&&，\|\|）（C#）
`在成员访问操作符两边添加空格`	在成员访问运算符周围的空格（.，->，...）（通用）
`在乘法运算符两边添加空格`	围绕二元运算符 - 乘法运算符 (*,/,%) (C#)
`在空合并运算符两边添加空格`	在二元运算符周围 - 空合并运算符（??）（C#）
`在关系运算符两边添加空格`	围绕二元运算符 - 关系运算符 (<,>,<=,>=) (C#)
`在移位运算符两边添加空格`	围绕二元运算符 - 移位运算符 (<<,>>,>>>) (C#)
`在三元运算符两边添加空格`	在三元运算符（?，:）周围的空格（通用）
`在数组访问括号前添加空格`	围绕数组括号 - 在数组访问括号之前 (C#)
`在数组维度括号前添加空格`	围绕数组括号 - 在数组维度括号之前 (C#)
`在属性冒号前添加空格`	围绕冒号 - 在其他冒号之前 (C#)
`在 catch 的括号前添加空格`	在语句中的括号之前 - 'catch' 括号 (C#)
`在 checked 的括号前添加空格`	在其他括号之前 - 'checked' 和 'unchecked' 括号 (C#)
`在冒号前添加空格`	围绕冒号 - 在其他冒号之前 (C#)
`在 case 中的冒号前添加空格`	围绕冒号 - 在 'case' 语句中的冒号之前 (C#)
`在 default 的括号前添加空格`	在其他括号之前 - 'default' 括号 (C#)
`在空方法调用的括号前添加空格`	在其他括号之前 - 方法调用空括号 (C#)
`在空方法定义的括号前添加空格`	在其他括号之前 - 方法声明空括号 (C#)
`在 fixed 的括号前添加空格`	在语句中的括号之前 - 'fixed' 括号（C#）
`在 for 的括号前添加空格`	在语句中的括号之前 - 'for' 括号（C#）
`在 foreach 的括号前添加空格`	在语句中的括号之前 - 'foreach' 括号（C#）
`在 if 的括号前添加空格`	在语句中的括号之前 - 'if' 括号 (C#)
`在 lock 的括号前添加空格`	在语句中的括号之前 - 'lock' 括号 (C#)
`在方法调用的括号前添加空格`	在其他括号之前 - 方法调用括号 (C#)
`在方法定义的括号前添加空格`	在其他括号之前 - 方法声明括号 (C#)
`在 nameof 的括号前添加空格`	在其他括号之前 - 'nameof' 括号 (C#)
`在 new 的括号前添加空格`	在其他括号之前 - 'new' 括号 (C#)
`在可空标记 ? 前添加空格`	其他 - 在可空标记之前（C#）
`在指针声明星号前添加空格`	其他 - 在不安全指针声明之前（C#）
`在分号前添加空格`	围绕逗号和分号 - 在分号之前 (C#)
`在单行访问器容器前添加空格`	围绕大括号 - 在单行访问器块之前 (C#)
`在 sizeof 的括号前添加空格`	在其他括号之前 - 'sizeof' 括号 (C#)
`在 switch 的括号前添加空格`	语句中括号之前 - 'switch' 括号（C#）
`在三元运算符的冒号前添加空格`	三元运算符中 - ':' 之前（C#）
`在三元运算符的问号前添加空格`	三元运算符中 - '?' 之前（C#）
`在行尾注释前添加空格`	其他 - 行尾注释之前（C#）
`在类型参数角括号前添加空格`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`在类型参数定义角括号前添加空格`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`在类型参数约束冒号前添加空格`	冒号周围 - 类型参数约束冒号之前（C#）
`在 typeof 的括号前添加空格`	其他括号之前 - 'typeof' 括号（C#）
`在 using 的括号前添加空格`	语句中括号之前 - 'using' 括号（C#）
`在 while 的括号前添加空格`	语句中括号之前 - 'while' 括号（C#）
`在单行属性中访问器之间添加空格`	大括号周围 - 在单行属性/事件访问器之间 (C#)
`在属性部分之间添加空格`	属性 - 在属性部分之间 (C#)
`在关键字和表达式之间添加空格`	其他括号之前 - 关键字和表达式之间（C#）
`在关键字和类型之间添加空格`	其他括号之前 - 关键字和类型之间（C#）
`在控制流语句括号内添加空格`	控制流语句括号内的空格（通用）
`在类型转换括号内添加空格`	其他括号内 - 类型转换括号（C#）
`在单行访问器承载器中添加空格`	大括号周围 - 在单行访问器内 (C#)
`在单行匿名方法中添加空格`	大括号周围 - 在单行匿名方法内 (C#)
`在单行方法中添加空格`	大括号周围 - 在单行方法内 (C#)
`在后缀和前缀运算符附近添加空格`	一元运算符之后 - ++ 和 -- 之前/之后（C#）
`在数组访问方括号内添加空格`	数组括号周围 - 数组访问括号内（C#）
`在数组维度声明的方括号内添加空格`	数组括号周围 - 数组维度括号内（C#）
`在数组空维度声明的方括号内添加空格`	数组括号周围 - 在空数组维度括号内（C#）
`在特性方括号内添加空格`	属性 - 属性括号内（C#）
`在 catch 圆括号内添加空格`	语句中括号内 - 'catch' 括号（C#）
`在 checked 圆括号内添加空格`	其他括号内 - 'checked' 和 'unchecked' 括号（C#）
`在 default 圆括号内添加空格`	其他括号内 - 'default' 括号 (C#)
`在空的大括号内添加空格`	大括号周围 - 空大括号之间的空格 (C#)
`在 fixed 圆括号内添加空格`	语句中的括号内 - 'fixed' 括号 (C#)
`在 for 圆括号内添加空格`	语句中括号内 - 'for' 括号（C#）
`在 foreach 圆括号内添加空格`	语句中括号内 - 'foreach' 括号（C#）
`在 if 圆括号内添加空格`	语句中括号内 - 'if' 括号（C#）
`在列表模式方括号内添加空格`	数组括号周围 - 列表模式和集合表达式括号内（C#）
`在 lock 圆括号内添加空格`	语句中括号内 - 'lock' 括号（C#）
`在 nameof 圆括号内添加空格`	其他括号内 - 'nameof' 括号（C#）
`在 new 圆括号内添加空格`	其他括号内 - 'new' 括号（C#）
`在圆括号对内添加空格`	其他括号内 - 括号（C#）
`在单行数组初始化器的大括号内添加空格`	大括号周围 - 单行表达式大括号内（C#）
`在 sizeof 圆括号内添加空格`	其他括号内 - 'sizeof' 括号（C#）
`在切片模式中添加空格`	其他 - 切片模式中 '..' 之后（C#）
`在 switch 圆括号内添加空格`	语句中括号内 - 'switch' 括号（C#）
`在类型参数尖括号内添加空格`	尖括号周围 - 类型参数尖括号 (C#)
`在类型形参尖括号内添加空格`	尖括号周围 - 类型形参尖括号（C#）
`在 typeof 圆括号内添加空格`	其他括号内 - 'typeof' 括号（C#）
`在 using 圆括号内添加空格`	语句中括号内 - 'using' 括号（C#）
`在 while 圆括号内添加空格`	语句中括号内 - 'while' 括号（C#）
`特殊处理 else if`	通用 - 特殊的 'else if' 处理（C#）
`限定对 static 成员的访问`	静态成员限定 - 需要限定的成员（C#）
`使用指定方式限定 static 成员`	静态成员限定 - 使用名称限定（C#）
`粘附注释`	其他缩进 - 不缩进从第一列开始的注释（C#）
`制表符宽度`	常规 - 制表符宽度 (C#)
`在多行列表中保留尾随逗号`	尾随逗号 - 多行列表中新行前 (C#)
`在单行列表中保留尾随逗号`	尾随逗号 - 当最后一个元素后没有换行时（C#）
`类型声明的大括号设置`	大括号布局 - 类型和命名空间声明 (C#)
`在初始化器大括号中使用连续缩进`	大括号布局 - 在表达式大括号内使用连续行缩进 (C#)
`在括号内使用连续缩进`	括号 - 在括号内使用连续行缩进 (C#)
`使用启发式规则选择语句主体样式`	代码主体 - 应用样式启发式规则（C#）
`使用上一元素的缩进方式`	其他缩进 - 在部分格式中使用前一个元素的缩进 (C#)
`对明显类型使用 Roslyn 逻辑`	'var' 声明中的使用 - 更倾向于 Roslyn（Visual Studio）逻辑以证明类型（C#）
`在声明左括号后换行`	方法签名的排列 - 偏好在声明中 '(' 后换行 (C#)
`在方法调用中点号后换行`	成员访问表达式排列 - 优先在 '.' 后换行 (C#)
`在调用左括号后换行`	调用的排列 - 偏好在调用中 '(' 后换行 (C#)
`在主构造函数声明左括号后换行`	主构造函数签名排列 - 优先在声明中的 '(' 后换行 (C#)
`在链式方法调用中的属性之后换行`	成员访问表达式排列 - 优先在链式方法调用中的属性和字段后换行 (C#)
`参数换行样式`	调用的排列 - 换行调用参数 (C#)
`数组初始化器换行样式`	初始化器排列 - 换行数组初始化器 (C#)
`在 => 表达式前换行`	表达式主体成员排列 - 优先在 '=>' 前换行并跟随表达式 (C#)
`在二元运算符前换行`	二元表达式的排列 - 偏好在二元表达式中的运算符前换行 (C#)
`在二元模式运算符前换行`	二元表达式排列 - 优先在二元模式中的运算符前换行 (C#)
`在逗号前换行`	常规 - 更倾向于在 ',' 前换行 (C#)
`在声明左括号前换行`	方法签名的排列 - 偏好在声明中 '(' 前换行 (C#)
`在声明右括号前换行`	方法签名的排列 - 偏好在声明中 ')' 前换行 (C#)
`在等号前换行`	通用 - 优先在 '=' 前换行（C#）
`在 extends 冒号前换行`	类型参数、约束和基类型排列 - 优先在 ':' 前换行 (C#)
`在首次方法调用前换行`	成员访问表达式排列 - 优先在第一个方法调用前换行 (C#)
`在首个类型形参约束前换行`	类型参数、约束和基类型的排列 - 偏好在第一个约束前换行 (C#)
`在调用左括号前换行`	调用的排列 - 偏好在调用中 '(' 前换行 (C#)
`在调用右括号前换行`	调用的排列 - 偏好在调用中 ')' 前换行 (C#)
`在 LINQ 表达式前换行`	LINQ 表达式排列 - 优先在多行 LINQ 表达式前换行 (C#)
`在主构造函数声明左括号前换行`	主构造函数签名排列 - 优先在声明中的 '(' 前换行 (C#)
`在主构造函数声明右括号前换行`	主构造函数签名排列 - 优先在声明中的 ')' 前换行 (C#)
`在三元运算符前换行`	三元表达式的排列 - 偏好在三元表达式中的 '?' 和 ':' 前换行 (C#)
`在类型形参左尖括号前换行`	类型参数、约束和基类型排列 - 优先在类型参数列表中的开尖括号前换行 (C#)
`在链式二元表达式中换行`	二元表达式的排列 - 换行链式二元表达式 (C#)
`在链式二元模式中换行`	二元表达式排列 - 换行复杂的二元模式 (C#)
`在链式方法调用中换行`	成员访问表达式的排列 - 换行链式方法调用 (C#)
`枚举声明换行设置`	枚举排列 - 换行枚举声明 (C#)
`扩展类列表换行样式`	类型参数、约束和基类型的排列 - 换行扩展/实现列表 (C#)
`for 语句头部换行样式`	语句的排列 - 换行 'for' 语句头部 (C#)
`LINQ 表达式换行样式`	LINQ 表达式排列 - 换行 LINQ 表达式 (C#)
`列表模式换行`	列表模式排列 - 换行列表模式和集合表达式 (C#)
`多重声明换行样式`	语句的排列 - 换行多重声明 (C#)
`多重类型形参约束换行样式`	类型参数、约束和基类型的排列 - 换行多重类型参数约束 (C#)
`对象与集合初始化器换行样式`	初始化器排列 - 换行对象和集合初始化器 (C#)
`函数参数换行样式`	方法签名的排列 - 换行形式参数 (C#)
`主构造函数参数换行样式`	主构造函数签名排列 - 换行主构造函数参数 (C#)
`属性模式换行`	属性模式排列 - 换行属性模式 (C#)
`switch 表达式换行样式`	切换表达式排列 - 换行切换表达式 (C#)
`三元表达式换行样式`	三元表达式的排列 - 换行三元表达式 (C#)
`逐字插值字符串换行样式`	插值字符串的排列 - 换行插值字符串 (C#)
`循环引用注释高亮`	代码检查：引用注释创建了循环依赖
`声明隐藏高亮显示`	代码检查：声明隐藏了外部作用域中的另一个声明
`声明可见性错误高亮显示`	代码检查：导出的实体使用了私有实体
`默认 internal 修饰符`	修饰符 - 更倾向于为类型使用显式/隐式 internal 修饰符（C#）
`默认 private 修饰符`	修饰符 - 更倾向于为类型成员使用显式/隐式 private 修饰符（C#）
`可选参数的默认值特性高亮显示`	代码检查：可能误导的 'DefaultValueAttribute' 用法用于定义可选参数值
`当类型明显时使用默认值`	默认值 - 当类型从用法中显而易见时 (C#)
`当类型不明显时使用默认值`	默认值 - 当类型从用法中不显而易见时（C#）
`删除非限定引用时高亮显示`	代码检查：在 'strict mode' 中对非限定标识符调用 'delete'
`在 using 变量上调用 Dispose 的高亮显示`	代码检查：已被 'using' 语句捕获的变量的处置
`模式中的双重否定高亮显示`	代码检查：简化否定模式
`布尔值的双重否定高亮显示`	代码检查：布尔值的双重否定是多余的
`双重否定运算符高亮显示`	代码检查：双重否定运算符
`重复标识符错误高亮显示`	代码检查：重复的标识符
`重复引用注释高亮显示`	代码检查：重复的引用注释是多余的
`重复资源高亮显示`	代码检查：重复的资源名称
`重复的局部声明高亮显示`	代码检查：重复的局部声明
`重复的参数声明错误高亮显示`	代码检查：在 'strict mode' 中重复的参数声明
`ReSharper 属性重复声明错误高亮显示`	代码检查：在 'strict mode' 中重复的属性声明
`ReSharper 属性重复声明高亮显示`	代码检查：重复的属性声明
`ReSharper switch 标签重复高亮显示`	代码检查：重复的 switch 标签
`ReSharper 忽略尾随元素高亮显示`	代码检查：数组的尾部元素被省略
`ReSharper 空代码块样式`	大括号布局 - 空大括号格式化，可用于： C#
`ReSharper 空构造函数高亮显示`	代码检查：空构造函数
`ReSharper 空析构函数高亮显示`	代码检查：空析构函数
`ReSharper 空内嵌语句高亮显示`	代码检查：空控制语句体
`ReSharper 空 for 语句高亮显示`	代码检查：空的 'for' 循环是多余的
`ReSharper 空通用 catch 子句高亮显示`	代码检查：空的一般 catch 子句
`ReSharper 空命名空间高亮显示`	代码检查：空的命名空间声明
`ReSharper 空对象属性声明高亮显示`	代码检查：预期的对象属性声明
`ReSharper 空 #region 高亮显示`	代码检查：空区域
`ReSharper 类型注解函数缺少返回值高亮显示`	代码检查：类型注解函数的空返回值
`ReSharper 空语句高亮显示`	代码检查：空语句是多余的
`ReSharper 强制 do-while 语句使用大括号高亮显示`	代码检查：使用首选的大括号样式（在 'do-while' 语句中强制使用大括号）
`ReSharper 强制 fixed 语句使用大括号高亮显示`	代码检查：使用首选的大括号样式（在 'fixed' 语句中强制使用大括号）
`强制为 for 语句使用大括号的高亮显示`	代码检查：使用首选的大括号样式（在 'for' 语句中强制使用大括号）
`强制为 foreach 语句使用大括号的高亮显示`	代码检查：使用首选的大括号样式（在 'foreach' 语句中强制使用大括号）
`强制为 if 语句使用大括号的高亮显示`	代码检查：使用首选的大括号样式（在 'if' 语句中强制使用大括号）
`强制为 lock 语句使用大括号的高亮显示`	代码检查：使用首选的大括号样式（在 'lock' 语句中强制使用大括号）
`强制为 using 语句使用大括号的高亮显示`	代码检查：使用首选的大括号样式（在 'using' 语句中强制使用大括号）
`强制为 while 语句使用大括号的高亮显示`	代码检查：使用首选的大括号样式（在 'while' 语句中强制使用大括号）
`Entity Framework 客户端数据库函数调用的高亮显示`	代码检查：数据库函数不得在非数据库上下文中调用
`Entity Framework 模型验证中循环依赖项的高亮显示`	代码检查：此属性定义的关系导致了依赖循环
`Entity Framework 模型验证中无限字符串长度的高亮显示`	代码检查：由于字符串长度无限可能导致性能问题
`Entity Framework N+1 不完整数据查询的高亮显示`	代码检查：查询可能会返回不完整的相关实体数据
`Entity Framework N+1 不完整数据使用的高亮显示`	代码检查：导航属性的使用可能会返回不完整的数据
`Entity Framework N+1 查询的高亮显示`	代码检查：可能对相关实体的数据库进行多次查询（N+1 问题）
`Entity Framework N+1 使用的高亮显示`	代码检查：可能对数据库进行多次查询（N+1 问题）
`Entity Framework 不支持的服务器端函数调用的高亮显示`	代码检查：函数无法转换为 SQL，且不得在数据库上下文中调用
`仅在全局范围捕获的实体名称的高亮显示`	代码检查：实体仅用于捕获其名称（非私有可访问性）
`仅在局部范围捕获的实体名称的高亮显示`	代码检查：实体仅用于捕获其名称（私有可访问性）
`枚举的基础类型为 int 的高亮显示`	代码检查：枚举的基础类型为 'int'
`枚举类型求和操作在显式 unchecked 上下文中的高亮显示`	代码检查：在显式未检查上下文中调用 'Enumerable.Sum'
`等值表达式比较的高亮显示`	代码检查：相似表达式比较
`XML 文档引用中的错误的高亮显示`	代码检查： XML 文档注释引用中的错误
`ES6 功能的高亮显示`	代码检查：在 ES 5 或更低版本中使用 ECMAScript 2015 功能
`ES7 功能的高亮显示`	代码检查：在 ES 2015 或更低版本中使用 ECMAScript 2016 功能
`eval 参数名错误的高亮显示`	代码检查：在 'strict mode' 中使用 'eval'/'arguments' 名称
`全局范围事件从未被调用的高亮显示`	代码检查：抽象或虚拟（可重写）事件从未被调用
`事件从未被调用的高亮显示`	代码检查：事件从未被调用
`全局范围事件从未被订阅的高亮显示`	代码检查：事件从未被订阅（非私有可访问性）
`局部范围事件从未被订阅的高亮显示`	代码检查：事件从未被订阅（私有可访问性）
`通过匿名委托注销事件的高亮显示`	代码检查：通过匿名委托取消事件订阅
`实验功能的高亮显示`	代码检查：在语言级别设置为稳定时使用实验性功能
`显式调用方信息参数的高亮显示`	代码检查：向具有调用者信息属性的参数显式传递参数
`表达式始终为常量的高亮显示`	代码检查：表达式始终为常量
`表达式始终为 null 的高亮显示`	代码检查：表达式始终为 'null'
`多余空格`	保留现有格式 - 内部的额外空格，适用于： C#
`提取公共属性模式的高亮显示`	代码检查：提取公共属性模式
`字段可设为只读（全局范围）的高亮显示`	代码检查：字段可以设为只读（非私有可访问性）
`字段可设为只读（局部范围）的高亮显示`	代码检查：字段可以设为只读（私有可访问性）
`字段隐藏了具有默认实现的接口属性的高亮显示`	代码检查：字段隐藏了接口中具有默认实现的属性
`针对内置类型的建议`	声明中 'var' 的使用 - 对于内置类型（C#）
`for 可转换为 foreach 的高亮显示`	代码检查： For 循环可以转换为 Foreach 循环
`针对其他类型的建议`	声明中 'var' 的使用 - 其他地方（C#）
`针对简单类型的建议`	声明中 'var' 的使用 - 对于简单类型（C#）
`for 语句条件始终为 true 的高亮显示`	代码检查： 'true' 作为 'for' 语句条件是多余的
`强制使用属性样式`	属性 - 合并或分离节中的属性（C#）
`强制拆分 do 复合表达式`	二元表达式的排列 - 强制在 'do' 语句中分割复合条件（C#）
`强制拆分 if 复合表达式`	二元表达式的排列 - 强制在 'if' 语句中分割复合条件（C#）
`强制拆分 while 复合表达式`	二元表达式的排列 - 强制在 'while' 语句中分割复合条件（C#）
`foreach 可转换为使用其他 GetEnumerator 的查询表达式（全部）的高亮显示`	代码检查： Foreach 循环可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法
`foreach 可部分转换为使用其他 GetEnumerator 的查询表达式的高亮显示`	代码检查： Foreach 循环的一部分可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法
`格式化字符串占位符不匹配的高亮显示`	代码检查：格式字符串占位符不匹配
`格式化字符串问题的高亮显示`	代码检查：字符串格式化方法问题
`函数复杂度超过限制的高亮显示`	代码检查：函数体过于复杂，无法分析
`函数从不返回的高亮显示`	代码检查：函数从未返回
`函数参数命名参数使用的高亮显示`	代码检查：参数名称 'arguments' 与预定义的 JS 函数作用域变量冲突
`函数在所有路径上递归的高亮显示`	代码检查：函数在所有执行路径上都是递归的
`函数超出作用域使用的高亮显示`	代码检查：函数在声明范围之外被使用
`函数在声明前使用的高亮显示`	代码检查：函数在声明之前被使用
`没有析构函数的类型调用 GC.SuppressFinalize 的高亮显示`	代码检查： 'GC.SuppressFinalize' 被调用于没有析构函数的类型
`注释中的语法错误高亮显示`	代码检查：注释中的语法错误
`标记属性中的语法错误高亮显示`	代码检查：标记属性值中的语法错误
`标记文本中的语法错误高亮显示`	代码检查：标记文本中的语法错误
`字符串文本中的语法错误高亮显示`	代码检查：字符串字面量中的语法错误
`启发式检测为无法访问的代码的高亮显示`	代码检查：启发式不可达代码
`启发式识别为无法访问代码的高亮显示`	代码检查：启发式不可达代码
`Razor 函数间空行的 HTML 设置`	Razor @functions 块周围的空行 (Razor CSharp)
`Razor 辅助方法间空行的 HTML 设置`	Razor 助手周围的空行 (Razor CSharp)
`Razor 区块间空行的 HTML 设置`	Razor 区段周围的空行 (Razor CSharp)
`Razor 语句周围的 HTML 换行设置`	Razor 语句周围的换行 (Razor CSharp)
`使用旧版 HTML 引擎`	为 Razor 格式化使用旧引擎 (Razor CSharp)
`标识符拼写错误的高亮显示`	代码检查：标识符中的拼写错误
`隐式 any 错误的高亮显示`	代码检查：当设置 NoImplicitAny 时的“隐式 any”检查
`隐式 any 类型警告的高亮显示`	代码检查：元素具有隐式的“any”类型
`import 关键字未与调用一起使用的高亮显示`	代码检查：此处不允许使用“import”关键字
`带有 MustDisposeResource 属性的 in 参数的高亮显示`	代码检查：输入参数的 [MustDisposeResource] 注解无意义
`预处理器中的非活动分支的高亮显示`	代码检查：非活动的预处理器分支
`函数返回不一致的高亮显示`	代码检查：函数返回值不一致
`命名不一致的高亮显示`	代码检查：命名不一致
`锁定顺序不一致的高亮显示`	代码检查：获取锁的顺序不一致
`字段同步不一致的高亮显示`	代码检查：字段上的同步不一致
`大括号附近的空行不正确的高亮显示`	代码检查：空行不正确（大括号附近的空行数量不正确）
`typeof 比较中操作数不正确的高亮显示`	代码检查： “typeof”表达式与不正确的值进行比较
`不正确的三斜线位置的高亮显示`	代码检查：三斜杠指令仅在文件顶部有效
`匿名方法块缩进`	对齐多行结构 - 匿名方法体（C#）
`语句条件中的大括号缩进`	其他缩进 - 在语句条件内缩进大括号（C#）
`select 中的 case 缩进`	其他 - 将“case”缩进到“select”（VB.NET）
`子元素缩进`	标签内容 - 在不包含文本的元素内缩进，可用于：
`命名空间内缩进`	大括号布局 - 在命名空间声明内缩进（C#）
`函数调用参数缩进`	括号 - 方法调用的括号缩进，可用于： C#
`方法声明参数缩进`	括号 - 方法声明的括号缩进，可用于： C#
`嵌套 fixed 语句缩进`	嵌套语句 - 缩进嵌套的 'fixed' 语句（C#）
`嵌套 for 语句缩进`	嵌套语句 - 缩进嵌套的 'for' 语句（C#）
`嵌套 foreach 语句缩进`	嵌套语句 - 缩进嵌套的“foreach”语句（C#）
`嵌套 lock 语句缩进`	嵌套语句 - 缩进嵌套的“lock”语句（C#）
`嵌套 using 语句缩进`	嵌套语句 - 缩进嵌套的“using”语句（C#）
`嵌套 while 语句缩进`	嵌套语句 - 缩进嵌套的“while”语句（C#）
`声明参数缩进`	括号 - 其他括号和方括号的缩进，可用于： C#
`预处理器 #if 缩进`	预处理指令 - 缩进 #if、#else、#elif、#endif（C#）
`其他预处理器指令缩进`	预处理指令 - 缩进其他预处理指令（C#）
`预处理器 #region 缩进`	预处理指令 - 缩进 #region、#endregion（C#）
`主构造函数声明参数缩进`	括号 - 主构造函数声明的括号缩进（C#）
`原始字符串字面量缩进`	对齐多行结构 - 如何缩进原始字符串字面量（C#）
`语句参数缩进`	括号 - 语句（if、while、for 等）的括号缩进，可用于： C#
`switch 标签缩进`	其他缩进 - 从“switch”缩进“case”，可用于： C#
`控制缩进文本`	标签内容 - 在包含文本的元素内缩进，可用于：
`控制类型约束的缩进`	其他缩进 - 类型约束的缩进，可用于： C#
`控制类型参数尖括号的缩进`	括号 - 类型参数的角括号缩进（C#）
`控制类型参数声明尖括号的缩进`	括号 - 类型参数的角括号缩进（C#）
`按无效范围进行索引时的高亮显示`	代码检查：可能的 'System.ArgumentOutOfRangeException'。起始索引必须小于或等于结束索引。
`inheritdoc 使用情况建议高亮显示`	代码检查：在根级别使用 <inheritdoc /> 从基候选项继承文档
`inheritdoc 无效使用高亮显示`	代码检查： <inheritdoc /> 的使用无效
`控制初始化器大括号的格式`	大括号布局 - 表达式（初始化器、switch 表达式、模式、集合表达式）（C#）
`内联 out 变量声明的高亮显示`	代码检查：内联“out”变量声明
`内联临时变量的高亮显示`	代码检查：内联临时变量
`限定实例成员声明所在的类型`	实例成员限定 - 限定在（C#）中声明的成员
`限定实例成员的使用`	实例成员限定 - 对其使用 'this.' 限定符（C#）
`控制整数对齐规则`	对齐相似代码到列（通用化）
`控制赋值语句的对齐`	将相似代码对齐到列 - 其他赋值和初始化器（C#）
`控制二元表达式的对齐`	对齐相似代码到列 - 二元表达式（C#）
`控制注释的对齐`	将相似代码对齐到列 - 结束注释，可用于： C#
`控制字段的对齐`	将相似代码对齐到列 - 字段和常量（C#）
`在相邻元素中修复对齐`	将相似代码对齐到列 - 修复相邻行的列对齐，可用于： C#
`控制调用表达式的对齐`	对齐相似代码为列 - 相同方法的调用 (C#)
`控制方法声明的对齐`	将相似代码对齐到列 - 简单方法、运算符、委托（C#）
`控制嵌套三元表达式对齐`	将相似代码对齐到列 - 嵌套三元运算符（C#）
`控制参数的对齐`	对齐相似代码为列 - 多行方法签名 (C#)
`控制属性的对齐`	对齐相似代码为列 - 属性和事件 (C#)
`控制属性模式的对齐`	对齐相似代码为列 - 属性模式 (C#)
`控制 switch 表达式的对齐`	对齐相似代码为列 - switch 表达式 (C#)
`控制 switch 语句区块的对齐`	对齐相似代码为列 - 简单 switch 部分 (C#)
`控制变量的对齐`	对齐相似代码为列 - 变量和局部常量 (C#)
`除以零的高亮显示`	代码检查：至少一个执行路径中存在除零操作
`整数变量溢出的高亮显示`	代码检查：可能的溢出
`checked 上下文中整数变量溢出的高亮显示`	代码检查：在 checked 上下文中可能的溢出
`unchecked 上下文中整数变量溢出的高亮显示`	代码检查：在 unchecked 上下文中可能的溢出
`internal 模块的高亮显示`	代码检查：立即调用的函数表达式可以转换为内部模块
`internal 或 private 成员未文档化的高亮显示`	代码检查：私有或内部类型或成员缺少 XML 注释
`插值字符串表达式不是 IFormattable 的高亮显示`	代码检查：指定了格式，但插值字符串表达式不是 IFormattable
`建议全局引入可选参数的高亮显示`	代码检查：引入可选参数（非私有可访问性）
`建议局部引入可选参数的高亮显示`	代码检查：引入可选参数（私有可访问性）
`建议通过变量添加保护条件的高亮显示`	代码检查：引入变量将允许应用类型守卫
`无效属性值的高亮显示`	代码检查：无效的属性值
`JSON 语法无效的高亮显示`	代码检查：无效的 JSON 语法
`无效 task 元素的高亮显示`	代码检查：无效的任务元素
`无效值类型的高亮显示`	代码检查：资源值类型无效
`无效的 XML 文档注释的高亮显示`	代码检查：无效的 XML 文档注释
`反转条件建议 1 的高亮显示`	代码检查：反转条件
`反转 if 条件的高亮显示`	代码检查：反转 'if' 语句以减少嵌套
`控制可调用声明的大括号格式`	大括号布局 - 方法声明，可用于： C#
`调用被跳过的高亮显示`	代码检查：方法调用被跳过
`对非函数项的调用高亮显示`	代码检查：调用非函数表达式
`作为扩展方法调用的高亮显示`	代码检查：将静态方法调用转换为扩展方法调用
`被调用表达式可能不是函数的高亮显示`	代码检查：调用的表达式不是函数值
`is 表达式恒为 false 的高亮显示`	代码检查： 'is' 运算符的表达式从不属于提供的类型
`is 表达式恒为 true 的高亮显示`	代码检查： 'is' 运算符的给定表达式始终属于提供的类型
`迭代器方法的返回值被忽略的高亮显示`	代码检查：迭代器的返回值未被使用
`迭代器方法不返回的高亮显示`	代码检查：迭代器从不返回
`可以合并声明与初始化的高亮显示`	代码检查：合并局部变量声明和赋值
`可以合并 JavaScript 中的声明与初始化的高亮显示`	代码检查：合并局部变量声明和赋值
`可以将 null 检查与使用合并的高亮显示`	代码检查：将空检查与赋值合并
`JavaScript 大括号样式设置`	大括号布局样式（通用）
`找不到 JavaScript 路径的高亮显示`	代码检查：未找到引用注释的路径
`方法调用名与左括号之间的空格`	方法调用括号之前的空格 (通用)
`方法声明名与左括号之间的空格`	方法声明括号之前的空格 (通用)
`方括号之间的空格`	括号内的空格 (通用)
`不可达 JavaScript 代码的高亮显示`	代码检查：不可达代码
`JSON 验证失败的高亮显示`	代码检查： JSON 验证失败
`jump 语句必须在循环中使用的高亮显示`	代码检查：在循环体外使用 'break' 或 'continue'
`保持声明之间的空行`	空行 - 声明之间的最大空行数，适用于：
`保持代码中的空行`	代码中的空行 - 保持代码中的最大空行数，适用于： C#、 VB.NET
`保持声明中的空行`	声明中的空行 - 保持声明中的最大空行数，适用于： C#、 VB.NET
`保留现有的排列方式`	保持现有代码排列（单行/多行）（通用）
`保留现有的属性排列`	属性排列 - 保留现有的属性排列（C#）
`保留现有的声明块排列`	声明块排列 - 保留现有声明块排列（C#）
`保留现有的声明括号排列`	方法签名排列 - 保持声明中括号的现有排列（C#）
`保留现有的内嵌排列`	嵌套语句排列 - 保留现有嵌套语句排列（C#）
`保留现有的内嵌块排列`	嵌套块排列 - 保留现有嵌套块排列（C#）
`保留现有的枚举排列`	枚举排列 - 保留枚举的现有排列 (C#)
`保留现有的表达式成员排列`	表达式主体成员排列 - 保留现有表达式主体成员排列 (C#)
`保留现有的初始化器排列`	初始化器排列 - 保留初始化器的现有排列 (C#)
`保留现有的调用括号排列`	调用排列 - 保持调用中括号的现有排列（C#）
`保留现有换行`	通用 - 保留现有换行（C#）
`保留现有的列表模式排列`	列表模式排列 - 保留现有列表模式和集合表达式排列（C#）
`保留现有的主构造函数声明括号排列`	主构造函数签名排列 - 保持声明中括号的现有排列（C#）
`保留现有的属性模式排列`	属性模式排列 - 保留属性模式的现有排列 (C#)
`保留现有的 switch 表达式排列`	switch 表达式排列 - 保留 switch 表达式的现有排列 (C#)
`保留用户换行`	通用 - 保持现有换行，适用于： C#、 VB.NET
`需要 l 值的高亮显示`	代码检查：需要左值错误
`需要标签或分号的高亮显示`	代码检查：在 'break' 或 'continue' 之后使用表达式
`Lambda 表达式可以声明为 static 的高亮显示`	代码检查： Lambda 表达式/匿名方法可以设为 'static'
`Lambda 表达式必须声明为 static 的高亮显示`	代码检查： Lambda 表达式/匿名方法必须设为 'static' 以避免分配
`Lambda 表达式的高亮显示`	代码检查：函数表达式可以转换为 Lambda 表达式
`Lambda 不应捕获上下文的高亮显示`	代码检查： Lambda 表达式/匿名方法不得捕获包含上下文
`比主签名更不具体的重载的高亮显示`	代码检查：重载比主签名更不具体
`词法声明需要代码块的高亮显示`	代码检查：词法声明只能在块内声明
`元素前的换行`	标签周围 - 将以下元素放在新行，适用于：
`多行元素前的换行`	标签周围 - 将多行元素放在新行，适用于：
`单行元素前的换行`	标签周围 - 将单行元素放在新行上，可用于：
`Razor 语句周围的换行`	Razor 语句周围的换行 (Razor CSharp)
`元素长度超过指定值时在标签内换行`	标签内容 - 当元素长度超过时，在起始标签后和结束标签前换行，适用于：
`包含子元素时在标签内换行`	标签周围 - 在包含其他元素且无文本的元素中，在起始标签后和结束标签前换行，适用于：
`多行元素在标签内换行`	标签周围 - 在多行元素中，在起始标签后和结束标签前换行，适用于：
`本地函数体设置`	代码体 - 本地函数（C#）
`本地函数可设为 static 的高亮显示`	代码检查：本地函数可以设为 static
`本地函数隐藏方法的高亮显示`	代码检查：本地函数隐藏了方法
`本地函数后续重新定义的高亮显示`	代码检查：本地函数稍后被重新定义
`局部变量隐藏成员的高亮显示`	代码检查：本地变量隐藏了成员
`局部变量隐藏主构造函数参数的高亮显示`	代码检查：本地变量隐藏了主构造函数参数
`可本地化元素突出显示`	代码检查：元素是可本地化的
`以小写“l”结尾的长整型字面量突出显示`	代码检查： 'l' 后缀容易与数字 '1' 混淆
`循环可转换为查询的突出显示`	代码检查：循环可以转换为 LINQ 表达式
`循环可部分转换为查询的突出显示`	代码检查：循环体的一部分可以转换为 LINQ 表达式
`循环变量在循环内未更改的突出显示`	代码检查：循环控制变量在循环内从未更改
`多余的 Math.Abs 方法调用突出显示`	代码检查： Math.Abs() 参数始终为非负数
`Math.Clamp 最小值大于最大值的突出显示`	代码检查：传递给 'Math.Clamp()' 方法的参数不一致
`一行上的数组初始值元素数量上限`	初始化器排列 - 单行中的最大数组初始化器和集合表达式元素数（C#）
`同一行属性的最大长度`	属性排列 - 如果属性部分列表过长，则将其放在单独的行上 (C#)
`标签之间最大空行数`	标签周围 - 标签之间的最大空行数，适用于：
`一行上的枚举成员数量上限`	枚举排列 - 单行中的最大枚举成员数 (C#)
`一行上的形式参数数量上限`	方法签名排列 - 单行中的最大正式参数数 (C#)
`一行上的初始值元素数量上限`	初始化器排列 - 单行中的最大对象和集合初始化器元素数 (C#)
`一行上的调用参数数量上限`	调用排列 - 单行中的最大调用参数数（C#）
`一行上的主构造函数参数数量上限`	主构造函数签名排列 - 单行中的最大主构造函数参数数（C#）
`无意义的默认参数值突出显示`	代码检查： 'DefaultParameterValueAttribute' 必须与 'OptionalAttribute' 一起使用
`成员可设为文件本地的突出显示`	代码检查：类型可以设为文件本地
`成员可设为 internal 的突出显示`	代码检查：成员或类型可以设为内部 (友元)
`成员可设为 static（全局）的突出显示`	代码检查：成员可以设为静态 (共享) (非私有可访问性)
`成员可设为 static（局部）的突出显示`	代码检查：成员可以设为静态 (共享) (私有可访问性)
`成员可设为 private（全局）的突出显示`	代码检查：成员可以设为私有 (非私有可访问性)
`成员可设为 private（局部）的突出显示`	代码检查：成员可以设为私有 (私有可访问性)
`成员可设为 protected（全局）的突出显示`	代码检查：成员可以设为受保护 (非私有可访问性)
`成员可设为 protected（局部）的突出显示`	代码检查：成员可以设为受保护 (私有可访问性)
`成员隐藏默认实现的接口成员的突出显示`	代码检查：实现类中的非公共成员隐藏了接口中的默认实现
`成员隐藏外部类中的静态成员的突出显示`	代码检查：成员隐藏了外部类的静态成员
`成员初始化值被忽略的突出显示`	代码检查：成员初始化的值被忽略
`合并 and 模式的突出显示`	代码检查：合并 'and' 模式
`合并类型检查和强制转换的突出显示`	代码检查：类型检查和强制转换可以合并
`合并条件表达式的突出显示`	代码检查：将条件 ?: 表达式合并为条件访问
`合并为逻辑模式的突出显示`	代码检查：将空值/模式/值检查合并为 'or'/'and' 模式
`合并为取反模式的突出显示`	代码检查：将取反的空值/模式检查合并为复杂模式
`合并为模式的突出显示`	代码检查：将空值/模式检查合并为复杂模式
`合并嵌套属性模式的突出显示`	代码检查：合并嵌套属性模式
`合并顺序检查的突出显示`	代码检查：将连续检查合并为单个条件访问检查
`方法具有 async 重载的突出显示`	代码检查：方法具有异步重载
`方法具有带取消功能的 async 重载的突出显示`	代码检查：方法具有支持取消的异步重载
`方法或运算符主体`	代码体 - 方法和运算符（C#）
`带可选参数的方法重载突出显示`	代码检查：带有可选或 'params' 参数的方法被重载隐藏
`方法支持安全的 this 用法的突出显示`	代码检查：由函数赋值的成员可以转换为函数成员
`方法支持取消功能的突出显示`	代码检查：方法支持取消
`asmdef 文件名不匹配的突出显示`	代码检查：文件名应与程序集名称匹配
`缺失属性的突出显示`	代码检查：缺少必需的属性
`缺失空行的突出显示`	代码检查：空行不正确 (其他地方缺少空行)
`foreach 中缺失 hasOwnProperty 检查的突出显示`	代码检查：在 'for in' 循环体中没有 .hasOwnProperty() 检查。这将导致枚举原型属性。
`缺失缩进的突出显示`	代码检查：缩进不正确 (其他地方缺少缩进/缩出)
`缺失换行符的突出显示`	代码检查：换行不正确 (其他地方缺少换行)
`缺失空格的突出显示`	代码检查：间距不正确 (其他地方缺少间距)
`错误使用函数所有者的 this 的突出显示`	代码检查：在内部函数中误用 'this' 限定符
`修饰符顺序`	修饰符 - 修饰符顺序（C#）
`foreach 变量类型可更具体的突出显示`	代码检查：迭代变量可以用更具体的类型声明
`更具体的签名位于不太具体签名之后的突出显示`	代码检查：更具体的签名跟随不太具体的签名
`将局部函数移至跳转语句之后的突出显示`	代码检查：将局部函数放在 'return' 或 'continue' 之后
`移至现有位置解构模式中的突出显示`	代码检查：移动到现有的位置解构模式
`将变量声明移至循环条件内的突出显示`	代码检查：将变量声明移到循环条件内
`foreach 中的多重声明突出显示`	代码检查： 'for in' 错误中的多个声明
`多重可空属性使用的突出显示`	代码检查：多个可空属性的使用
`多个 order by 的突出显示`	代码检查：多次连续调用 'OrderBy'
`多个 output 标签的突出显示`	代码检查：定义了多个输出标签
`文本中多个解析候选项的突出显示`	代码检查：文本参数中存在模糊符号
`多个空格的突出显示`	代码检查：间距不正确（禁止多个空格）
`一行中的多个语句突出显示`	代码检查：换行不正确（同一行包含多个语句）
`一行中的多个类型成员突出显示`	代码检查：换行不正确（同一行包含多个类型成员）
`必须使用返回值的突出显示`	代码检查： [MustUseReturnValue] 注解方法的返回值未被使用
`未解析的 MVC 操作的突出显示`	代码检查： MVC（未知操作）
`未解析的 MVC 区域的突出显示`	代码检查： MVC（未知区域）
`未解析的 MVC 控制器的突出显示`	代码检查： MVC（未知控制器）
`无效的 MVC 模型类型的突出显示`	代码检查： MVC（模型类型不匹配）
`未解析的 MVC 主页面的突出显示`	代码检查： MVC（未知母版页）
`未解析的 MVC 局部视图的突出显示`	代码检查： MVC（未知部分视图）
`未解析的 MVC 模板的突出显示`	代码检查： MVC（未知模板）
`未解析的 MVC 视图组件的突出显示`	代码检查： MVC（未知视图组件）
`未解析的 MVC 视图组件视图的突出显示`	代码检查： MVC（未知视图组件视图）
`未解析的 MVC 视图的突出显示`	代码检查： MVC（未知视图）
`NUnit 异步方法必须返回 Task 的突出显示`	代码检查： NUnit。异步测试方法必须返回 Task 或 Task<T>
`NUnit 属性生成的测试过多的突出显示`	代码检查： NUnit。指定的属性值生成了过多的测试。
`NUnit AutoFixture 参数类型不正确的突出显示`	代码检查： NUnit.AutoFixture。参数类型不兼容或参数值不正确。
`NUnit AutoFixture 缺失 Test 或 TestFixture 属性的突出显示`	代码检查： NUnit.AutoFixture。缺少 Test 或 TestFixture 属性。
`NUnit InlineAutoData 属性中的冗余参数突出显示`	代码检查： NUnit.AutoFixture。 InlineAutoData 属性中存在多余的参数。
`NUnit 测试中的重复值突出显示`	代码检查： NUnit。重复的值。
`NUnit 中忽略的参数属性突出显示`	代码检查： NUnit。被忽略的参数属性。
`NUnit 中隐含未指定空值的突出显示`	代码检查： NUnit。隐式未指定的空值。
`NUnit 中参数类型与属性不兼容的突出显示`	代码检查： NUnit。参数类型不兼容或参数值不正确。
`NUnit 中预期结果类型错误的突出显示`	代码检查： NUnit。预期结果类型不兼容或值不正确。
`NUnit 中范围边界不正确的突出显示`	代码检查： NUnit。范围边界不正确。 'to' 必须大于或等于 'from'。
`NUnit 拥有参数但带 Test 属性的方法的突出显示`	代码检查： NUnit。未为测试方法参数提供值。
`NUnit TestCase 属性中缺失参数的突出显示`	代码检查： NUnit。 TestCase 属性中缺少参数。
`NUnit 未提供值的突出显示`	代码检查： NUnit。属性中未提供任何值。
`NUnit 中带 Test 属性的非公共方法的突出显示`	代码检查： NUnit。非公共测试方法。
`NUnit 中参数类型与属性不兼容的突出显示`	代码检查： NUnit。指定的值与测试参数类型不兼容。
`NUnit Range 属性的边界超出范围的突出显示`	代码检查： NUnit。范围内的值与测试参数的类型不匹配。
`NUnit Range 步长符号不匹配的突出显示`	代码检查： NUnit。范围步长符号不匹配。
`NUnit Range 步长值不能为零的突出显示`	代码检查： NUnit。范围的 'step' 参数值必须为非零。
`NUnit Range 中目标值不可达的突出显示`	代码检查： NUnit。使用当前步长值无法达到最大范围值。
`NUnit TestCase 属性中冗余参数的突出显示`	代码检查： NUnit。 TestCase 属性中存在多余的参数。
`NUnit 中将冗余参数用作预期结果的突出显示`	代码检查： NUnit。多余的参数代替了 ExpectedResult。
`NUnit TestCase 属性中冗余的预期结果突出显示`	代码检查： NUnit。对于 void 测试方法，多余的预期结果。
`NUnit TestCase 属性需要预期结果的突出显示`	代码检查： NUnit。对于非 void 测试方法，缺少预期结果。
`NUnit TestCase 的 result 属性重复预期结果的突出显示`	代码检查： NUnit。测试用例的 Result 属性与 ExpectedResult 重复。
`NUnit TestCase 的 result 属性已弃用的突出显示`	代码检查： NUnit。测试用例的 Result 属性已过时。
`resharper_n_unit_test_case_source_must_be_field_property_method_highlighting`	代码检查： NUnit。测试用例的来源必须是字段、属性或方法。
`resharper_n_unit_test_case_source_must_be_static_highlighting`	代码检查： NUnit。测试用例的来源必须是静态的。
`resharper_n_unit_test_case_source_should_implement_i_enumerable_highlighting`	代码检查： NUnit。测试用例的来源必须是非抽象的并实现 IEnumerable。
`resharper_namespace_body`	代码主体 - 命名空间（C#）
`resharper_native_type_prototype_extending_highlighting`	代码检查：扩展原生对象的原型
`resharper_native_type_prototype_overwriting_highlighting`	代码检查：覆盖原生对象的原型
`resharper_negation_of_relational_pattern_highlighting`	代码检查：简化取反的关系模式
`resharper_negative_equality_expression_highlighting`	代码检查：简化负等式表达式
`resharper_negative_index_highlighting`	代码检查：可能的 'System.ArgumentOutOfRangeException'。索引必须是非负整数。
`resharper_nested_string_interpolation_highlighting`	代码检查：嵌套的字符串插值可以内联
`resharper_nested_ternary_style`	三元表达式的排列 - 嵌套三元表达式样式（C#）
`resharper_new_line_before_catch`	语句的排列 - 将 'catch' 放在新行上，可用于： C#
`resharper_new_line_before_else`	语句的排列 - 将 'else' 放在新行上，可用于： C#
`resharper_new_line_before_finally`	语句的排列 - 将 'finally' 放在新行上，可用于： C#
`resharper_new_line_before_while`	语句的排列 - 将 'while' 放在新行上，可用于： C#
`resharper_non_assigned_constant_highlighting`	代码检查：未赋值的常量
`resharper_non_atomic_compound_operator_highlighting`	代码检查：可疑的 'volatile' 字段使用：复合操作不是原子的。 'Interlocked' 类可以代替使用。
`resharper_non_constant_equality_expression_has_constant_result_highlighting`	代码检查：根据位掩码的值，表达式结果将始终相同
`resharper_non_parsable_element_highlighting`	代码检查：部分代码无法解析
`resharper_non_readonly_member_in_get_hash_code_highlighting`	代码检查：在 'GetHashCode()' 中引用了非只读类型成员
`resharper_not_accessed_field_compiler_highlighting`	代码检查：未访问的字段
`resharper_not_accessed_field_global_highlighting`	代码检查：未访问的字段（非私有访问性）
`resharper_not_accessed_field_local_highlighting`	代码检查：未访问的字段（私有访问性）
`resharper_not_accessed_out_parameter_variable_highlighting`	代码检查：未访问的局部变量，仅用于丢弃 'out' 参数值
`resharper_not_accessed_positional_property_global_highlighting`	代码检查：未访问的位置属性（非私有访问性）
`resharper_not_accessed_positional_property_local_highlighting`	代码检查：未访问的位置属性（私有可访问性）
`resharper_not_accessed_primary_constructor_parameter_compiler_highlighting`	代码检查：未访问的主构造函数参数
`resharper_not_accessed_variable_compiler_highlighting`	代码检查：未访问的局部变量
`resharper_not_accessed_variable_highlighting`	代码检查：未访问的局部变量
`resharper_not_all_paths_return_value_highlighting`	代码检查：并非所有代码路径都返回值
`resharper_not_assigned_out_parameter_highlighting`	代码检查： 'out' 参数在退出时未被赋值
`resharper_not_declared_in_parent_culture_highlighting`	代码检查：资源未在基础文化中声明
`resharper_not_disposed_resource_highlighting`	代码检查：带有 [MustDisposeResource] 注解的方法的返回值从未被释放
`resharper_not_disposed_resource_is_returned_by_property_highlighting`	代码检查：属性的返回值必须由调用方释放
`resharper_not_disposed_resource_is_returned_highlighting`	代码检查：返回值必须被释放，但方法或函数未带有 [MustDisposeResource] 注解
`resharper_not_null_or_required_member_is_not_initialized_highlighting`	代码检查：不可为空或必需的成员在构造函数退出时未被初始化
`resharper_not_observable_annotation_redundancy_highlighting`	代码检查：空属性用于无法从其他代码直接引用的声明
`resharper_not_overridden_in_specific_culture_highlighting`	代码检查：资源未在特定文化中被重写
`resharper_not_resolved_highlighting`	代码检查：无法解析符号
`resharper_not_resolved_in_text_highlighting`	代码检查：无法解析文本参数中的符号
`resharper_null_checking_pattern_style`	模式 - 空检查模式样式（C#）
`resharper_null_coalescing_condition_is_always_not_null_according_to_api_contract_highlighting`	代码检查：根据可空引用类型的注解，'??' 条件永远不为空
`resharper_nullable_warning_suppression_is_used_highlighting`	代码检查：被抑制的可空警告可能隐藏潜在问题
`resharper_nullness_annotation_conflict_with_jet_brains_annotations_highlighting`	代码检查：可空性与层次结构中的注解冲突
`resharper_object_creation_as_statement_highlighting`	代码检查：由 'new' 表达式创建的对象可能未被分配
`resharper_object_creation_when_type_evident`	对象创建 - 当创建的类型从用法中显而易见时（C#）
`resharper_object_creation_when_type_not_evident`	对象创建 - 当创建的类型从用法中不显而易见时（C#）
`resharper_object_destructuring_without_parentheses_highlighting`	代码检查：非括号化的对象解构赋值不能在表达式语句中使用
`resharper_object_literals_are_not_comma_free_highlighting`	代码检查：对象字面量中缺少逗号
`resharper_obsolete_element_error_highlighting`	代码检查：使用了过时的类型或类型成员（错误）
`resharper_obsolete_element_highlighting`	代码检查：使用了过时的类型或类型成员
`resharper_octal_literals_not_allowed_error_highlighting`	代码检查：在 'strict mode' 中使用八进制字面量和转义序列
`resharper_old_engine`	ReSharper 其他 - 恢复旧的格式化引擎（C#）
`resharper_one_way_operation_contract_with_return_type_highlighting`	代码检查：单向操作不得返回值
`resharper_operation_contract_without_service_contract_highlighting`	代码检查：方法被标记为 OperationContract，但包含的类型未标记为 ServiceContract
`resharper_operator_is_can_be_used_highlighting`	代码检查：可以使用操作符 'is'/'Type Of ... Is ...'
`resharper_operator_without_matched_checked_operator_highlighting`	代码检查：操作符没有匹配的检查操作符
`resharper_optional_parameter_hierarchy_mismatch_highlighting`	代码检查：在重写方法中可选参数值不匹配
`resharper_optional_parameter_ref_out_highlighting`	代码检查：带有 [Optional] 属性的 'ref' 或 'out' 参数
`resharper_other_braces`	大括号布局 - 其他，可用于： C#
`resharper_out_parameter_value_is_always_discarded_global_highlighting`	代码检查：参数输出值始终被丢弃（非私有可访问性）
`resharper_out_parameter_value_is_always_discarded_local_highlighting`	代码检查：参数输出值始终被丢弃（私有可访问性）
`resharper_outdent_binary_ops`	对齐多行结构 - 减少二元操作符的缩进（C#）
`resharper_outdent_binary_pattern_ops`	对齐多行结构 - 减少二元模式的缩进（C#）
`resharper_outdent_commas`	对齐多行结构 - 减少逗号缩进，可用于： C#
`resharper_outdent_dots`	对齐多行结构 - 减少链式方法调用中点的缩进，可用于： C#
`resharper_outdent_is_off_prev_level_highlighting`	代码检查：缩进不正确（缩进级别未恢复）
`resharper_outdent_statement_labels`	其他缩进 - 减少语句标签的缩进（C#）
`resharper_output_tag_required_highlighting`	代码检查：需要输出标签
`resharper_overload_signature_inferring_highlighting`	代码检查：可能的重载可以通过函数体推断
`resharper_overridden_with_empty_value_highlighting`	代码检查：资源用空值覆盖了基础资源
`resharper_overridden_with_same_value_highlighting`	代码检查：资源被覆盖为相同的值
`resharper_parameter_doesnt_make_any_sense_highlighting`	代码检查：参数不是主签名的一部分
`resharper_parameter_hides_member_highlighting`	代码检查：参数隐藏了成员
`resharper_parameter_hides_primary_constructor_parameter_highlighting`	代码检查：参数隐藏了主构造函数参数
`resharper_parameter_only_used_for_precondition_check_global_highlighting`	代码检查：参数仅用于前置条件检查（非私有可访问性）
`resharper_parameter_only_used_for_precondition_check_local_highlighting`	代码检查：参数仅用于前置条件检查（私有可访问性）
`resharper_parameter_type_can_be_enumerable_global_highlighting`	代码检查：参数类型可以是 IEnumerable<T>（非私有可访问性）
`resharper_parameter_type_can_be_enumerable_local_highlighting`	代码检查：参数类型可以是 IEnumerable<T>（私有可访问性）
`resharper_parameter_value_is_not_used_highlighting`	代码检查：参数值未被使用
`resharper_parentheses_group_non_obvious_operations`	添加括号以避免不明显的优先级 - 当以下组的操作嵌套时（C#）
`resharper_parentheses_non_obvious_operations`	添加括号以避免不明显的优先级 - 在以下操作的操作数周围（C#）
`resharper_parentheses_redundancy_style`	括号 - 删除多余的括号（C#）
`resharper_parentheses_same_type_operations`	添加括号以避免不明显的优先级 - 即使是同类型操作嵌套时（C#）
`resharper_partial_method_parameter_name_mismatch_highlighting`	代码检查：参数名称在部分方法声明中不同
`resharper_partial_method_with_single_part_highlighting`	代码检查：方法声明中多余的 'partial' 修饰符
`resharper_partial_type_with_single_part_highlighting`	代码检查：类型声明中多余的 'partial' 修饰符
`resharper_pass_string_interpolation_highlighting`	代码检查：传递字符串插值表达式
`resharper_pattern_always_matches_highlighting`	代码检查：源表达式始终匹配提供的模式
`resharper_pattern_is_always_true_or_false_highlighting`	代码检查：模式始终为 'true' 或始终为 'false'
`resharper_pattern_is_redundant_highlighting`	代码检查：模式是多余的，不会产生任何运行时检查
`resharper_pattern_never_matches_highlighting`	代码检查：源表达式从不匹配提供的模式
`resharper_pi_attribute_style`	处理指令 - 属性格式，可用于：
`resharper_pi_attributes_indent`	处理指令 - 属性缩进，可用于：
`resharper_place_abstract_accessorholder_on_single_line`	声明块的排列 - 将抽象/自动属性/索引器/事件声明放在单行（C#）
`resharper_place_accessor_attribute_on_same_line`	属性的排列 - 将访问器属性放在同一行（C#）
`resharper_place_accessor_with_attrs_holder_on_single_line`	声明块的排列 - 即使访问器上有属性，也将其放在单行上（C#）
`resharper_place_accessorholder_attribute_on_same_line`	属性的排列 - 将属性/索引器/事件属性放在同一行（C#）
`resharper_place_assignment_expression_into_block_highlighting`	代码检查：将赋值表达式放入块中
`resharper_place_attribute_on_same_line`	将简单属性与所有者放在同一行（通用）
`resharper_place_comments_at_first_column`	其他缩进 - 注释代码时将注释放在第一列，可用于： C#
`resharper_place_constructor_initializer_on_same_line`	方法签名的排列 - 允许构造函数初始化器放在同一行 (C#)
`在同一行放置事件属性`	属性 - 将事件属性放在同一行 (VB.NET)
`将表达式访问器放在单行中`	表达式主体成员的排列 - 将属性访问器表达式主体放在同一行（C#）
`将表达式方法放在单行中`	表达式主体成员的排列 - 将方法表达式主体放在同一行（C#）
`将表达式属性放在单行中`	表达式主体成员的排列 - 将属性表达式主体放在同一行（C#）
`在同一行放置字段属性`	属性的排列 - 将字段属性放在同一行（C#）
`在新行放置 LINQ into`	LINQ 表达式的排列 - 在 LINQ 表达式中将 'into' 放在新行（C#）
`在同一行放置方法属性`	属性的排列 - 将方法属性放在同一行（C#）
`在同一行放置属性属性`	属性 - 将属性的属性放在同一行 (VB.NET)
`在同一行放置 record 字段属性`	属性的排列 - 将记录字段属性放在同一行（C#）
`将简单访问器放在单行中`	声明块的排列 - 将简单访问器放在单行（C#）
`将 simpleAccessorholder 放在单行中`	声明块的排列 - 将简单属性/索引器/事件声明放在单行（C#）
`将简单匿名方法放在单行中`	嵌套块的排列 - 将简单匿名方法放在单行（C#）
`将简单语句块放在单行中`	将简单块放在单行（通用）
`在同一行放置简单 case 语句`	嵌套语句的排列 - 将简单 'case' 语句放在同一行（C#）
`将简单声明块放在单行中`	将简单类型成员的块放在单行（通用）
`在同一行放置简单嵌入块`	嵌套块的排列 - 将只有一个简单语句的块放在同一行 (C#)
`在同一行放置简单嵌入语句`	嵌套语句的排列 - 将简单嵌套语句放在同一行（C#）
`将简单枚举放在单行中`	枚举的排列 - 将简单枚举放在单行（C#）
`将简单初始化器放在单行中`	初始化器的排列 - 将简单数组、对象和集合放在单行（C#）
`将 simpleListPattern 放在单行中`	列表模式的排列 - 将简单列表模式和集合表达式放在单行（C#）
`将简单方法放在单行中`	声明块的排列 - 将简单方法放在单行（C#）
`将 simplePropertyPattern 放在单行中`	属性模式的排列 - 将简单属性模式放在单行（C#）
`将简单 switch 表达式放在单行中`	切换表达式的排列 - 将简单切换表达式放在单行（C#）
`在同一行放置类型属性`	属性排列 - 将类型属性放在同一行 (C#)
`在同一行放置类型约束`	类型参数、约束和基类型的排列 - 允许类型约束在同一行，可用于： C#
`多态字段类事件调用高亮显示`	代码检查：多态字段式事件的调用
`潜在的无限继承高亮显示`	代码检查：可能的无限继承
`可能有意重新抛出异常的高亮显示`	代码检查：可能有意的异常重新抛出
`可能存在接口成员歧义的高亮显示`	代码检查：通过接口访问成员时可能的歧义
`可能的无效类型转换异常高亮显示`	代码检查：可能的 'System.InvalidCastException'
`foreach 循环中可能的无效类型转换异常高亮显示`	代码检查：在 foreach 循环中可能的 'System.InvalidCastException'
`可能的无效操作异常高亮显示`	代码检查：可能的 'System.InvalidOperationException'
`可能存在精度丢失的高亮显示`	代码检查：可能的分数丢失
`可能错误的参数高亮显示`	代码检查：可能的错误参数
`可能误用 GetType 方法（类型 1）的高亮显示`	代码检查：可能错误地调用了 GetType()
`可能误用 GetType 方法（类型 2）的高亮显示`	代码检查：可能错误地调用了 GetType()
`可能多次枚举的高亮显示`	代码检查：可能的多次枚举
`双重检查锁中可能的多次写访问高亮显示`	Code Inspection: Possible incorrect implementation of Double-Check Locking pattern. 可能对已检查字段的多次写入访问。
`可能的空引用异常高亮显示`	代码检查：可能的 'System.NullReferenceException'
`可能对非变量 struct 的 struct 成员修改高亮显示`	代码检查：赋值给非变量限定符表达式的属性可能会丢失
`在 Set 中可能意图之外的线性搜索高亮显示`	代码检查：在集合中可能无意的线性搜索
`可能意图之外使用 Queryable.AsEnumerable 高亮显示`	代码检查： IQueryable 可能无意中用作 IEnumerable
`可能的意外引用比较高亮显示`	代码检查：可能无意的引用比较
`可能的写入自身高亮显示`	代码检查：可能对 'Me' 的写入
`对 readonly 变量调用可能不纯的方法的高亮显示`	代码检查：在只读变量上调用可能不纯的结构体方法：结构体值在调用前总是被复制
`语句可能被错误折断的高亮显示`	代码检查：语句可能被换行符错误地中断
`索引器初始化器中可能缺少逗号的高亮显示`	代码检查：索引器初始化器前可能缺少逗号
`可能错误使用插值字符串插入的高亮显示`	代码检查：可能无意的字符串插值而非格式字符串模板
`可能未赋值的属性高亮显示`	代码检查：可能使用了未赋值的属性或全局变量
`偏好显式丢弃声明`	'var' 声明的使用 - 对于丢弃值使用 'var' 关键字 (C#)
`偏好限定引用`	引用限定和 'using' 指令 - 优先使用完全限定的引用，可用于： C#、 Razor CSharp、 VB.NET
`偏好将解构变量分开声明`	'var' 声明的使用 - 对解构变量优先使用单独的声明 (C#)
`私有字段可转换为局部变量的高亮显示`	代码检查：私有字段可以转换为局部变量
`私有变量可设为 readonly 的高亮显示`	代码检查：私有类字段可以设为只读
`属性可设为仅支持 init 的全局高亮显示`	代码检查：属性可以设为仅初始化 (非私有访问权限)
`属性可设为仅支持 init 的局部高亮显示`	代码检查：属性可以设为仅初始化 (私有访问权限)
`property 字段关键字从未被赋值的高亮显示`	代码检查：后备字段已使用但从未赋值
`property 字段关键字从未被使用的高亮显示`	代码检查：后备字段已赋值但从未使用
`属性 getter 不能有参数的高亮显示`	代码检查：属性 getter 不能有参数
`属性未解析的高亮显示`	代码检查：无法解析属性
`属性 setter 必须只有一个参数的高亮显示`	代码检查：属性 setter 必须有一个参数
`protobuf 大括号样式`	大括号布局样式（通用）
`抽象类中存在公共构造函数的高亮显示`	代码检查：在抽象类中将构造函数设为受保护
`void 方法上的 [Pure] 特性高亮显示`	代码检查： 'void' 方法带有 [Pure] 属性注解
`限定表达式为 null 的高亮显示`	代码检查：限定符为 'null' 或 'undefined'
`限定表达式可能为 null 的高亮显示`	代码检查：限定符可能为 'null' 或 'undefined'
`在嵌套作用域中使用限定 using`	引用限定和 'using' 指令 - 在嵌套作用域中优先使用完全限定的 'using' 名称 (C#)
`引号样式`	引号 - 引号样式，可用于：
`原始字符串可简化的高亮显示`	代码检查：原始字符串可以简化
`Razor 始终使用行尾大括号样式`	为 C# 覆盖大括号样式以始终使用 '行尾 (K&R 样式)'（Razor CSharp）
`Razor 布局未解析高亮显示`	代码检查：未知的 Razor 布局
`Razor 中偏好限定引用`	为 @inherits 和 @model 指令使用完全限定的名称 (Razor CSharp)
`Razor 删除大括号附近的空行`	在 @functions (Razor CSharp) 中删除 '{' 后和 '}' 前的空行
`Razor 中删除 this 限定符`	始终删除 'this.' 限定符 (覆盖相应的 C# 设置) (Razor CSharp)
`Razor 段未解析高亮显示`	代码检查：未知的 Razor 部分
`双重检查锁中读取访问高亮显示`	Code Inspection: Possible incorrect implementation of Double-Check Locking pattern. 读取已检查字段的访问。
`冗余 abstract 修饰符高亮显示`	代码检查：多余的 'abstract' 修饰符
`冗余访问器主体高亮显示`	代码检查：多余的访问器主体
`冗余总是匹配子模式高亮显示`	代码检查：始终匹配的子模式是多余的
`匿名类型属性名称冗余高亮显示`	代码检查：多余的匿名类型属性显式名称
`参数默认值冗余高亮显示`	代码检查：具有默认值的多余参数
`冗余数组创建表达式高亮显示`	代码检查：数组创建可以替换为数组初始化器
`冗余数组下界说明高亮显示`	代码检查：多余的数组下界指定
`冗余赋值高亮显示`	代码检查：赋值未被使用
`冗余属性圆括号高亮显示`	代码检查：如果属性没有参数，则括号是多余的
`冗余属性后缀高亮显示`	代码检查：多余的 'Attribute' 后缀
`冗余 AttributeUsage 属性高亮显示`	代码检查：多余的 [AttributeUsage] 属性属性赋值
`冗余基类构造函数调用高亮显示`	代码检查：多余的基类构造函数调用
`冗余 base 限定符高亮显示`	代码检查：多余的 'base.' 限定符
`冗余空行高亮显示`	代码检查：不正确的空行（其他地方的空行是多余的）
`冗余代码块高亮显示`	代码检查：多余的代码块
`冗余布尔比较高亮显示`	代码检查：多余的布尔比较
`冗余 CallerArgumentExpression 默认值高亮显示`	代码检查：传递给调用方参数表达式参数的多余参数
`冗余 case 标签高亮显示`	代码检查：多余的 'case' 标签
`冗余强制类型转换高亮显示`	代码检查：多余的强制转换
`冗余 catch 子句高亮显示`	代码检查：多余的 catch 子句
`赋值前冗余检查高亮显示`	代码检查：赋值前的多余条件检查
`冗余集合初始化器元素大括号高亮显示`	代码检查：集合初始化器中的多余大括号
`与布尔值冗余比较高亮显示`	代码检查：布尔值与布尔值的比较等同于值或取反值
`冗余 ConfigureAwait 高亮显示`	代码检查：多余的 'ConfigureAwait(true)'
`ReSharper 冗余声明分号高亮显示`	代码检查：类型或命名空间声明后的多余分号
`ReSharper 冗余默认成员初始化器高亮显示`	代码检查：多余的成员初始化器
`ReSharper 冗余委托创建高亮显示`	代码检查：显式委托创建表达式是多余的
`ReSharper 在添加之前多余的 ContainsKey 检查高亮显示`	代码检查：在添加到集合之前多余的字典 'ContainsKey'
`ReSharper 冗余丢弃声明高亮显示`	代码检查：多余的丢弃符号指定
`ReSharper 冗余 else 块高亮显示`	代码检查：多余的 'else' 块
`ReSharper 冗余空 case/else 语句高亮显示`	代码检查：多余的空 'Case Else' 语句
`ReSharper 冗余空构造函数高亮显示`	代码检查：没有参数的多余空构造函数
`ReSharper 冗余空 finally 块高亮显示`	代码检查：多余的空 finally 块
`ReSharper 冗余空对象创建参数列表高亮显示`	代码检查：对象创建表达式上的多余空参数列表
`ReSharper 冗余空对象或集合初始化器高亮显示`	代码检查：多余的空对象或集合初始化器
`ReSharper 冗余空 switch 分支高亮显示`	代码检查：多余的空 switch 部分
`ReSharper 对 default 分支使用的冗余枚举标签高亮显示`	代码检查：默认部分前的多余 'case' 标签
`ReSharper 冗余 enumerable.Cast 调用高亮显示`	代码检查：多余的 'IEnumerable.Cast<T>' 或 'IEnumerable.OfType<T>' 调用
`ReSharper 冗余显式数组创建高亮显示`	代码检查：数组创建中的多余显式类型
`ReSharper 冗余显式数组大小高亮显示`	代码检查：数组创建中的多余显式大小指定
`ReSharper 冗余显式 Nullable 创建高亮显示`	代码检查：多余的显式可空类型创建
`ReSharper 冗余显式 params 数组创建高亮显示`	代码检查： 'params' 参数的参数中的多余显式数组创建
`ReSharper 冗余显式位置属性声明高亮显示`	代码检查：多余的显式位置属性声明
`ReSharper 冗余显式元组组件名称高亮显示`	代码检查：多余的显式元组组件名称
`ReSharper 冗余继承列表条目高亮显示`	代码检查：基类型列表中的多余类或接口指定
`ReSharper 冗余 fixed 指针声明高亮显示`	代码检查：多余的固定指针声明
`ReSharper 冗余 if-else 块高亮显示`	代码检查：多余的 'else' 关键字
`ReSharper 冗余 if 语句中的 then 关键字高亮显示`	代码检查：在多行 'If' 语句中，'Then' 关键字是多余的
`ReSharper 冗余立即委托调用高亮显示`	代码检查：立即委托调用
`ReSharper 冗余中间变量高亮显示`	代码检查：中间局部变量是多余的，可以安全地内联
`ReSharper 冗余 is 与关系模式组合使用高亮显示`	代码检查：多余的 'is'
`ReSharper 冗余迭代器关键字高亮显示`	代码检查：没有 'Yield' 语句的迭代器函数
`ReSharper 冗余跳转语句高亮显示`	代码检查：多余的控制流跳转语句
`ReSharper 冗余 Lambda 参数类型高亮显示`	代码检查：多余的 lambda 表达式参数类型说明
`ReSharper 冗余 Lambda 签名括号高亮显示`	代码检查：多余的 lambda 签名括号
`ReSharper 冗余换行符高亮显示`	代码检查：不正确的换行（其他地方的换行是多余的）
`ReSharper 冗余局部类名高亮显示`	代码检查：多余的局部类名
`ReSharper 冗余局部函数名称高亮显示`	代码检查：多余的局部函数名
`ReSharper 冗余逻辑条件表达式操作数高亮显示`	代码检查：逻辑条件表达式中的多余操作数
`ReSharper 冗余 me 限定符高亮显示`	代码检查：多余的 'Me.' 限定符
`ReSharper 冗余 MyBase 限定符高亮显示`	代码检查：多余的 'MyBase.' 限定符
`ReSharper 冗余 MyClass 限定符高亮显示`	代码检查：多余的 'MyClass.' 限定符
`ReSharper 冗余名称限定符高亮显示`	代码检查：多余的名称限定符
`ReSharper 冗余非空约束高亮显示`	代码检查：对由非空基类型约束的类型参数的多余 'notnull' 约束
`ReSharper 在引用类型约束上冗余的可空注解高亮显示`	代码检查：对由非空基类型约束的类型参数的 'class?' 约束的多余可空注解
`ReSharper 可空类型约束具有非可空基类时的冗余可空注解高亮显示`	代码检查：对由另一个非空基类型约束的类型参数的基类型约束的多余可空注解
`ReSharper 可空类型约束具有非可空类型类别时的冗余可空注解高亮显示`	代码检查：对具有非空类型种类的类型参数的基类型约束的多余可空注解
`ReSharper 冗余 nullable 指令高亮显示`	代码检查：多余的可空指令
`ReSharper 冗余 NullableFlow 属性高亮显示`	代码检查：多余的可空属性
`ReSharper 冗余可空类型标记高亮显示`	代码检查：对可空类型的类型检查等同于对底层类型的检查
`ReSharper 可空引用类型下冗余的 Nullness 属性高亮显示`	代码检查： [NotNull] 或 [CanBeNull] 属性应用于已从可空引用类型中获得相同注解的类型
`ReSharper 冗余溢出检查上下文高亮显示`	代码检查：多余的算术溢出检查上下文
`ReSharper 冗余全局重载高亮显示`	代码检查：多余的方法重载（非私有可访问性）
`ReSharper 冗余局部重载高亮显示`	代码检查：多余的方法重载（私有可访问性）
`ReSharper 冗余被重写成员高亮显示`	代码检查：多余的成员重写
`ReSharper 冗余 params 修饰符高亮显示`	代码检查： 'params' 修饰符在重写中始终被忽略
`ReSharper 冗余父类型声明高亮显示`	代码检查：在 extends/implements 中多余的父类型说明
`ReSharper 冗余括号高亮显示`	代码检查：移除多余的括号
`ReSharper 冗余模式括号高亮显示`	代码检查：移除多余的模式匹配括号
`ReSharper 冗余属性括号高亮显示`	代码检查：无参数属性的括号是多余的
`ReSharper 冗余属性模式子句高亮显示`	代码检查：多余的属性模式子句
`ReSharper 冗余限定符高亮显示`	代码检查：多余的限定符
`ReSharper 冗余查询语句中的 ascending 关键字高亮显示`	代码检查：多余的 'orderby' 子句中的 'ascending' 关键字
`ReSharper 冗余范围界限高亮显示`	代码检查：多余的范围边界
`ReSharper 冗余 readonly 修饰符高亮显示`	代码检查：多余的 'readonly' 修饰符
`ReSharper 冗余 record class 关键字高亮显示`	代码检查：记录声明中多余的 'class' 关键字
`ReSharper 冗余作用域参数修饰符高亮显示`	代码检查：多余的 'scoped' 参数修饰符
`ReSharper 冗余 setter value 参数声明高亮显示`	代码检查：显式的 'value' 参数声明是多余的
`ReSharper 冗余空格高亮显示`	代码检查：不正确的空格（其他地方的空格是多余的）
`ReSharper 冗余 string.Format 调用高亮显示`	代码检查：多余的 'string.Format()' 调用
`ReSharper 冗余字符串插值高亮显示`	代码检查：多余的字符串插值
`ReSharper 冗余 string.ToCharArray 调用高亮显示`	代码检查：多余的 'string.ToCharArray()' 调用
`ReSharper 冗余 string 类型高亮显示`	代码检查：多余的字符串类型
`ReSharper 冗余用于抑制可空警告的表达式高亮显示`	代码检查：多余的可空警告抑制表达式
`ReSharper 冗余三元表达式高亮显示`	代码检查：多余的条件三元表达式用法
`ReSharper 针对值类型冗余的 ToString 调用高亮显示`	代码检查：对值类型的冗余 'object.ToString()' 调用
`ReSharper 冗余 ToString 调用高亮显示`	代码检查：冗余的 'object.ToString()' 调用
`ReSharper 冗余方法类型参数高亮显示`	代码检查：方法的冗余类型参数
`ReSharper 冗余类型转换高亮显示`	代码检查：类型转换是多余的：表达式始终为提供的类型
`ReSharper 冗余结构类型转换高亮显示`	代码检查：类型转换是多余的：表达式是结构兼容的类型
`ReSharper 冗余模式中的类型检查高亮显示`	代码检查：模式中的冗余类型检查
`ReSharper 冗余类型声明体高亮显示`	代码检查：冗余的类型声明体
`ReSharper 冗余 unsafe 上下文高亮显示`	代码检查：不安全上下文声明是多余的
`ReSharper 冗余全局 using 指令高亮显示`	代码检查：冗余的全局 using 指令
`ReSharper 冗余 using 指令高亮显示`	代码检查：冗余的 using 指令
`ReSharper 冗余变量类型说明高亮显示`	代码检查：类型说明是多余的，因为变量类型可以从赋值值的类型上下文中确定
`ReSharper 冗余逐字前缀高亮显示`	代码检查：冗余的逐字前缀
`ReSharper 冗余逐字字符串前缀高亮显示`	代码检查：冗余的逐字字符串前缀
`ReSharper 冗余 virtual 修饰符高亮显示`	代码检查：冗余的 'virtual' 修饰符
`ReSharper 冗余 with cancellation 高亮显示`	代码检查：冗余的 'WithCancellation()' 调用
`ReSharper 冗余 with 表达式高亮显示`	代码检查：空的 'with' 表达式是多余的
`ReSharper 针对值类型使用 ReferenceEquals 的高亮显示`	代码检查： 'Object.ReferenceEquals' 始终为 false，因为它是用值类型调用的
`ReSharper 正则表达式检查高亮显示`	代码检查：正则表达式检查
`ReSharper 删除括号附近的空行`	在 @functions (Razor CSharp) 中删除 '{' 后和 '}' 前的空行
`ReSharper 删除代码中括号附近的空行`	代码中的空行 - 删除代码中 '{' 后和 '}' 前的空行，可用于： C#
`ReSharper 删除声明中括号附近的空行`	声明中的空行 - 删除声明中 '{' 后和 '}' 前的空行，适用于： C#
`ReSharper 删除构造函数调用高亮显示`	代码检查：删除构造函数调用
`ReSharper 删除冗余大括号高亮显示`	代码检查：使用首选的大括号样式（删除多余的大括号）
`ReSharper 删除 ‘或’ 语句中恒等于 false 的部分高亮显示`	代码检查：删除冗余语句
`ReSharper 删除 ‘或’ 语句中恒等于 true 的部分高亮显示`	代码检查：删除冗余语句
`resharper_remove_this_qualifier`	始终删除 'this.' 限定符（覆盖相应的 C# 设置）(Razor CSharp)
`resharper_remove_to_list_1_highlighting`	代码检查：移除 ToList()
`resharper_remove_to_list_2_highlighting`	代码检查：移除 ToList()
`resharper_replace_async_with_task_return_highlighting`	代码检查：将 'async' 代码替换为 'Task'-返回
`resharper_replace_auto_property_with_computed_property_highlighting`	代码检查：用计算属性替换自动属性
`resharper_replace_conditional_expression_with_null_coalescing_highlighting`	代码检查：条件表达式可以重写为空合并
`resharper_replace_indicing_with_array_destructuring_highlighting`	代码检查：后续索引器可以替换为解构声明或赋值
`resharper_replace_indicing_with_short_hand_properties_after_destructuring_highlighting`	代码检查：对象字面量字段中的后续索引器可以通过解构简化
`resharper_replace_object_pattern_with_var_pattern_highlighting`	代码检查：将不执行任何额外检查的对象模式替换为 'var' 模式
`resharper_replace_sequence_equal_with_constant_pattern_highlighting`	代码检查：用常量模式替换 'SequenceEqual'
`resharper_replace_slice_with_range_indexer_highlighting`	代码检查：用范围索引器替换 'Slice'
`resharper_replace_substring_with_range_indexer_highlighting`	代码检查：用范围索引器替换 'Substring'
`resharper_replace_undefined_checking_series_with_object_destructuring_highlighting`	代码检查：一系列属性的未定义检查可以用解构替换
`resharper_replace_with_destructuring_swap_highlighting`	代码检查：中间局部变量是多余的，因为它可以用解构交换表达式替换
`resharper_replace_with_field_keyword_highlighting`	代码检查：替换为 'field' 关键字
`resharper_replace_with_first_or_default_1_highlighting`	代码检查：替换为 FirstOrDefault($args$)
`resharper_replace_with_first_or_default_2_highlighting`	代码检查：替换为 FirstOrDefault($args$)
`resharper_replace_with_first_or_default_3_highlighting`	代码检查：替换为 FirstOrDefault($args$)
`resharper_replace_with_first_or_default_4_highlighting`	代码检查：替换为 FirstOrDefault($args$)
`resharper_replace_with_last_or_default_1_highlighting`	代码检查：替换为 LastOrDefault($args$)
`resharper_replace_with_last_or_default_2_highlighting`	代码检查：替换为 LastOrDefault($args$)
`resharper_replace_with_last_or_default_3_highlighting`	代码检查：替换为 LastOrDefault($args$)
`resharper_replace_with_last_or_default_4_highlighting`	代码检查：替换为 LastOrDefault($args$)
`resharper_replace_with_of_type_1_highlighting`	代码检查：替换为 OfType<T>()
`resharper_replace_with_of_type_2_highlighting`	代码检查：替换为 OfType<T>()
`resharper_replace_with_of_type_3_highlighting`	代码检查：替换为 OfType<T>()
`resharper_replace_with_of_type_any_1_highlighting`	代码检查：替换为 OfType<T>().Any()
`resharper_replace_with_of_type_any_2_highlighting`	代码检查：替换为 OfType<T>().Any()（替换为 OfType<T>().Any(..)）
`resharper_replace_with_of_type_count_1_highlighting`	代码检查：替换为 OfType<T>().Count()
`resharper_replace_with_of_type_count_2_highlighting`	代码检查：替换为 OfType<T>().Count()（替换为 OfType<T>().Count(..)）
`resharper_replace_with_of_type_first_1_highlighting`	代码检查：替换为 OfType<T>().First()
`resharper_replace_with_of_type_first_2_highlighting`	代码检查：替换为 OfType<T>().First()（替换为 OfType<T>().First(..)）
`resharper_replace_with_of_type_first_or_default_1_highlighting`	代码检查：替换为 OfType<T>().FirstOrDefault()
`resharper_replace_with_of_type_first_or_default_2_highlighting`	代码检查：替换为 OfType<T>().FirstOrDefault()（替换为 OfType<T>().FirstOrDefault(..)）
`resharper_replace_with_of_type_last_1_highlighting`	代码检查：替换为 OfType<T>().Last()
`resharper_replace_with_of_type_last_2_highlighting`	代码检查：替换为 OfType<T>().Last()（替换为 OfType<T>().Last(..)）
`resharper_replace_with_of_type_last_or_default_1_highlighting`	代码检查：替换为 OfType<T>().LastOrDefault()
`resharper_replace_with_of_type_last_or_default_2_highlighting`	代码检查：替换为 OfType<T>().LastOrDefault()（替换为 OfType<T>().LastOrDefault(..)）
`resharper_replace_with_of_type_long_count_highlighting`	代码检查：替换为 OfType<T>().LongCount()
`resharper_replace_with_of_type_single_1_highlighting`	代码检查：替换为 OfType<T>().Single()
`resharper_replace_with_of_type_single_2_highlighting`	代码检查：替换为 OfType<T>().Single()（替换为 OfType<T>().Single(..)）
`resharper_replace_with_of_type_single_or_default_1_highlighting`	代码检查：替换为 OfType<T>().SingleOrDefault()
`resharper_replace_with_of_type_single_or_default_2_highlighting`	代码检查：替换为 OfType<T>().SingleOrDefault()（替换为 OfType<T>().SingleOrDefault(..)）
`resharper_replace_with_of_type_where_highlighting`	代码检查：替换为 OfType<T>().Where()（替换为 OfType<T>().Where(..)）
`resharper_replace_with_primary_constructor_parameter_highlighting`	代码检查：替换为主构造函数参数
`resharper_replace_with_simple_assignment_false_highlighting`	代码检查：替换为简单赋值
`resharper_replace_with_simple_assignment_true_highlighting`	代码检查：替换为简单赋值
`resharper_replace_with_single_assignment_false_highlighting`	代码检查：替换为单一赋值
`resharper_replace_with_single_assignment_true_highlighting`	代码检查：替换为单一赋值
`resharper_replace_with_single_call_to_any_highlighting`	代码检查：替换为单次调用 Any(..)
`resharper_replace_with_single_call_to_count_highlighting`	代码检查：替换为单次调用 Count(..)
`resharper_replace_with_single_call_to_first_highlighting`	代码检查：替换为单次调用 First(..)
`resharper_replace_with_single_call_to_first_or_default_highlighting`	代码检查：替换为单次调用 FirstOrDefault(..)
`resharper_replace_with_single_call_to_last_highlighting`	代码检查：替换为单次调用 Last(..)
`resharper_replace_with_single_call_to_last_or_default_highlighting`	代码检查：替换为单次调用 LastOrDefault(..)
`resharper_replace_with_single_call_to_single_highlighting`	代码检查：替换为单次调用 Single(..)
`resharper_replace_with_single_call_to_single_or_default_highlighting`	代码检查：替换为单次调用 SingleOrDefault(..)
`resharper_replace_with_single_or_default_1_highlighting`	代码检查：替换为 SingleOrDefault($args$)
`resharper_replace_with_single_or_default_2_highlighting`	代码检查：替换为 SingleOrDefault($args$)
`resharper_replace_with_single_or_default_3_highlighting`	代码检查：替换为 SingleOrDefault($args$)
`resharper_replace_with_single_or_default_4_highlighting`	代码检查：替换为 SingleOrDefault($args$)
`resharper_replace_with_string_is_null_or_empty_highlighting`	代码检查：使用 'String.IsNullOrEmpty'
`resharper_required_base_types_conflict_highlighting`	代码检查：所需的基类型与另一个类型冲突
`resharper_required_base_types_direct_conflict_highlighting`	代码检查： '[BaseTypeRequired]' 属性中指定的类型与另一个类型冲突
`resharper_required_base_types_is_not_inherited_highlighting`	代码检查：需要基类型
`resharper_resource_item_not_resolved_highlighting`	代码检查：无法解析资源项
`resharper_resource_not_resolved_highlighting`	代码检查：无法解析资源
`resharper_resx_not_resolved_highlighting`	代码检查：无法解析符号
`resharper_return_from_global_scopet_with_value_highlighting`	代码检查：全局范围内的 return 语句带有值
`resharper_return_of_task_produced_by_using_variable_highlighting`	代码检查：返回由 'using' 捕获的对象生成的任务
`resharper_return_of_using_variable_highlighting`	代码检查：返回由 'using' 语句捕获的变量
`resharper_return_type_can_be_enumerable_global_highlighting`	代码检查：返回类型可以是 IEnumerable<T>（非私有访问权限）
`resharper_return_type_can_be_enumerable_local_highlighting`	代码检查：返回类型可以是 IEnumerable<T>（私有访问权限）
`resharper_return_type_can_be_not_nullable_highlighting`	代码检查：函数的返回类型可以是非可空的
`resharper_return_value_of_pure_method_is_not_used_highlighting`	代码检查：纯方法的返回值未被使用
`resharper_route_templates_action_route_prefix_can_be_extracted_to_controller_route_highlighting`	代码检查：操作的路由前缀可以提取到控制器的路由中
`resharper_route_templates_ambiguous_matching_constraint_constructor_highlighting`	代码检查：匹配了多个参数约束的构造函数
`resharper_route_templates_constraint_argument_cannot_be_converted_highlighting`	代码检查：路由参数约束的参数无法转换为目标类型
`resharper_route_templates_controller_route_parameter_is_not_passed_to_methods_highlighting`	代码检查：控制器的路由参数可以传递给方法
`resharper_route_templates_duplicated_parameter_highlighting`	代码检查：路由中声明的参数重复
`resharper_route_templates_matching_constraint_constructor_not_resolved_highlighting`	代码检查：未找到匹配的参数约束构造函数
`resharper_route_templates_method_missing_route_parameters_highlighting`	代码检查：并非所有路由参数都传递给了方法
`resharper_route_templates_optional_parameter_can_be_preceded_only_by_single_period_highlighting`	代码检查：可选参数在段中只能以单个句点（'.'）为前缀
`resharper_route_templates_optional_parameter_must_be_at_the_end_of_segment_highlighting`	代码检查：可选参数必须位于段的末尾
`resharper_route_templates_parameter_constraint_can_be_specified_highlighting`	代码检查：可以根据方法参数的类型添加路由参数约束
`resharper_route_templates_parameter_type_and_constraints_mismatch_highlighting`	代码检查：参数的类型不满足路由模板中声明的约束
`resharper_route_templates_parameter_type_can_be_made_stricter_highlighting`	代码检查：由于应用的约束，参数的类型可以更严格
`resharper_route_templates_route_parameter_constraint_not_resolved_highlighting`	代码检查：路由参数约束未解析
`resharper_route_templates_route_parameter_is_not_passed_to_method_highlighting`	代码检查：路由参数可以传递给方法
`resharper_route_templates_route_token_not_resolved_highlighting`	代码检查：路由标记未解析
`resharper_route_templates_symbol_not_resolved_highlighting`	代码检查：符号未解析
`resharper_route_templates_syntax_error_highlighting`	代码检查：语法错误
`resharper_safe_cast_is_used_as_type_check_highlighting`	代码检查：尝试类型转换并检查空值可以替换为类型检查
`resharper_same_imports_with_different_name_highlighting`	代码检查：同一项以不同名称导入了两次
`resharper_same_variable_assignment_highlighting`	代码检查：将局部变量赋值给自身是多余的
`resharper_sealed_member_in_sealed_class_highlighting`	代码检查：密封类中的密封成员
`resharper_separate_control_transfer_statement_highlighting`	代码检查：用空行分隔控制转移语句
`resharper_separate_local_functions_with_jump_statement_highlighting`	代码检查：在局部函数之前添加显式的 'return' 或 'continue'
`缺少操作的服务契约`	代码检查：标记为 ServiceContract 的接口应至少声明一个 OperationContract
`ShaderLab 对齐制表符填充样式`	制表符和缩进 - 使用制表符进行缩进时如何对齐（ShaderLab）
`允许 ShaderLab 远距离对齐`	制表符和缩进 - 即使结果缩进过大也要对齐（ShaderLab）
`ShaderLab 大括号样式`	大括号布局样式（通用化）
`ShaderLab 缩进大小`	制表符和缩进 - 缩进大小（ShaderLab）
`ShaderLab 缩进样式`	制表符和缩进 - 缩进样式（ShaderLab）
`ShaderLab 制表符宽度`	制表符和缩进 - 制表符宽度（ShaderLab）
`移位表达式的实际移位数为零`	代码检查：实际移位计数等于零
`移位表达式结果等于零`	代码检查：具有非零操作数的常量移位表达式结果为零值
`移位表达式的右操作数与实际移位数不相等`	代码检查：对于此类型的左操作数，移位计数可疑
`移位表达式左操作数为零`	代码检查：左操作数为零的移位表达式结果为零
`附近存在相似的匿名类型`	代码检查：附近检测到相似的匿名类型
`相似表达式比较`	代码检查：相似表达式比较
`简单嵌入语句样式`	换行 - 在单个嵌入语句中换行，可用于：
`简化条件运算符`	代码检查：简化条件运算符
`简化条件三元表达式`	代码检查：简化条件三元表达式
`简化 if 语句的赋值`	代码检查：简化 'IIf'
`将 LINQ 表达式简化为 all`	代码检查：简化 LINQ 表达式（使用 'All'）
`将 LINQ 表达式简化为 any`	代码检查：简化 LINQ 表达式（使用 'Any'）
`将 LINQ 表达式简化为 MinBy 和 MaxBy`	代码检查：使用 'MinBy' 或 'MaxBy' 替代排序后取 'First' 或 'Last'
`简化字符串插值`	代码检查：在插值字符串中使用格式说明符
`使用 System 排序 using 指令`	引用限定和 'using' 指令 - 排序 'using' 指令时优先放置 'System.' 和 'Windows.' 命名空间（C#）
`resharper_space_after_ampersand_op`	一元运算符后 - 不安全的取地址运算符 (&)（C#）
`在 * 运算符后添加空格`	一元运算符后 - 不安全的星号运算符 (*)（C#）
`在特性冒号后添加空格`	围绕冒号 - 在其他冒号之后 (C#)
`在特性目标冒号后添加空格`	属性 - 属性目标冒号后 (VB.NET)
`在特性后添加空格`	属性 - 属性后（C#）
`在强制转换后添加空格`	其他 - 类型转换括号后，可用于： C#
`在冒号后添加空格`	围绕冒号 - 在其他冒号之后 (C#)
`在 case 语句的冒号后添加空格`	冒号周围 - “case”语句中的冒号后，可用于： C#
`在继承子句的冒号后添加空格`	冒号周围 - 基类型列表冒号后，可用于： C#
`在逗号后添加空格`	逗号后空格（通用）
`在控制流语句中的关键字后添加空格`	控制流语句括号前空格（通用）
`在最后一个特性后添加空格`	标签头部内部 - 最后一个属性后的空格，可用于：
`在最后一个处理指令特性后添加空格`	处理指令 - 最后一个属性后的空格，可用于：
`在逻辑非运算符后添加空格`	一元运算符后 - 逻辑非运算符 (!)（C#）
`在 operator 关键字后添加空格`	其他 - 运算符关键字后（C#）
`在属性冒号后添加空格`	属性 - 冒号后，可用于：
`在 for 语句分号后添加空格`	逗号和分号周围 - “for”分号后，可用于： C#
`在三元运算符的冒号后添加空格`	三元运算符中 - “:”后，可用于： C#
`在三元运算符的问号后添加空格`	三元运算符中 - “?”后，可用于： C#
`在类型参数约束冒号后添加空格`	冒号周围 - 类型参数约束冒号后，可用于： C#
`在一元负号运算符后添加空格`	一元运算符后 - 一元减号运算符 (-)（C#）
`在一元运算符后添加空格`	操作周围 - 一元运算符之后 (VB.NET)
`在一元运算相符后添加空格`	一元运算符后空格 (!, -, ~,...)（通用）
`在一元加号运算符后添加空格`	一元运算符后 - 一元加号运算符 (+)（C#）
`在加法运算符周围添加空格`	二元运算符周围 - 加法运算符（+、-），可用于： C#， VB.NET
`在 alias = 符号周围添加空格`	其他 - 命名空间别名指令中的 '=' 周围，可用于： C#
`在箭头运算符周围添加空格`	二元运算符周围 - 不安全箭头运算符（->）（C#）
`在赋值运算符周围添加空格`	二元运算符周围 - 赋值运算符（如 '=' 和 '+='），可用于： C#， VB.NET
`在赋值运算符周围添加空格`	在表达式中 - 在赋值运算符周围，适用于：
`在二元运算符周围添加空格`	在二元运算符周围的空格（+，\|\|，=，...）（通用）
`在按位运算符周围添加空格`	在二元运算符周围 - 按位运算符（&，\|，^）（C#）
`在点运算符周围添加空格`	其他 - 在点号周围，适用于： C#， VB.NET
`在等值操作符周围添加空格`	围绕二元运算符 - 相等运算符 (==,!=) (C#)
`在 Lambda 箭头周围添加空格`	其他 - 在 lambda 箭头周围（C#）
`在逻辑运算符周围添加空格`	二元运算符周围 - 逻辑运算符（&&、\|\|）（C#）
`在成员访问运算符周围添加空格`	在成员访问运算符周围的空格（.，->，...）（通用）
`在乘法运算符周围添加空格`	二元运算符周围 - 乘法运算符（*、/、%），可用于： C#， VB.NET
`在空合并运算符周围添加空格`	二元运算符周围 - 空合运算符（??）（C#）
`在关系运算符周围添加空格`	二元运算符周围 - 关系运算符（<、>、<=、>=），可用于： C#， VB.NET
`在移位运算符周围添加空格`	在二元运算符周围 - 移位运算符（<<，>>，>>>），适用于： C#， VB.NET
`在语句标签冒号周围添加空格`	其他 - 在语句 ':' 周围（VB.NET）
`在三元运算符周围添加空格`	在三元运算符（?，:）周围的空格（通用）
`在数组访问方括号前添加空格`	在数组括号周围 - 在数组访问括号之前，适用于： C#
`在数组秩方括号前添加空格`	数组括号周围 - 数组维度括号前（C#）
`在数组秩圆括号前添加空格`	数组 - 数组维度括号前 (VB.NET)
`在特性冒号前添加空格`	围绕冒号 - 在其他冒号之前 (C#)
`在特性目标冒号前添加空格`	属性 - 属性目标冒号前 (VB.NET)
`在 catch 圆括号前添加空格`	在语句中的括号之前 - 'catch' 括号（C#）
`在 checked 圆括号前添加空格`	其他括号前 - 'checked' 和 'unchecked' 括号（C#）
`在冒号前添加空格`	在冒号周围 - 在其他冒号之前（C#）
`在 case 语句冒号前添加空格`	在冒号周围 - 在 'case' 语句中的冒号之前，适用于： C#
`在继承子句冒号前添加空格`	在冒号周围 - 在基类型列表冒号之前，适用于： C#
`在逗号前添加空格`	逗号前的空格（通用）
`在 default 圆括号前添加空格`	在其他括号之前 - 'default' 括号 (C#)
`在空方法调用圆括号前添加空格`	附近的括号 - 空调用括号前 (VB.NET)
`在空方法调用括号前添加空格`	在其他括号之前 - 方法调用的空括号，适用于： C#
`在空方法声明圆括号前添加空格`	在其他括号之前 - 方法声明的空括号，适用于： C#， VB.NET
`在 fixed 圆括号前添加空格`	在语句中的括号之前 - 'fixed' 括号 (C#)
`在 for 圆括号前添加空格`	在语句中的括号之前 - 'for' 括号 (C#)
`在 foreach 圆括号前添加空格`	在语句中的括号之前 - 'foreach' 括号（C#）
`在 if 圆括号前添加空格`	在语句中的括号之前 - 'if' 括号 (C#)
`在调用括号前添加空格`	附近的括号 - 调用括号前 (VB.NET)
`在标签冒号前添加空格`	其他 - 标签中的 ':' 前 (VB.NET)
`在 lock 圆括号前添加空格`	在语句中的括号之前 - 'lock' 括号 (C#)
`在方法调用圆括号前添加空格`	在其他括号之前 - 方法调用括号，适用于： C#
`在方法括号前添加空格`	在其他括号之前 - 方法声明括号，适用于： C#， VB.NET
`在 nameof 圆括号前添加空格`	在其他括号之前 - 'nameof' 括号 (C#)
`在 new 圆括号前添加空格`	在其他括号之前 - 'new' 括号 (C#)
`在可空标记前添加空格`	其他 - 在可空标记之前（C#）
`在开放方括号前添加空格`	括号前的空格（通用）
`在指针声明 * 前添加空格`	其他 - 在不安全指针声明之前（C#）
`在属性冒号前添加空格`	属性 - 在冒号之前，适用于：
`在自闭合标记前添加空格`	在标签头部内部 - 在 '/>' 之前的空格，适用于：
`在分号前添加空格`	在逗号和分号周围 - 在分号之前，适用于： C#
`在 for 语句的分号前添加空格`	逗号和分号周围 - 在 'for' 分号之前，可用于： C#
`在单行访问器容器前添加空格`	围绕大括号 - 在单行访问器块之前 (C#)
`在 sizeof 圆括号前添加空格`	在其他括号之前 - 'sizeof' 括号 (C#)
`在 switch 圆括号前添加空格`	语句中括号之前 - 'switch' 括号（C#）
`在三元运算符的冒号前添加空格`	三元运算符中 - 在 ':' 之前，可用于： C#
`在三元运算符的问号前添加空格`	三元运算符中 - 在 '?' 之前，可用于： C#
`在行尾注释前添加空格`	其他 - 在行尾注释之前，可用于： C#
`在类型参数括号前添加空格`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`在类型参数定义括号前添加空格`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`在类型参数约束冒号前保留空格`	冒号周围 - 在类型参数约束冒号之前，可用于： C#
`在类型参数括号前保留空格`	附近的括号 - 类型参数括号前 (VB.NET)
`在 typeof 括号前保留空格`	其他括号之前 - 'typeof' 括号（C#）
`在 using 括号前保留空格`	语句中括号之前 - 'using' 括号（C#）
`在 while 括号前保留空格`	语句中括号之前 - 'while' 括号（C#）
`在单行属性中的访问器之间添加空格`	大括号周围 - 在单行属性/事件访问器之间 (C#)
`在特性区域之间添加空格`	属性 - 在属性部分之间 (C#)
`在空方括号之间添加空格`	数组括号周围 - 在数组维度空括号内，可用于： C#
`在关键字与表达式之间添加空格`	其他括号之前 - 关键字和表达式之间（C#）
`在关键字与类型之间添加空格`	其他括号之前 - 关键字和类型之间（C#）
`在方法调用的空参数列表括号之间添加空格`	其他括号内 - 方法调用空括号内，可用于： C#
`在方法调用名称与左括号之间添加空格`	方法调用括号之前的空格 (通用)
`在方法调用的参数列表括号之间添加空格`	其他括号内 - 方法调用括号内，可用于： C#
`在方法声明的空参数列表括号之间添加空格`	其他括号内 - 方法声明空括号内，可用于： C#
`在方法声明名称与左括号之间添加空格`	方法声明括号之前的空格 (通用)
`在方法声明的参数列表括号之间添加空格`	其他括号内 - 方法声明括号内，可用于： C#
`在控制流语句的括号之间添加空格`	控制流语句括号内的空格（通用）
`在方括号之间添加空格`	括号内的空格 (通用)
`在类型转换的括号之间添加空格`	其他括号内 - 类型转换括号内，可用于： C#
`在单行访问器容器中添加空格`	大括号周围 - 在单行访问器内 (C#)
`在单行匿名方法中添加空格`	大括号周围 - 在单行匿名方法内 (C#)
`在单行方法中添加空格`	大括号周围 - 在单行方法内 (C#)
`在后缀和前缀运算符附近添加空格`	一元运算符之后 - ++ 和 -- 之前/之后（C#）
`在数组访问的括号内添加空格`	数组括号周围 - 在数组访问括号内，可用于： C#
`在数组初始化的大括号内添加空格`	数组 - 在数组初始化大括号内 (VB.NET)
`在数组维度的括号内添加空格`	数组括号周围 - 在数组维度括号内 (C#)
`在数组维度的空方括号内添加空格`	数组括号周围 - 在数组维度空括号内 (C#)
`在数组维度的空括号内添加空格`	数组 - 在空数组维度括号内 (VB.NET)
`在数组维度的括号内添加空格`	数组 - 在数组维度括号内 (VB.NET)
`在特性尖括号内添加空格`	属性 - 在属性尖括号内 (VB.NET)
`在特性方括号内添加空格`	属性 - 属性括号内（C#）
`在 catch 括号内添加空格`	语句中的括号内 - 'catch' 括号 (C#)
`在 checked 括号内添加空格`	其他括号内 - 'checked' 和 'unchecked' 括号（C#）
`在 default 括号内添加空格`	其他括号内 - 'default' 括号（C#）
`在空大括号内添加空格`	大括号周围 - 空大括号之间的空格 (C#)
`在空方法调用括号内添加空格`	附近的括号 - 在空调用括号内 (VB.NET)
`在空方法括号内添加空格`	附近的括号 - 在空方法声明括号内 (VB.NET)
`在表达式括号内添加空格`	表达式 - 在括号内，可用于：， VB.NET
`在 fixed 括号内添加空格`	语句中括号内 - 'fixed' 括号（C#）
`在 for 括号内添加空格`	语句中的括号内 - 'for' 括号 (C#)
`在 foreach 括号内添加空格`	语句中括号内 - 'foreach' 括号（C#）
`在 if 括号内添加空格`	语句中的括号 - 'if' 括号 (C#)
`在方法调用括号内添加空格`	附近的括号 - 调用括号内 (VB.NET)
`在列表模式的方括号内添加空格`	数组括号周围 - 列表模式和集合表达式括号内（C#）
`在 lock 括号内添加空格`	语句中括号内 - 'lock' 括号（C#）
`在方法括号内添加空格`	附近的括号 - 方法声明括号内 (VB.NET)
`在 nameof 括号内添加空格`	其他括号内 - 'nameof' 括号（C#）
`在 new 表达式括号内添加空格`	其他括号内 - 'new' 括号（C#）
`在括号内添加空格`	其他括号内 - 括号，适用于： C#
`在单行数组初始化器的大括号内添加空格`	大括号周围 - 单行表达式大括号内（C#）
`在 sizeof 括号内添加空格`	其他括号内 - 'sizeof' 括号（C#）
`在范围模式中添加空格`	其他 - 切片模式中 '..' 之后（C#）
`在 switch 括号内添加空格`	语句中括号内 - 'switch' 括号（C#）
`在元组括号内添加空格`	附近的括号 - 元组括号内 (VB.NET)
`在类型参数尖括号内添加空格`	尖括号周围 - 类型参数尖括号（C#）
`在类型参数声明尖括号内添加空格`	尖括号周围 - 类型形参尖括号（C#）
`在泛型类型参数括号内添加空格`	附近括号 - 类型参数括号内 (VB.NET)
`在 typeof 括号内添加空格`	其他括号内 - 'typeof' 括号（C#）
`在 using 括号内添加空格`	语句中括号内 - 'using' 括号（C#）
`在 while 括号内添加空格`	语句中括号内 - 'while' 括号（C#）
`在属性中的等号两侧添加空格`	标签头部内部 - 属性中 '=' 周围的空格，适用于：
`在处理指令属性中的等号两侧添加空格`	处理指令 - 属性中 '=' 周围的空格，适用于：
`在标签内添加空格`	标签内容 - 起始标签后和结束标签前的空格，适用于：
`特殊处理 else if`	通用 - 特殊 'else if' 处理，适用于： C#
`显式指定字符串转换中的区域性（高亮显示）`	代码检查：显式指定字符串区域性
`显式指定字符串比较方式（高亮显示）`	代码检查：显式指定字符串比较
`显式指定变量类型（高亮显示）`	代码检查：可以显式指定变量类型
`在 readonly 字段中使用自旋锁（高亮显示）`	代码检查：不要在只读字段中存储 SpinLock
`在循环中使用 stackalloc（高亮显示）`	代码检查：在循环中使用 stackalloc
`语句未以分号结尾（高亮显示）`	代码检查：语句终止符不符合代码样式设置
`在泛型类型中使用 static 成员（高亮显示）`	代码检查：泛型类型中的静态字段或自动属性
`static 成员初始值设定项引用了下面的成员（高亮显示）`	代码检查：静态成员初始化器引用了下面或其他部分的静态成员
`限定 static 成员的访问方式`	静态成员限定 - 需要限定的成员（C#）
`使用指定方式限定 static 成员`	静态成员限定 - 使用名称限定（C#）
`存在文本中的 static 成员问题（高亮显示）`	代码检查：无法访问文本参数中的静态符号
`粘贴注释`	其他缩进 - 不缩进从第一列开始的注释，适用于： C#， VB.NET
`字符串比较为特定区域性（类型 1，高亮显示）`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string) 是特定于文化的）
`字符串比较为特定区域性（类型 2，高亮显示）`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string, bool) 是特定于文化的）
`字符串比较为特定区域性（类型 3，高亮显示）`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string, bool) 是特定于文化的）
`字符串比较为特定区域性（类型 4，高亮显示）`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int) 是特定于文化的）
`字符串比较为特定区域性（类型 5，高亮显示）`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的）
`字符串比较为特定区域性（类型 6，高亮显示）`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的）
`使用 CompareTo 进行的字符串比较为特定区域性（高亮显示）`	代码检查： String.CompareTo 是特定于文化的
`将字符串拼接转为模板字符串（高亮显示）`	代码检查：字符串连接可以转换为模板字符串
`使用 EndsWith 的字符串比较为特定区域性（高亮显示）`	代码检查： String.EndsWith 是特定于文化的（string.EndsWith(string) 是特定于文化的）
`使用 IndexOf 的字符串比较为特定区域性（类型 1，高亮显示）`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string) 是特定于文化的）
`使用 IndexOf 的字符串比较为特定区域性（类型 2，高亮显示）`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string, int) 是特定于文化的）
`使用 IndexOf 的字符串比较为特定区域性（类型 3，高亮显示）`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string, int) 是特定于文化的）
`使用 LastIndexOf 的字符串比较为特定区域性（类型 1，高亮显示）`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string) 是特定于文化的）
`使用 LastIndexOf 的字符串比较为特定区域性（类型 2，高亮显示）`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string, int) 是特定于文化的）
`使用 LastIndexOf 的字符串比较为特定区域性（类型 3，高亮显示）`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string, int) 是特定于文化的）
`字符串字面量作为插值参数（高亮显示）`	代码检查：字符串字面量可以内联
`字符串字面量拼写错误（高亮显示）`	代码检查：字符串字面量中有拼写错误
`字符串字面量使用了错误的引号（高亮显示）`	代码检查：字符串字面量周围的引号不符合规范
`使用 StartsWith 的字符串比较为特定区域性（高亮显示）`	代码检查： String.StartsWith 是特定于文化的（string.StartsWith(string) 是特定于文化的）
`结构体可设为 readonly（高亮显示）`	代码检查：结构体可以声明为 readonly
`结构体成员可设为 readonly（高亮显示）`	代码检查：结构体成员可以声明为 readonly
`结构化消息模板存在问题（高亮显示）`	代码检查：结构化消息模板存在问题
`建议为参数指定基类类型（高亮显示）`	代码检查：参数可以声明为基类型
`建议在构造函数中为参数指定基类类型（高亮显示）`	代码检查：参数可以声明为基类型
`建议使用 discard 声明语法（高亮显示）`	代码检查：使用首选的丢弃声明样式
`建议在内置类型中使用 var 或类型（高亮显示）`	代码检查：使用首选的 'var' 样式（针对内置类型）
`建议在解构声明中使用 var 或类型（高亮显示）`	代码检查：使用首选的 'var' 样式（在解构声明中）
`建议在其他位置使用 var 或类型（高亮显示）`	代码检查：使用首选的 'var' 样式（其他地方）
`建议在简单类型中使用 var 或类型（高亮显示）`	代码检查：使用首选的 'var' 样式（当类型简单时）
`调用 base 方法（高亮显示）`	代码检查：父类调用可以转换为 super 调用
`调用 base 方法禁止使用 this（高亮显示）`	代码检查：在派生类的构造函数中，必须在访问 'this' 之前调用 'super'
`将取消可空警告的表达式视作 is 表达式的否定（高亮显示）`	代码检查：可空警告抑制运算符可能与反转的 'is' 表达式混淆
`可疑的 instanceof 检查（高亮显示）`	代码检查：可疑的 'instanceof' 检查
`可疑的 lambda 块（高亮显示）`	代码检查：可能的错误：模糊的 lambda 块和对象字面量
`在同步基元上使用可疑的 lock（高亮显示）`	代码检查：在同步原语上的可疑锁定
`可疑的 Math.Sign 方法使用（高亮显示）`	代码检查： Math.Sign() 方法始终返回相同的结果
`ArgumentNullException 中参数名称可疑（高亮显示）`	代码检查： ArgumentNullException 中的参数名称可疑
`可疑的 this 使用（高亮显示）`	代码检查：在类成员内的局部函数上下文中对 'this' 的可疑使用
`可疑的类型转换（全局，高亮显示）`	代码检查：可疑的类型转换或检查
`可疑的 typeof 检查（高亮显示）`	代码检查：可疑的 'typeof' 检查
`使用解构完成变量交换（高亮显示）`	代码检查：使用解构来交换变量
`switch 表达式仅处理部分已知枚举值，其默认分支抛出异常（高亮显示）`	代码检查：枚举的一些值未在 'switch' 表达式中处理，而是通过默认分支中的异常处理
`switch 语句仅处理部分已知枚举值并带有默认分支（高亮显示）`	代码检查：枚举的一些值未在 'switch' 语句中处理，而是通过默认部分处理
`switch 语句未处理部分枚举值且缺少默认分支（高亮显示）`	代码检查：枚举的一些值未在 'switch' 语句中处理
`使用了未本地复制的引用中的符号（高亮显示）`	代码检查：模块中的符号可能在运行时丢失
`Tab 与空格不匹配（高亮显示）`	代码检查：缩进不正确（制表符/空格不匹配）
`不允许使用 Tab（高亮显示）`	代码检查：禁止使用制表符进行缩进
`非缩进位置使用了 Tab（高亮显示）`	代码检查：间距不正确（此处禁止使用制表符）
`尾递归调用（高亮显示）`	代码检查：尾递归调用可以替换为循环
`任务未加载（高亮显示）`	代码检查：未知的任务程序集
`三元表达式可被其条件替代（高亮显示）`	代码检查：三元运算符可以用其条件替换
`在全局上下文中使用了 this（高亮显示）`	代码检查：在全局上下文中使用 'this'
`实例字段上使用了 ThreadStatic（高亮显示）`	代码检查： [ThreadStatic] 无法与实例字段一起使用
`ThreadStatic 字段具有初始值设定项（高亮显示）`	代码检查：线程静态字段具有初始化器
`throw 后必须紧跟表达式（高亮显示）`	代码检查： 'throw' 语句后需要表达式
`局部变量作用域过宽（高亮显示）`	代码检查：局部变量的声明范围过宽
`多行列表中使用拖尾逗号`	尾随逗号 - 多行列表中新行前 (C#)
`单行列表中使用拖尾逗号`	尾随逗号 - 当最后一个元素后没有新行时 (C#)
`尝试转换将始终成功（高亮显示）`	代码检查：安全类型转换表达式始终成功
`try 语句可以合并（高亮显示）`	代码检查： try-catch 和 try-finally 语句可以合并
`TypeScript 未解析（高亮显示）`	代码检查：使用未声明的变量
`TypeScript 从不可访问的模块中解析（高亮显示）`	代码检查：无法解析，可能符号位于不可访问的模块中
`类型声明的大括号格式`	大括号布局 - 类型和命名空间声明，适用于： C#
`类型保护无任何影响（高亮显示）`	代码检查：类型保护对变量的类型没有任何影响
`类型保护生成 never 类型（高亮显示）`	代码检查：类型保护明确为变量生成了 'never' 类型
`类型参数可以设为可变（高亮显示）`	代码检查：类型参数可以声明为协变或逆变
`类型参数隐藏了外部作用域的类型参数（高亮显示）`	代码检查：类型参数隐藏了外部作用域中声明的类型参数
`字段未赋值（编译器高亮显示）`	代码检查：未赋值的字段
`resharper_unassigned_field_global_highlighting`	代码检查：未赋值的字段（非私有访问权限）
`resharper_unassigned_field_local_highlighting`	代码检查：未赋值的字段（私有访问权限）
`resharper_unassigned_get_only_auto_property_highlighting`	代码检查：仅读自动属性从未被赋值
`resharper_unassigned_readonly_field_compiler_highlighting`	代码检查：未赋值的只读字段
`resharper_unassigned_readonly_field_highlighting`	代码检查：未赋值的只读字段
`resharper_undeclared_global_variable_using_highlighting`	代码检查：使用未声明的全局变量
`resharper_unity_burst_accessing_managed_indexer_highlighting`	代码检查：访问托管索引器不受支持
`resharper_unity_burst_accessing_managed_method_highlighting`	代码检查：访问托管方法不受支持
`resharper_unity_burst_boxing_not_supported_highlighting`	代码检查：装箱操作不受支持
`resharper_unity_burst_creating_managed_type_highlighting`	代码检查：创建托管类型不受支持
`resharper_unity_burst_debug_log_invalid_argument_highlighting`	代码检查：调试日志函数仅接受字符串
`resharper_unity_burst_foreach_not_supported_highlighting`	代码检查： 'foreach' 构造不受支持
`resharper_unity_burst_function_signature_contains_managed_types_highlighting`	代码检查：函数签名不能包含托管类型
`resharper_unity_burst_loading_managed_type_highlighting`	代码检查：加载托管类型不受支持
`resharper_unity_burst_loading_static_not_readonly_highlighting`	代码检查：从非只读静态字段加载不受支持
`resharper_unity_burst_local_string_variable_declaration_highlighting`	代码检查： Burst：变量解析为 System.String，这可能导致在 Burst 编译的调用栈中出现无效的托管方法调用
`resharper_unity_burst_shared_static_create_highlighting`	代码检查：某些 SharedStatic`1.GetOrCreate 重载会导致编译器错误
`resharper_unity_burst_string_format_invalid_argument_highlighting`	代码检查： Burst：String.Format(format, ...) 参数类型无效
`resharper_unity_burst_string_format_invalid_format_highlighting`	代码检查： String.Format(format, ...) 仅接受字符串字面量和常量字符串
`resharper_unity_burst_try_not_supported_highlighting`	代码检查： try 语句不受支持
`resharper_unity_burst_typeof_expression_highlighting`	代码检查：在 Burst 中禁止使用 typeof
`resharper_unity_burst_write_static_field_highlighting`	代码检查：写入静态字段不受支持
`resharper_unity_duplicate_event_function_highlighting`	代码检查：已声明具有相同名称的事件函数
`resharper_unity_duplicate_shortcut_highlighting`	代码检查：相同的快捷键已为另一个菜单项定义
`resharper_unity_entities_aspect_wrong_fields_type_highlighting`	代码检查： {0} 的字段 '{1}' 必须是 RefRW、RefRO、EnabledRefRW、EnabledRefRO、DynamicBuffer 或 Entity 类型
`resharper_unity_entities_inconsistent_modifiers_for_dots_inheritor_highlighting`	代码检查： {0} 的继承者 '{1}' 必须是 '{2}{3}{4}'
`resharper_unity_entities_must_be_struct_for_dots_inheritor_highlighting`	代码检查： {0} 的继承者 '{1}' 必须是结构体
`resharper_unity_entities_not_updated_component_lookup_highlighting`	代码检查： 'ComponentLookup' 类型的字段在使用前必须更新。
`resharper_unity_entities_singleton_must_be_requested_highlighting`	代码检查：要在函数中使用 'GetSingleton<{0}>' 调用的结果，'OnCreate' 必须包含一个 'RequireForUpdate' 调用
`resharper_unity_expected_component_highlighting`	代码检查：需要一个从 'Component' 或 'MonoBehaviour' 派生的类型
`resharper_unity_expected_scriptable_object_highlighting`	代码检查：需要一个从 'ScriptableObject' 派生的类型
`resharper_unity_explicit_tag_comparison_highlighting`	代码检查：使用 'CompareTag' 而不是显式字符串比较
`resharper_unity_incorrect_method_signature_highlighting`	代码检查：方法签名不正确
`resharper_unity_incorrect_method_signature_in_string_literal_highlighting`	代码检查：字符串文字中引用的方法没有预期的签名
`resharper_unity_incorrect_mono_behaviour_instantiation_highlighting`	代码检查： 'MonoBehaviour' 实例必须使用 'GameObject.AddComponent<T>()' 而不是 'new' 进行实例化
`resharper_unity_incorrect_scriptable_object_instantiation_highlighting`	代码检查： 'ScriptableObject' 实例必须使用 'ScriptableObject.CreateInstance<T>()' 而不是 'new' 进行实例化
`resharper_unity_inefficient_multidimensional_array_usage_highlighting`	代码检查：使用锯齿状数组或一维数组代替多维数组
`resharper_unity_inefficient_multiplication_order_highlighting`	代码检查：乘法操作的顺序效率低下
`resharper_unity_inefficient_property_access_highlighting`	代码检查：对内置组件属性的重复访问效率低下
`resharper_unity_instantiate_without_parent_highlighting`	代码检查：在对象实例化后立即设置 'parent' 属性效率低下
`resharper_unity_load_scene_ambiguous_scene_name_highlighting`	代码检查：场景名称过短且不唯一
`resharper_unity_load_scene_disabled_scene_name_highlighting`	代码检查：场景在构建设置中被禁用
`resharper_unity_load_scene_unexisting_scene_highlighting`	代码检查：场景不存在
`resharper_unity_load_scene_unknown_scene_name_highlighting`	代码检查：构建设置中没有具有相同名称的场景
`resharper_unity_load_scene_wrong_index_highlighting`	代码检查：构建设置中缺少索引
`resharper_unity_no_null_coalescing_highlighting`	代码检查：可能无意中绕过了底层 Unity 引擎对象的生命周期检查（在派生自 'UnityEngine.Object' 的类型上使用 '??' 会绕过底层 Unity 引擎对象的生命周期检查）
`resharper_unity_no_null_propagation_highlighting`	代码检查：可能无意中绕过了底层 Unity 引擎对象的生命周期检查（在派生自 'UnityEngine.Object' 的类型上使用 '?.' 会绕过底层 Unity 引擎对象的生命周期检查）
`resharper_unity_parameter_not_derived_from_component_highlighting`	代码检查：参数应派生自 'Component'
`resharper_unity_performance_critical_code_camera_main_highlighting`	代码检查： 'Camera.main' 开销较大
`resharper_unity_performance_critical_code_invocation_highlighting`	代码检查：方法调用开销较大
`resharper_unity_performance_critical_code_null_comparison_highlighting`	代码检查：空值比较开销较大
`resharper_unity_possible_misapplication_of_attribute_to_multiple_fields_highlighting`	代码检查：可能错误地将属性应用于多个字段
`resharper_unity_prefer_address_by_id_to_graphics_params_highlighting`	代码检查：基于字符串的图形属性查找效率低下
`resharper_unity_prefer_generic_method_overload_highlighting`	代码检查：基于字符串的组件类型查找效率低下
`resharper_unity_prefer_guid_reference_highlighting`	代码检查：优先使用基于 GUID 的程序集引用
`resharper_unity_prefer_non_alloc_api_highlighting`	代码检查：可用的非分配方法替代
`resharper_unity_property_drawer_on_gui_base_highlighting`	代码检查：避免在从 'PropertyDrawer' 派生的类中使用 'base.OnGUI()'
`resharper_unity_redundant_attribute_on_target_highlighting`	代码检查：冗余的属性使用（将属性应用于此声明类型时是多余的）
`resharper_unity_redundant_event_function_highlighting`	代码检查：冗余的 Unity 事件函数
`resharper_unity_redundant_formerly_serialized_as_attribute_highlighting`	代码检查：冗余的属性使用（冗余的 'FormerlySerializedAs' 属性）
`resharper_unity_redundant_hide_in_inspector_attribute_highlighting`	代码检查：冗余的属性使用（冗余的 'HideInInspector' 属性）
`resharper_unity_redundant_initialize_on_load_attribute_highlighting`	代码检查：冗余的属性使用（冗余的 'InitializeOnLoad' 属性）
`resharper_unity_redundant_serialize_field_attribute_highlighting`	代码检查：冗余的属性使用（冗余的 'SerializeField' 属性）
`resharper_unity_shared_static_unmanaged_type_highlighting`	代码检查：共享的静态类型参数需要非托管约束
`resharper_unity_unknown_animator_state_name_highlighting`	代码检查：项目中没有具有相同名称的动画状态
`resharper_unity_unknown_input_axes_highlighting`	代码检查：输入名称未在输入管理器中定义
`resharper_unity_unknown_layer_highlighting`	代码检查：图层未在 'Tags & Layers' 中定义
`resharper_unity_unknown_resource_highlighting`	代码检查：资源未在项目中定义
`resharper_unity_unknown_tag_highlighting`	代码检查：标签未在 'Tags & Layers' 中定义
`resharper_unity_unresolved_component_or_scriptable_object_highlighting`	代码检查：无法解析组件或可脚本化对象
`resharper_unknown_item_group_highlighting`	代码检查：未知的项目组
`resharper_unknown_metadata_highlighting`	代码检查：未知的元数据
`resharper_unknown_output_parameter_highlighting`	代码检查：未知的输出参数
`resharper_unknown_property_highlighting`	代码检查：未知的属性
`resharper_unknown_target_highlighting`	代码检查：未知的目标
`resharper_unknown_task_attribute_highlighting`	代码检查：未知的任务属性
`resharper_unknown_task_highlighting`	代码检查：未知的任务
`resharper_unnecessary_whitespace_highlighting`	代码检查：行尾有不必要的空格
`resharper_unreachable_switch_arm_due_to_integer_analysis_highlighting`	代码检查：根据整数分析，启发式不可达的 switch 分支
`resharper_unreachable_switch_case_due_to_integer_analysis_highlighting`	代码检查：根据整数分析，启发式不可达的 case
`resharper_unsafe_comma_in_object_properties_list_highlighting`	代码检查：对象属性列表中的尾随冗余逗号可能导致错误
`resharper_unsupported_required_base_type_highlighting`	代码检查： BaseTypeRequired 属性仅支持类和接口
`resharper_unused_anonymous_method_signature_highlighting`	代码检查：匿名方法签名不是必需的
`resharper_unused_auto_property_accessor_global_highlighting`	代码检查：自动属性访问器从未使用过（非私有可访问性）
`resharper_unused_auto_property_accessor_local_highlighting`	代码检查：自动属性访问器从未使用过（私有可访问性）
`resharper_unused_field_compiler_highlighting`	代码检查：字段从未使用过
`resharper_unused_import_clause_highlighting`	代码检查：未使用的导入子句
`resharper_unused_inherited_parameter_highlighting`	代码检查：继承成员的未使用参数
`resharper_unused_label_highlighting`	代码检查：未使用的标签
`resharper_unused_local_function_compiler_highlighting`	代码检查：局部函数从未使用过
`resharper_unused_local_function_highlighting`	代码检查：局部函数从未使用过
`resharper_unused_local_function_return_value_highlighting`	代码检查：局部函数的返回值从未使用过
`resharper_unused_local_import_highlighting`	代码检查：未使用的本地导入
`resharper_unused_locals_highlighting`	代码检查：未使用的局部变量 / 函数 / 类
`resharper_unused_member_global_highlighting`	代码检查：类型成员从未使用过（非私有可访问性）
`resharper_unused_member_hierarchy_global_highlighting`	代码检查：类型成员仅在重写中使用（非私有可访问性）
`resharper_unused_member_hierarchy_local_highlighting`	代码检查：类型成员仅在重写中使用（私有可访问性）
`resharper_unused_member_in_super_global_highlighting`	代码检查：类型成员从未通过基类型访问（非私有可访问性）
`resharper_unused_member_in_super_local_highlighting`	代码检查：类型成员从未通过基类型访问（私有可访问性）
`ReSharper 本地未使用成员高亮显示`	代码检查：类型成员从未使用过（私有可访问性）
`ReSharper 全局未使用方法返回值高亮显示`	代码检查：方法返回值从未使用过（非私有可访问性）
`ReSharper 本地未使用方法返回值高亮显示`	代码检查：方法返回值从未使用过（私有可访问性）
`ReSharper 未使用的可为 null 指令高亮显示`	代码检查：未使用的可空指令
`ReSharper 全局未使用参数高亮显示`	代码检查：未使用的参数（非私有可访问性）
`ReSharper 未使用参数高亮显示`	代码检查：未使用的参数
`ReSharper 局部方法中未使用的参数高亮显示`	代码检查：部分方法中的未使用参数
`ReSharper 本地未使用参数高亮显示`	代码检查：未使用的参数（私有可访问性）
`ReSharper 编译器中未使用的位置参数高亮显示`	代码检查：未使用的位置参数
`ReSharper 未使用属性高亮显示`	代码检查：未使用的属性或函数
`ReSharper 返回值中未使用的元组组件高亮显示`	代码检查：元组的组件从未使用过
`ReSharper 全局未使用类型高亮显示`	代码检查：类型从未使用过（非私有可访问性）
`ReSharper 本地未使用类型高亮显示`	代码检查：类型从未使用过（私有可访问性）
`ReSharper 未使用的类型参数高亮显示`	代码检查：未使用的类型参数
`ReSharper 编译器中未使用变量高亮显示`	代码检查：未使用的局部变量
`ReSharper 未使用变量高亮显示`	代码检查：未使用的局部变量
`ReSharper 明确未赋值值的使用高亮显示`	代码检查：使用未赋值的局部变量
`ReSharper 可能未赋值值的使用高亮显示`	代码检查：使用可能未赋值的局部变量
`ReSharper 使用数组创建表达式方式 1 高亮显示`	代码检查：使用数组创建表达式
`ReSharper 使用数组创建表达式方式 2 高亮显示`	代码检查：使用数组创建表达式
`ReSharper 使用 Array.Empty 方法高亮显示`	代码检查：使用 'Array.Empty<T>()'
`ReSharper 使用 as 代替类型转换高亮显示`	代码检查：使用 'as' 运算符代替类型断言
`ReSharper 使用 await using 高亮显示`	代码检查：转换为 'await using' 语句或声明
`ReSharper 为 IAsyncEnumerable 使用 CancellationToken 高亮显示`	代码检查：使用取消令牌
`ReSharper 使用集合的 Count 属性高亮显示`	代码检查：使用集合的 count 属性
`ReSharper 使用集合表达式高亮显示`	代码检查：使用集合表达式语法
`ReSharper 为可释放的异步类型使用 ConfigureAwait(false) 高亮显示`	代码检查：在库代码中缺少 '.ConfigureAwait(false)' 用于异步可释放对象
`ReSharper 使用 ConfigureAwait(false) 高亮显示`	代码检查：在库代码中缺少 '.ConfigureAwait(false)'
`ReSharper 在初始值设定项大括号内使用连续缩进`	大括号布局 - 在表达式大括号内使用连续行缩进 (C#)
`ReSharper 在圆括号中使用连续缩进`	括号 - 在括号内使用连续行缩进 (C#)
`ReSharper 使用解构高亮显示`	代码检查：使用解构
`ReSharper 使用丢弃赋值高亮显示`	代码检查：使用丢弃赋值
`ReSharper 使用空类型字段高亮显示`	代码检查：使用 'Type.EmptyTypes'
`ReSharper 使用 EventArgs.Empty 字段高亮显示`	代码检查：使用 'EventArgs.Empty'
`ReSharper 在格式字符串中使用格式说明符高亮显示`	代码检查：在格式字符串中使用格式说明符
`ReSharper 为方法体样式使用启发式规则`	代码主体 - 应用样式启发式规则（C#）
`ReSharper 使用隐式 by val 修饰符高亮显示`	代码检查：使用隐式 'ByVal' 修饰符
`ReSharper 使用明显类型的隐式类型变量高亮显示`	代码检查：使用隐式类型变量声明（显而易见）
`ReSharper 使用隐式类型变量高亮显示`	代码检查：使用隐式类型变量声明
`ReSharper 根据前一元素缩进`	其他缩进 - 在部分格式中使用前一个元素的缩进 (C#)
`ReSharper 使用 ^ 运算符（从结尾索引）高亮显示`	代码检查：使用从末尾表达式的索引
`ReSharper 使用带索引的属性高亮显示`	代码检查：使用索引属性
`ReSharper 使用 is 运算符方式 1 高亮显示`	代码检查：使用 'is' 运算符
`ReSharper 使用 is 运算符方式 2 高亮显示`	代码检查：使用 'is' 运算符
`ReSharper 使用 Any 方法（无参数）高亮显示`	代码检查：请改用方法 Any()
`ReSharper 使用 Any 方法（一个参数）高亮显示`	代码检查：请改用方法 Any()
`ReSharper 使用 Any 方法（两个参数）高亮显示`	代码检查：请改用方法 Any()
`ReSharper 使用 Any 方法（三个参数）高亮显示`	代码检查：请改用方法 Any()
`ReSharper 使用 Any 方法（四个参数）高亮显示`	代码检查：请改用方法 Any()
`ReSharper 使用 isInstanceOfType 方法高亮显示`	代码检查：请改用方法 IsInstanceOfType(..)
`ReSharper 使用 nameof 替代 typeof 高亮显示`	代码检查：使用 'nameof' 表达式引用类型名称
`ReSharper 使用 nameof 表达式替代表达式中的字符串部分高亮显示`	代码检查：使用 'nameof' 表达式在字符串字面量的一部分中引用名称
`ReSharper 使用 nameof 表达式高亮显示`	代码检查：使用 'nameof' 表达式引用名称
`ReSharper 为依赖项属性使用 nameof 表达式高亮显示`	代码检查：在注册 DependencyProperty 时使用 'nameof' 表达式
`ReSharper 在 is 表达式中使用取反模式高亮显示`	代码检查：将取反的 'is' 表达式转换为带有取反模式的 'is' 表达式
`ReSharper 使用取反模式匹配高亮显示`	代码检查：将 'as' 表达式类型检查和后续的空检查转换为取反模式匹配
`ReSharper 使用空传播运算符高亮显示`	代码检查：用空传播代码替换 if 语句
`ReSharper 使用可为空注解替代特性高亮显示`	代码检查：使用可空注解代替属性
`ReSharper 使用编译器支持的可为空特性高亮显示`	代码检查：使用编译器支持的可空属性
`ReSharper 使用可空引用类型注解语法高亮显示`	代码检查：使用类型注解语法
`ReSharper 使用对象或集合初始值设定项高亮显示`	代码检查：在可能的情况下使用对象或集合初始化器
`ReSharper 在函数作用域中使用隐式 global 高亮显示`	代码检查：使用隐式声明的全局变量
`ReSharper 使用可能未赋值属性高亮显示`	代码检查：在静态初始化器中使用可能未赋值的属性
`ReSharper 使用旧引擎`	使用旧引擎进行 Razor 格式化 (Razor CSharp)
`ReSharper 使用模式匹配高亮显示`	代码检查：将 'as' 表达式类型检查和后续的空检查转换为模式匹配
`ReSharper 使用位置解构模式高亮显示`	代码检查：使用位置解构模式
`ReSharper 使用原始字符串高亮显示`	代码检查：使用原始字符串
`ReSharper 为明显类型使用 Roslyn 逻辑`	'var' 声明中的使用 - 更倾向于 Roslyn（Visual Studio）逻辑以证明类型（C#）
`ReSharper 使用字符串插值高亮显示`	代码检查：使用字符串插值表达式
`ReSharper 为 switch case 模式变量使用变量高亮显示`	代码检查：类型模式和强制转换可以合并
`ReSharper 使用符号别名高亮显示`	代码检查：使用别名
`ReSharper 使用 ThrowIfNull 方法高亮显示`	代码检查：使用 'ArgumentNullException.ThrowIfNull'
`ReSharper 使用无符号右移运算符高亮显示`	代码检查：使用无符号右移运算符 '>>>'
`ReSharper 使用 UTF-8 字符串文本高亮显示`	代码检查：使用 UTF-8 字符串字面量
`ReSharper 使用逐字字符串高亮显示`	代码检查：通过使用逐字字符串减少字面量长度
`ReSharper 使用 with 表达式复制匿名对象高亮显示`	代码检查：使用 'with' 表达式复制匿名对象
`ReSharper 使用 with 表达式复制记录对象高亮显示`	代码检查：使用 'with' 表达式复制记录
`ReSharper 使用 with 表达式复制结构体高亮显示`	代码检查：使用 'with' 表达式复制结构体
`ReSharper 使用 with 表达式复制元组高亮显示`	代码检查：使用 'with' 表达式复制元组
`ReSharper 无用的二元运算高亮显示`	代码检查：无用的算术运算
`ReSharper 对整型常量的无用比较高亮显示`	代码检查：与整数常量的比较是无用的
`ReSharper 使用保留字的错误高亮显示`	代码检查：在“严格模式”中使用未来保留关键字
`ReSharper 使用保留字高亮显示`	代码检查：使用未来保留字
`ReSharper using 语句资源初始化表达式高亮显示`	代码检查：不要为“using”变量使用对象初始化器（对象初始化器表达式在初始化“using”变量时可能抛出异常）
`ReSharper using 语句资源初始化高亮显示`	代码检查：不要为“using”变量使用对象初始化器
`ReSharper 未使用值参数高亮显示`	代码检查： “value”参数未被使用
`ReSharper 值范围特性违规高亮显示`	代码检查：可能违反“ValueRange”/“NonNegativeValue”属性
`ReSharper 可设为常量的变量高亮显示`	代码检查：变量可以声明为常量
`ReSharper 可设为 let 的变量高亮显示`	代码检查： “var”变量可以改为“let”变量
`ReSharper 可移至内嵌代码块的变量高亮显示`	代码检查：局部变量可以安全地移动到内部块
`ReSharper 可设为非可空的变量高亮显示`	代码检查：变量可以声明为非空
`ReSharper 变量隐藏外部变量高亮显示`	代码检查：局部函数中的变量隐藏了外部作用域的变量
`ReSharper 使用前未声明变量高亮显示`	代码检查：变量在声明之前被使用
`ReSharper 在内层作用域中声明前使用变量高亮显示`	代码检查：变量在内部作用域中被使用时尚未声明
`ReSharper 使用超出作用域的变量高亮显示`	代码检查：变量在声明的作用域之外被使用
`ReSharper VB 多行参数对齐`	对齐多行结构 - 调用参数 (VB.NET)
`ReSharper VB 多行数组初始化器对齐`	对齐多行结构 - 数组初始化器（VB.NET）
`ReSharper VB 多行表达式对齐`	对齐多行结构 - 表达式 (VB.NET)
`ReSharper VB 多行 implements 列表对齐`	对齐多行结构 - Implements/handles 列表 (VB.NET)
`ReSharper VB 多行参数对齐`	对齐多行结构 - 方法参数 (VB.NET)
`ReSharper VB 多项声明对齐`	对齐多行结构 - 多声明列表 (VB.NET)
`ReSharper VB 对齐制表填充样式`	制表符和缩进 - 使用制表符缩进时的对齐方式 (VB.NET)
`允许使用别名`	引用限定 - 允许 'Imports' 别名指令 (VB.NET)
`在 Imports 语句后保留空行`	空行 - 在 Imports 部分之后 (VB.NET)
`在 Options 语句后保留空行`	空行 - 在文件选项部分之后（VB.NET）
`字段前后保留空行`	空行 - 在多行字段周围 (VB.NET)
`全局属性前后保留空行`	空行 - 全局属性之后 (VB.NET)
`可调用元素前后保留空行`	空行 - 在多行方法周围 (VB.NET)
`命名空间前后保留空行`	空行 - 在命名空间周围 (VB.NET)
`#Region 块前后保留空行`	空行 - 区域周围 (VB.NET)
`单行字段前后保留空行`	空行 - 单行字段周围 (VB.NET)
`单行可调用元素前后保留空行`	空行 - 单行方法周围 (VB.NET)
`类型前后保留空行`	空行 - 类型周围 (VB.NET)
`#Region 块内保留空行`	空行 - 区域内部 (VB.NET)
`建议使用引用相等检查替代方法（级别 1）高亮显示`	代码检查：检查引用相等性
`建议使用引用相等检查替代方法（级别 2）高亮显示`	代码检查：检查引用相等性
`对 Case 块进行缩进`	其他 - 将“case”缩进到“select”（VB.NET）
`缩进大小`	制表符和缩进 - 缩进大小（VB.NET）
`缩进样式`	制表符和缩进 - 缩进样式 (VB.NET)
`在代码中保留空行`	保留现有格式 - 保留代码中的最大空行数 (VB.NET)
`在声明中保留空行`	保留现有格式 - 保留声明中的最大空行数 (VB.NET)
`保留用户添加的换行符`	保留现有格式 - 保留现有换行符 (VB.NET)
`最大行长度`	换行 - 在（VB.NET）处硬换行
`将事件的属性置于同一行`	属性 - 将事件属性放在同一行（VB.NET）
`将字段的属性置于同一行`	属性 - 将字段属性放在同一行 (VB.NET)
`将方法的属性置于同一行`	属性 - 将方法属性放在同一行（VB.NET）
`将属性的属性置于同一行`	属性 - 将属性的属性放在同一行 (VB.NET)
`将类型的属性置于同一行`	属性 - 将类型属性放在同一行 (VB.NET)
`可能为错误参数的高亮显示`	代码检查：可能的错误参数
`可能错误地调用 GetType（级别 1）的高亮显示`	代码检查：可能错误地调用了 GetType()
`可能错误地调用 GetType（级别 2）的高亮显示`	代码检查：可能错误地调用了 GetType()
`首选使用限定引用`	引用限定 - 优先使用完全限定的引用（VB.NET）
`建议移除 ToList 调用（级别 1）高亮显示`	代码检查：移除 ToList()
`建议移除 ToList 调用（级别 2）高亮显示`	代码检查：移除 ToList()
`建议替换为 FirstOrDefault 的高亮显示`	代码检查：替换为 FirstOrDefault($args$)
`建议替换为 LastOrDefault 的高亮显示`	代码检查：替换为 LastOrDefault($args$)
`建议替换为 OfType（级别 1）的高亮显示`	代码检查：替换为 OfType<T>()（替换为 OfType(Of ..)()）
`建议替换为 OfType（级别 2）的高亮显示`	代码检查：替换为 OfType<T>()（替换为 OfType(Of ..)()）
`建议替换为 OfType().Any（级别 1）的高亮显示`	代码检查：替换为 OfType<T>().Any()（替换为 OfType(Of ..)().Any()）
`建议替换为 OfType().Any（级别 2）的高亮显示`	代码检查：替换为 OfType<T>().Any()（替换为 OfType(Of ..)().Any(..)）
`建议替换为 OfType().Count（级别 1）的高亮显示`	代码检查：替换为 OfType<T>().Count()（替换为 OfType(Of ..)().Count()）
`建议替换为 OfType().Count（级别 2）的高亮显示`	代码检查：替换为 OfType<T>().Count()（替换为 OfType(Of ..)().Count(..)）
`建议替换为 OfType().First（级别 1）的高亮显示`	代码检查：替换为 OfType<T>().First()（替换为 OfType(Of ..)().First()）
`建议替换为 OfType().First（级别 2）的高亮显示`	代码检查：替换为 OfType<T>().First()（替换为 OfType(Of ..)().First(..)）
`建议替换为 OfType().FirstOrDefault（级别 1）的高亮显示`	代码检查：替换为 OfType<T>().FirstOrDefault()（替换为 OfType(Of ..)().FirstOrDefault()）
`建议替换为 OfType().FirstOrDefault（级别 2）的高亮显示`	代码检查：替换为 OfType<T>().FirstOrDefault()（替换为 OfType(Of ..)().FirstOrDefault(..)）
`建议替换为 OfType().Last（级别 1）的高亮显示`	代码检查：替换为 OfType<T>().Last()（替换为 OfType(Of ..)().Last()）
`建议替换为 OfType().Last（级别 2）的高亮显示`	代码检查：替换为 OfType<T>().Last()（替换为 OfType(Of ..)().Last(..)）
`建议替换为 OfType().LastOrDefault（级别 1）的高亮显示`	代码检查：替换为 OfType<T>().LastOrDefault()（替换为 OfType(Of ..)().LastOrDefault()）
`建议替换为 OfType().LastOrDefault（级别 2）的高亮显示`	代码检查：替换为 OfType<T>().LastOrDefault()（替换为 OfType(Of ..)().LastOrDefault(..)）
`建议替换为 OfType().Single（级别 1）的高亮显示`	代码检查：替换为 OfType<T>().Single()（替换为 OfType(Of ..)().Single()）
`建议替换为 OfType().Single（级别 2）的高亮显示`	代码检查：替换为 OfType<T>().Single()（替换为 OfType(Of ..)().Single(..)）
`建议替换为 OfType().SingleOrDefault（级别 1）的高亮显示`	代码检查：替换为 OfType<T>().SingleOrDefault()（替换为 OfType(Of ..)().SingleOrDefault()）
`建议替换为 OfType().SingleOrDefault（级别 2）的高亮显示`	代码检查：替换为 OfType<T>().SingleOrDefault()（替换为 OfType(Of ..)().SingleOrDefault(..)）
`建议替换为 OfType().Where 的高亮显示`	代码检查：替换为 OfType<T>().Where()（替换为 OfType(Of ..)().Where(..)）
`建议替换为单一赋值（级别 1）的高亮显示`	代码检查：替换为单一赋值
`建议替换为单一赋值（级别 2）的高亮显示`	代码检查：替换为单一赋值
`建议替换为单一 Any 调用的高亮显示`	代码检查：替换为单次调用 Any(..)
`建议替换为单一 Count 调用的高亮显示`	代码检查：替换为单次调用 Count(..)
`建议替换为单一 First 调用的高亮显示`	代码检查：替换为单次调用 First(..)
`建议替换为单一 FirstOrDefault 调用的高亮显示`	代码检查：替换为单次调用 FirstOrDefault(..)
`建议替换为单一 Last 调用的高亮显示`	代码检查：替换为单次调用 Last(..)
`建议替换为单一 LastOrDefault 调用的高亮显示`	代码检查：替换为单次调用 LastOrDefault(..)
`建议替换为单一 Single 调用的高亮显示`	代码检查：替换为单次调用 Single(..)
`建议替换为单一 SingleOrDefault 调用的高亮显示`	代码检查：替换为单次调用 SingleOrDefault(..)
`建议替换为 SingleOrDefault 的高亮显示`	代码检查：替换为 SingleOrDefault($args$)
`简化 LINQ 表达式（级别 1）的高亮显示`	代码检查：简化表达式
`简化 LINQ 表达式（级别 10）的高亮显示`	代码检查：简化表达式
`简化 LINQ 表达式（级别 2）的高亮显示`	代码检查：简化表达式
`简化 LINQ 表达式（级别 3）的高亮显示`	代码检查：简化表达式
`简化 LINQ 表达式（级别 4）的高亮显示`	代码检查：简化表达式
`简化 LINQ 表达式（级别 5）的高亮显示`	代码检查：简化表达式
`简化 LINQ 表达式（级别 6）的高亮显示`	代码检查：简化表达式
`简化 LINQ 表达式（级别 7）的高亮显示`	代码检查：简化表达式
`简化 LINQ 表达式（级别 8）的高亮显示`	代码检查：简化表达式
`简化 LINQ 表达式（级别 9）的高亮显示`	代码检查：简化表达式
`在属性目标冒号后添加空格`	属性 - 属性目标冒号后（VB.NET）
`在逗号后添加空格`	其他 - 逗号后（VB.NET）
`在一元操作符后添加空格`	操作周围 - 一元运算符之后 (VB.NET)
`在一元运算符后添加空格`	操作周围 - 一元运算符之后 (VB.NET)
`在加法运算符两边添加空格`	操作周围 - 加法运算符（+，-） (VB.NET)
`在赋值运算符两边添加空格`	操作周围 - 赋值运算符 (如 '=' 和 '+=') (VB.NET)
`在二进制运算符两边添加空格`	在二元运算符周围的空格（+，\|\|，=，...）（通用）
`在点运算符两边添加空格`	其他 - '.' 周围 (VB.NET)
`在成员访问运算符两边添加空格`	其他 - '.' 周围 (VB.NET)
`在乘法运算符两边添加空格`	操作周围 - 乘法运算符（例如 '*' 和 '/'） (VB.NET)
`在关系运算符两边添加空格`	操作周围 - 关系运算符（<，>，<=，>=） (VB.NET)
`在位移运算符两边添加空格`	操作周围 - 移位运算符（<<，>>） (VB.NET)
`在语句冒号两边添加空格`	其他 - 语句 ':' 周围（VB.NET）
`在数组维度括号前添加空格`	数组 - 数组维度括号前（VB.NET）
`在属性目标冒号前添加空格`	属性 - 属性目标冒号前（VB.NET）
`在逗号前添加空格`	其他 - ',' 之前 (VB.NET)
`在空参数调用括号前添加空格`	附近的括号 - 空调用括号前 (VB.NET)
`在空方法括号前添加空格`	附近的括号 - 空方法声明括号前 (VB.NET)
`在调用括号前添加空格`	附近的括号 - 调用括号前 (VB.NET)
`在标签冒号前添加空格`	其他 - 标签中的 ':' 前 (VB.NET)
`在方法括号前添加空格`	附近的括号 - 方法声明括号前 (VB.NET)
`在类型参数括号前添加空格`	附近的括号 - 类型参数括号前 (VB.NET)
`在数组初始化括号内添加空格`	数组 - 在数组初始化大括号内 (VB.NET)
`在数组维度的空括号内添加空格`	数组 - 在空数组维度括号内 (VB.NET)
`在数组维度的括号内添加空格`	数组 - 在数组维度括号内 (VB.NET)
`在属性类型参数的尖括号内添加空格`	属性 - 在属性尖括号内 (VB.NET)
`在空的调用括号内添加空格`	附近的括号 - 在空调用括号内 (VB.NET)
`在空的方法括号内添加空格`	附近的括号 - 在空方法声明括号内 (VB.NET)
`在表达式括号内添加空格`	附近的括号 - 表达式括号内 (VB.NET)
`在方法调用括号内添加空格`	附近的括号 - 调用括号内 (VB.NET)
`在方法括号内添加空格`	附近的括号 - 方法声明括号内 (VB.NET)
`在元组括号内添加空格`	附近的括号 - 元组括号内 (VB.NET)
`在类型参数的括号内添加空格`	附近括号 - 类型参数括号内 (VB.NET)
`粘附注释`	其他 - 不缩进从第一列开始的注释 (VB.NET)
`使用文化特定规则的字符串比较（级别 1）突出显示`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string) 是特定于文化的）
`使用文化特定规则的字符串比较（级别 2）突出显示`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string, bool) 是特定于文化的）
`使用文化特定规则的字符串比较（级别 3）突出显示`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string, bool) 是特定于文化的）
`使用文化特定规则的字符串比较（级别 4）突出显示`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int) 是特定于文化的）
`使用文化特定规则的字符串比较（级别 5）突出显示`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的）
`使用文化特定规则的字符串比较（级别 6）突出显示`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的）
`对字符串调用 CompareTo 使用文化特定规则的突出显示`	代码检查： String.CompareTo 是特定于文化的
`字符串 EndsWith 使用文化特定规则的突出显示`	代码检查： String.EndsWith 是特定于文化的（string.EndsWith(string) 是特定于文化的）
`字符串 IndexOf 使用文化特定规则（级别 1）的突出显示`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string) 是特定于文化的）
`字符串 IndexOf 使用文化特定规则（级别 2）的突出显示`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string, int) 是特定于文化的）
`字符串 IndexOf 使用文化特定规则（级别 3）的突出显示`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string, int) 是特定于文化的）
`字符串 LastIndexOf 使用文化特定规则（级别 1）的突出显示`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string) 是特定于文化的）
`字符串 LastIndexOf 使用文化特定规则（级别 2）的突出显示`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string, int) 是特定于文化的）
`字符串 LastIndexOf 使用文化特定规则（级别 3）的突出显示`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string, int) 是特定于文化的）
`字符串 StartsWith 使用文化特定规则的突出显示`	代码检查： String.StartsWith 是特定于文化的（string.StartsWith(string) 是特定于文化的）
`制表符宽度`	制表符和缩进 - 制表符宽度 (VB.NET)
`不可达代码突出显示`	代码检查：不可达代码
`建议使用数组创建表达式（级别 1）突出显示`	代码检查：使用数组创建表达式
`建议使用数组创建表达式（级别 2）突出显示`	代码检查：使用数组创建表达式
`建议使用 First 替代的突出显示`	代码检查：请改用 First()
`建议使用方法 Any 的第 1 项突出显示`	代码检查：请改用方法 Any()
`建议使用方法 Any 的第 2 项突出显示`	代码检查：请改用方法 Any()
`建议使用方法 Any 的第 3 项突出显示`	代码检查：请改用方法 Any()
`建议使用方法 Any 的第 4 项突出显示`	代码检查：请改用方法 Any()
`建议使用方法 Any 的第 5 项突出显示`	代码检查：请改用方法 Any()
`建议使用方法 IsInstanceOfType 的突出显示`	代码检查：请改用方法 IsInstanceOfType(..)
`建议使用 TypeOf...Is 运算符的第 1 项突出显示`	代码检查：请改用 'TypeOf .. Is ..' 运算符
`建议使用 TypeOf...Is 运算符的第 2 项突出显示`	代码检查：请改用 'TypeOf .. Is ..' 运算符
`BC40000 警告突出显示`	代码检查：请改用已过时的成员
`BC400005 警告突出显示`	代码检查：成员遮蔽了可重写的成员
`BC40008 警告突出显示`	代码检查：请改用已过时的成员（无消息）
`BC40056 警告突出显示`	代码检查： Imports 'name' 中指定的命名空间或类型不包含任何公共成员或无法找到
`BC42016 警告突出显示`	代码检查：将 X 转换为 Y 时可能会发生运行时错误
`BC42025 警告突出显示`	代码检查：通过实例访问共享成员
`BC42104 警告突出显示`	代码检查：变量在赋值前被使用
`BC42105、BC42106、BC42107 警告突出显示`	代码检查：函数在所有代码路径上未返回引用类型值
`BC42304 警告突出显示`	代码检查： XML 注释中存在语法错误
`BC42309 警告突出显示`	代码检查： XML 注释中包含无法解析的带有 'cref' 属性的标签
`BC42322 警告突出显示`	代码检查：将 X 转换为 Y 时可能会发生运行时错误
`BC42349 警告突出显示`	代码检查：对等值类型的冗余 DirectCast
`BC42353、BC42354、BC42355 警告突出显示`	代码检查：函数在所有代码路径上未返回结构值
`BC42356 警告突出显示`	代码检查：异步方法缺少 'Await' 运算符
`BC42358 警告突出显示`	代码检查：由于此调用未等待，当前方法的执行在调用完成之前继续。请考虑对调用结果应用 'Await' 运算符。
`BC42504 警告突出显示`	代码检查：应用于参数的 CallerArgumentExpressionAttribute 无效，因为它是自引用的
`BC42505 警告突出显示`	代码检查：应用于参数的 CallerArgumentExpressionAttribute 无效。它使用了无效的参数名称。
`WME006 警告突出显示`	代码检查：命名空间应为此项目的默认命名空间
`参数换行样式`	换行 - 包装调用参数 (VB.NET)
`在二元运算符前换行`	换行 - 优先在二元表达式中的运算符前换行 (VB.NET)
`在声明左括号前换行`	换行 - 优先在方法声明中的 '(' 前换行 (VB.NET)
`在调用左括号前换行`	换行 - 优先在调用中的 '(' 前换行 (VB.NET)
`扩展列表换行样式`	换行 - 包装 extends/implements/handles 列表 (VB.NET)
`多声明换行样式`	换行 - 包装多个声明列表 (VB.NET)
`参数换行样式`	换行 - 包装形式参数 (VB.NET)
`在构造函数中调用虚成员的突出显示`	代码检查：构造函数中的虚成员调用
`虚成员从未在全局范围中被重写的突出显示`	代码检查：虚（可重写）成员从未被重写（非私有访问权限）
`虚成员从未在局部中被重写的突出显示`	代码检查：虚（可重写）成员从未被重写（私有访问权限）
`带有 MustDisposeResource 特性但返回类型为 void 的方法突出显示`	代码检查： 'void' 方法带有 [MustDisposeResource] 属性
`带有 MustUseReturnValue 特性但返回类型为 void 的方法突出显示`	代码检查： 'void' 方法带有 [MustUseReturnValue] 属性
`易受攻击的 API 突出显示`	代码检查：存在易受攻击的 API 用法
`易受攻击的包突出显示`	代码检查： NuGet 包存在漏洞
`未解析的 web.config 模块突出显示`	代码检查：无法解析模块
`web.config 模块限定解析突出显示`	代码检查：需要模块限定
`web.config 中冗余的 add namespace 标签突出显示`	代码检查：冗余的 add namespace 元素
`web.config 中冗余的 location 标签突出显示`	代码检查：冗余的 location 元素
`web.config 中冗余的标签前缀突出显示`	代码检查：冗余的 tagPrefix 声明
`web.config 类型未解析突出显示`	代码检查：无法解析符号
`web.config 中未使用的 add 标签突出显示`	代码检查：冗余的添加元素
`由于 configSource 属性导致未使用的元素突出显示`	代码检查：由于 'configSource' 属性导致的冗余元素或属性
`web.config 中未使用的 remove 或 clear 标签突出显示`	代码检查：冗余的移除或清除元素
`web.config 路径警告突出显示`	代码检查：在网站中找不到引用的路径
`无效的 web.config 模块突出显示`	代码检查：错误的模块
`忽略的路径突出显示`	代码检查：忽略的路径
`映射路径的突出显示`	代码检查：映射路径
`建议使用 With 表达式替代初始化器的突出显示`	代码检查：使用 'with' 表达式代替对象初始化器
`With 表达式修改所有成员的突出显示`	代码检查： 'with' 表达式修改了所有可访问的实例成员
`With 语句使用错误的突出显示`	代码检查：在 'strict mode' 中使用 'with' 语句
`在声明左括号后换行`	方法签名排列 - 优先在声明中的 '(' 后换行，可用于： C#
`在方法调用中的点号后换行`	成员访问表达式排列 - 优先在 '.' 后换行 (C#)
`在方法调用左括号后换行`	调用排列 - 优先在调用中的 '(' 后换行，可用于： C#
`在主构造函数声明中左括号后换行`	主构造函数签名排列 - 优先在声明中的 '(' 后换行 (C#)
`在链式方法调用中属性后换行`	成员访问表达式排列 - 优先在链式方法调用中的属性和字段后换行 (C#)
`参数换行样式`	调用排列 - 换行调用参数，可用于： C#， VB.NET
`围绕元素进行换行`	标签内容 - 在元素前后换行，可用于：
`数组初始化器换行样式`	初始化器排列 - 换行数组初始化器 (C#)
`在箭头表达式前换行`	表达式主体成员排列 - 优先在 '=>' 前换行并跟随表达式 (C#)
`在二元运算符前换行`	二元表达式排列 - 优先在二元表达式中的运算符前换行，可用于： C#， VB.NET
`在二元模式运算符前换行`	二元表达式排列 - 优先在二元模式中的运算符前换行 (C#)
`resharper_wrap_before_comma`	通用 - 优先在 ',' 前换行，适用于： C#
`resharper_wrap_before_declaration_lpar`	方法签名排列 - 优先在声明中的 '(' 前换行，可用于： C#， VB.NET
`resharper_wrap_before_declaration_rpar`	方法签名排列 - 优先在声明中的 ')' 前换行，可用于： C#
`resharper_wrap_before_eq`	通用 - 优先在 '=' 前换行（C#）
`resharper_wrap_before_extends_colon`	类型参数、约束和基类型排列 - 优先在 ':' 前换行 (C#)
`resharper_wrap_before_first_method_call`	成员访问表达式排列 - 优先在第一个方法调用前换行 (C#)
`resharper_wrap_before_first_type_parameter_constraint`	类型参数、约束和基类型排列 - 优先在第一个约束前换行，可用于： C#
`resharper_wrap_before_invocation_lpar`	调用排列 - 优先在调用中的 '(' 前换行，可用于： C#， VB.NET
`resharper_wrap_before_invocation_rpar`	调用排列 - 优先在调用中的 ')' 前换行，可用于： C#
`resharper_wrap_before_linq_expression`	LINQ 表达式排列 - 优先在多行 LINQ 表达式前换行 (C#)
`resharper_wrap_before_primary_constructor_declaration_lpar`	主构造函数签名排列 - 优先在声明中的 '(' 前换行 (C#)
`resharper_wrap_before_primary_constructor_declaration_rpar`	主构造函数签名排列 - 优先在声明中的 ')' 前换行 (C#)
`resharper_wrap_before_ternary_opsigns`	三元表达式排列 - 优先在三元表达式中的 '?' 和 ':' 前换行，可用于： C#
`resharper_wrap_before_type_parameter_langle`	类型参数、约束和基类型排列 - 优先在类型参数列表中的开尖括号前换行 (C#)
`resharper_wrap_chained_binary_expressions`	二元表达式排列 - 换行链式二元表达式，可用于： C#
`resharper_wrap_chained_binary_patterns`	二元表达式排列 - 换行复杂的二元模式 (C#)
`resharper_wrap_chained_method_calls`	成员访问表达式排列 - 换行链式方法调用，可用于： C#
`resharper_wrap_enum_declaration`	枚举排列 - 换行枚举声明 (C#)
`resharper_wrap_extends_list_style`	类型参数、约束和基类型排列 - 换行扩展/实现列表，可用于： C#， VB.NET
`resharper_wrap_for_stmt_header_style`	语句排列 - 换行 'for' 语句头部，可用于： C#
`resharper_wrap_linq_expressions`	LINQ 表达式排列 - 换行 LINQ 表达式 (C#)
`resharper_wrap_list_pattern`	列表模式排列 - 换行列表模式和集合表达式 (C#)
`resharper_wrap_multiple_declaration_style`	语句排列 - 换行多声明，可用于： C#， VB.NET
`resharper_wrap_multiple_type_parameter_constraints_style`	类型参数、约束和基类型排列 - 换行多个类型参数约束，可用于： C#
`resharper_wrap_object_and_collection_initializer_style`	初始化器排列 - 换行对象和集合初始化器 (C#)
`resharper_wrap_parameters_style`	方法签名排列 - 换行形式参数，可用于： C#， VB.NET
`resharper_wrap_primary_constructor_parameters_style`	主构造函数签名排列 - 换行主构造函数参数 (C#)
`resharper_wrap_property_pattern`	属性模式排列 - 换行属性模式 (C#)
`resharper_wrap_switch_expression`	切换表达式排列 - 换行切换表达式 (C#)
`resharper_wrap_tags_and_pi`	换行 - 换行标签和处理指令，适用于：
`resharper_wrap_ternary_expr_style`	三元表达式的排列 - 换行三元表达式，适用于： C#
`resharper_wrap_text`	标签内容 - 换行内部文本，适用于：
`resharper_wrap_verbatim_interpolated_strings`	插值字符串的排列 - 换行插值字符串（C#）
`resharper_wrong_expression_statement_highlighting`	代码检查：可疑的表达式语句
`resharper_wrong_indent_size_highlighting`	代码检查：缩进不正确（缩进大小不正确）
`resharper_wrong_metadata_use_highlighting`	代码检查：元数据使用错误
`resharper_wrong_public_modifier_specification_highlighting`	代码检查：不符合规范的 'public' 修饰符或其缺失
`resharper_wrong_require_relative_path_highlighting`	代码检查： 'require' 中不符合规范的路径样式
`resharper_xaml_assign_null_to_not_null_attribute_highlighting`	代码检查：可能将 'null' 分配给非空实体
`resharper_xaml_avalonia_wrong_binding_mode_for_stream_binding_operator_highlighting`	代码检查：在 TwoWay 或 OneWayToSource 绑定模式中使用流绑定运算符
`resharper_xaml_binding_with_context_not_resolved_highlighting`	代码检查：当 DataContext 已知时未解析的绑定路径
`resharper_xaml_binding_without_context_not_resolved_highlighting`	代码检查：当 DataContext 未知时未解析的绑定路径
`resharper_xaml_compiled_binding_missing_data_type_error_highlighting_highlighting`	代码检查：未为 CompiledBinding 指定 x:DataType
`resharper_xaml_constructor_warning_highlighting`	代码检查：构造函数未解析
`resharper_xaml_decimal_parsing_is_culture_dependent_highlighting`	代码检查：十进制数字的解析依赖于当前机器的区域设置
`resharper_xaml_dependency_property_resolve_error_highlighting`	代码检查：缺少依赖属性描述符字段
`resharper_xaml_duplicate_style_setter_highlighting`	代码检查：重复的样式属性/事件设置器
`resharper_xaml_dynamic_resource_error_highlighting`	代码检查： {DynamicResource} 只能用于依赖属性
`resharper_xaml_element_name_reference_not_resolved_highlighting`	代码检查：元素名称引用未解析
`resharper_xaml_empty_grid_length_definition_highlighting`	代码检查：网格长度定义不能为空
`resharper_xaml_field_modifier_requires_name_attribute_highlighting`	代码检查： x:FieldModifier 属性需要 x:Name 属性
`resharper_xaml_grid_definitions_can_be_converted_to_attribute_highlighting`	代码检查：网格列/行定义可以转换为属性
`resharper_xaml_ignored_path_highlighting_highlighting`	代码检查：忽略的路径
`resharper_xaml_index_out_of_grid_definition_highlighting`	代码检查：网格元素列/行索引超出网格定义范围
`resharper_xaml_invalid_member_type_highlighting`	代码检查：无效类型的成员
`resharper_xaml_invalid_resource_target_type_highlighting`	代码检查：无效目标类型的 XAML 样式
`resharper_xaml_invalid_resource_type_highlighting`	代码检查：无效类型的 XAML 资源
`resharper_xaml_invalid_type_highlighting`	代码检查：无效类型的对象/标记扩展
`resharper_xaml_language_level_highlighting`	代码检查： XAML 语言级别错误
`resharper_xaml_mapped_path_highlighting_highlighting`	代码检查：映射路径
`resharper_xaml_method_arguments_will_be_ignored_highlighting`	代码检查：方法参数将在生成的代码中被事件的参数替换
`resharper_xaml_missing_grid_index_highlighting`	代码检查：非首个子元素缺少网格列/行设置器
`resharper_xaml_overloads_collision_highlighting`	代码检查：找到具有相同参数数量的多个重载
`resharper_xaml_parent_is_out_of_current_component_tree_highlighting`	代码检查：父级在当前组件树之外
`resharper_xaml_path_error_highlighting`	代码检查：路径错误
`resharper_xaml_possible_null_reference_exception_highlighting`	代码检查：绑定路径中可能存在 'null' 值且没有回退值
`resharper_xaml_redundant_attached_property_highlighting`	代码检查：移除冗余的附加属性设置器
`resharper_xaml_redundant_binding_mode_attribute_highlighting`	代码检查：绑定模式等于默认值
`resharper_xaml_redundant_collection_property_highlighting`	代码检查：冗余的空集合属性设置器
`resharper_xaml_redundant_freeze_attribute_highlighting`	代码检查：冗余的 'Freeze' 属性
`resharper_xaml_redundant_grid_definitions_highlighting`	代码检查：单个网格行/列定义是冗余的
`resharper_xaml_redundant_grid_span_highlighting`	代码检查：单元格网格列/行跨度是冗余的
`resharper_xaml_redundant_modifiers_attribute_highlighting`	代码检查：冗余的修饰符属性
`resharper_xaml_redundant_name_attribute_highlighting`	代码检查：冗余的名称属性
`resharper_xaml_redundant_namespace_alias_highlighting`	代码检查：冗余的命名空间别名
`resharper_xaml_redundant_property_type_qualifier_highlighting`	代码检查：冗余的属性类型限定符
`resharper_xaml_redundant_resource_highlighting`	代码检查：冗余的资源
`resharper_xaml_redundant_styled_value_highlighting`	代码检查：属性值等于样式提供的值
`resharper_xaml_redundant_update_source_trigger_attribute_highlighting`	代码检查： UpdateSourceTrigger=Default 是多余的
`resharper_xaml_redundant_xamarin_forms_class_declaration_highlighting`	代码检查：由于 x:Key 属性，无法通过类名访问资源
`resharper_xaml_resource_file_path_case_mismatch_highlighting`	代码检查：资源路径区分大小写
`resharper_xaml_routed_event_resolve_error_highlighting`	代码检查：缺少路由事件描述符字段
`resharper_xaml_static_resource_not_resolved_highlighting`	代码检查：静态资源未解析
`resharper_xaml_style_class_not_found_highlighting`	代码检查：未找到样式类
`resharper_xaml_style_invalid_target_type_highlighting`	代码检查：样式目标类型无法转换为基类型
`resharper_xaml_unexpected_element_highlighting`	代码检查：意外的元素错误
`resharper_xaml_unexpected_text_token_highlighting`	代码检查：意外的文本标记错误
`resharper_xaml_x_key_attribute_disallowed_highlighting`	代码检查： x:Key 仅适用于资源和字典元素
`resharper_xaml_xaml_duplicate_device_family_type_view_highlighting_highlighting`	代码检查：重复的设备系列视图
`resharper_xaml_xaml_mismatched_device_family_view_clr_name_highlighting_highlighting`	代码检查：特定于 DeviceFamily 的视图类型名称与通用类型名称不匹配
`resharper_xaml_xaml_relative_source_default_mode_warning_highlighting_highlighting`	代码检查：未显式设置 RelativeSourceMode
`resharper_xaml_xaml_unknown_device_family_type_highlighting_highlighting`	代码检查：未知的 DeviceFamily
`resharper_xaml_xaml_xamarin_forms_data_type_and_binding_context_type_mismatched_highlighting_highlighting`	代码检查： x:DataType 和 BindingContext 中的类型不匹配
`resharper_xml_doc_comment_syntax_problem_highlighting`	代码检查： XML 代码注释中存在非法语法
`resharper_xunit_xunit_test_with_console_output_highlighting`	代码检查： Xunit 测试中的控制台输出
`resharper_zero_index_from_end_highlighting`	代码检查：从末尾的索引必须大于零；使用 '^1' 引用最后一个元素
`shaderlab_alignment_tab_fill_style`	制表符和缩进 - 使用制表符进行缩进时如何对齐（ShaderLab）
`shaderlab_allow_far_alignment`	制表符和缩进 - 即使结果缩进过大也要对齐（ShaderLab）
`shaderlab_brace_style`	大括号布局样式（通用化）
`shaderlab_indent_size`	制表符和缩进 - 缩进大小（ShaderLab）
`shaderlab_indent_style`	制表符和缩进 - 缩进样式（ShaderLab）
`shaderlab_tab_width`	制表符和缩进 - 制表符宽度（ShaderLab）
`simple_embedded_statement_style`	换行 - 在单个嵌入语句中换行，可用于：
`sort_usings_with_system_first`	引用限定和 'using' 指令 - 排序 'using' 指令时优先放置 'System.' 和 'Windows.' 命名空间（C#）
`space_after_ampersand_op`	一元运算符后 - 不安全的取地址运算符 (&)（C#）
`space_after_asterik_op`	一元运算符后 - 不安全的星号运算符 (*)（C#）
`space_after_attribute_colon`	围绕冒号 - 在其他冒号之后 (C#)
`space_after_attribute_target_colon`	属性 - 属性目标冒号后 (VB.NET)
`space_after_attributes`	属性 - 属性后（C#）
`space_after_cast`	其他 - 类型转换括号后，可用于： C#
`space_after_colon`	围绕冒号 - 在其他冒号之后 (C#)
`space_after_colon_in_case`	冒号周围 - “case”语句中的冒号后，可用于： C#
`space_after_colon_in_inheritance_clause`	冒号周围 - 基类型列表冒号后，可用于： C#
`space_after_comma`	逗号后空格（通用）
`space_after_keywords_in_control_flow_statements`	控制流语句括号前空格（通用）
`space_after_last_attribute`	标签头部内部 - 最后一个属性后的空格，可用于：
`space_after_last_pi_attribute`	处理指令 - 最后一个属性后的空格，可用于：
`space_after_logical_not_op`	一元运算符后 - 逻辑非运算符 (!)（C#）
`space_after_operator_keyword`	其他 - 运算符关键字后（C#）
`space_after_property_colon`	属性 - 冒号后，可用于：
`space_after_semicolon_in_for_statement`	逗号和分号周围 - “for”分号后，可用于： C#
`space_after_ternary_colon`	三元运算符中 - “:”后，可用于： C#
`space_after_ternary_quest`	三元运算符中 - “?”后，可用于： C#
`space_after_type_parameter_constraint_colon`	冒号周围 - 类型参数约束冒号后，可用于： C#
`space_after_unary_minus_op`	一元运算符后 - 一元减号运算符 (-)（C#）
`space_after_unary_op`	操作周围 - 一元运算符之后 (VB.NET)
`space_after_unary_operator`	一元运算符后空格 (!, -, ~,...)（通用）
`space_after_unary_plus_op`	一元运算符后 - 一元加号运算符 (+)（C#）
`space_around_additive_op`	在二元运算符周围 - 加法运算符（+，-），适用于： C#， VB.NET
`space_around_alias_eq`	其他 - 命名空间别名指令中的 '=' 周围，可用于： C#
`space_around_arrow_op`	二元运算符周围 - 不安全箭头运算符（->）（C#）
`space_around_assignment_op`	二元运算符周围 - 赋值运算符（如 '=' 和 '+='），可用于： C#， VB.NET
`space_around_assignment_operator`	在表达式中 - 在赋值运算符周围，适用于：
`space_around_binary_operator`	在二元运算符周围的空格（+，\|\|，=，...）（通用）
`space_around_bitwise_op`	二元运算符周围 - 位运算符（&、\|、^）（C#）
`space_around_dot`	其他 - 在点号周围，适用于： C#， VB.NET
`space_around_equality_op`	二元运算符周围 - 相等运算符（==、!=）（C#）
`space_around_lambda_arrow`	其他 - Lambda 箭头周围（C#）
`space_around_logical_op`	围绕二元运算符 - 逻辑运算符 (&&,\|\|) (C#)
`space_around_member_access_operator`	在成员访问运算符周围的空格（.，->，...）（通用）
`space_around_multiplicative_op`	二元运算符周围 - 乘法运算符（*、/、%），可用于： C#， VB.NET
`space_around_nullcoalescing_op`	围绕二元运算符 - 空合并运算符 (??) (C#)
`space_around_relational_op`	在二元运算符周围 - 关系运算符（<，>，<=，>=），适用于： C#， VB.NET
`space_around_shift_op`	在二元运算符周围 - 移位运算符（<<，>>，>>>），适用于： C#， VB.NET
`space_around_stmt_colon`	其他 - 语句 ':' 周围（VB.NET）
`space_around_ternary_operator`	三元运算符周围的空格（?、:）（通用）
`space_before_array_access_brackets`	数组括号周围 - 数组访问括号前，可用于： C#
`space_before_array_rank_brackets`	在数组括号周围 - 在数组维度括号之前（C#）
`space_before_array_rank_parentheses`	数组 - 数组维度括号前 (VB.NET)
`space_before_attribute_colon`	围绕冒号 - 在其他冒号之前 (C#)
`space_before_attribute_target_colon`	属性 - 属性目标冒号前（VB.NET）
`space_before_catch_parentheses`	语句中的括号前 - 'catch' 括号（C#）
`space_before_checked_parentheses`	在其他括号之前 - 'checked' 和 'unchecked' 括号 (C#)
`space_before_colon`	围绕冒号 - 在其他冒号之前 (C#)
`space_before_colon_in_case`	在冒号周围 - 在 'case' 语句中的冒号之前，适用于： C#
`space_before_colon_in_inheritance_clause`	在冒号周围 - 在基类型列表冒号之前，适用于： C#
`space_before_comma`	逗号前空格（通用）
`space_before_default_parentheses`	在其他括号之前 - 'default' 括号（C#）
`space_before_empty_invocation_parentheses`	附近的括号 - 空调用括号前 (VB.NET)
`space_before_empty_method_call_parentheses`	在其他括号之前 - 方法调用的空括号，适用于： C#
`space_before_empty_method_parentheses`	在其他括号之前 - 方法声明的空括号，适用于： C#， VB.NET
`space_before_fixed_parentheses`	在语句中的括号之前 - 'fixed' 括号（C#）
`space_before_for_parentheses`	在语句中的括号之前 - 'for' 括号（C#）
`space_before_foreach_parentheses`	在语句中的括号之前 - 'foreach' 括号（C#）
`space_before_if_parentheses`	在语句中的括号之前 - 'if' 括号（C#）
`space_before_invocation_parentheses`	附近的括号 - 调用括号前 (VB.NET)
`space_before_label_colon`	其他 - 标签中的 ':' 前 (VB.NET)
`space_before_lock_parentheses`	在语句中的括号之前 - 'lock' 括号（C#）
`space_before_method_call_parentheses`	在其他括号之前 - 方法调用括号，适用于： C#
`space_before_method_parentheses`	在其他括号之前 - 方法声明括号，适用于： C#， VB.NET
`space_before_nameof_parentheses`	在其他括号之前 - 'nameof' 括号 (C#)
`space_before_new_parentheses`	在其他括号之前 - 'new' 括号 (C#)
`space_before_nullable_mark`	其他 - 在可空标记之前（C#）
`space_before_open_square_brackets`	括号前的空格（通用）
`space_before_pointer_asterik_declaration`	其他 - 在不安全指针声明之前（C#）
`space_before_property_colon`	属性 - 在冒号之前，适用于：
`space_before_self_closing`	在标签头部内部 - 在 '/>' 之前的空格，适用于：
`space_before_semicolon`	在逗号和分号周围 - 在分号之前，适用于： C#
`space_before_semicolon_in_for_statement`	逗号和分号周围 - 在 'for' 分号之前，可用于： C#
`space_before_singleline_accessorholder`	围绕大括号 - 在单行访问器块之前 (C#)
`space_before_sizeof_parentheses`	在其他括号之前 - 'sizeof' 括号 (C#)
`space_before_switch_parentheses`	语句中括号之前 - 'switch' 括号（C#）
`space_before_ternary_colon`	三元运算符中 - 在 ':' 之前，可用于： C#
`space_before_ternary_quest`	三元运算符中 - 在 '?' 之前，可用于： C#
`space_before_trailing_comment`	其他 - 在行尾注释之前，可用于： C#
`space_before_type_argument_angle`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`space_before_type_parameter_angle`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`space_before_type_parameter_constraint_colon`	冒号周围 - 在类型参数约束冒号之前，可用于： C#
`space_before_type_parameter_parentheses`	附近的括号 - 类型参数括号前 (VB.NET)
`space_before_typeof_parentheses`	其他括号之前 - 'typeof' 括号（C#）
`space_before_using_parentheses`	语句中括号之前 - 'using' 括号（C#）
`space_before_while_parentheses`	语句中括号之前 - 'while' 括号（C#）
`space_between_accessors_in_singleline_property`	大括号周围 - 在单行属性/事件访问器之间 (C#)
`space_between_attribute_sections`	属性 - 在属性部分之间 (C#)
`space_between_empty_square_brackets`	数组括号周围 - 在数组维度空括号内，可用于： C#
`space_between_keyword_and_expression`	其他括号之前 - 关键字和表达式之间（C#）
`space_between_keyword_and_type`	其他括号之前 - 关键字和类型之间（C#）
`space_between_method_call_empty_parameter_list_parentheses`	其他括号内 - 方法调用空括号内，可用于： C#
`space_between_method_call_name_and_opening_parenthesis`	方法调用括号之前的空格 (通用)
`space_between_method_call_parameter_list_parentheses`	其他括号内 - 方法调用括号内，可用于： C#
`space_between_method_declaration_empty_parameter_list_parentheses`	其他括号内 - 方法声明空括号内，可用于： C#
`space_between_method_declaration_name_and_open_parenthesis`	方法声明括号之前的空格 (通用)
`space_between_method_declaration_parameter_list_parentheses`	其他括号内 - 方法声明括号内，可用于： C#
`space_between_parentheses_of_control_flow_statements`	控制流语句括号内的空格 (通用)
`space_between_square_brackets`	括号内的空格 (通用)
`space_between_typecast_parentheses`	其他括号内 - 类型转换括号内，可用于： C#
`space_in_singleline_accessorholder`	大括号周围 - 在单行访问器内 (C#)
`space_in_singleline_anonymous_method`	大括号周围 - 在单行匿名方法内 (C#)
`space_in_singleline_method`	大括号周围 - 在单行方法内 (C#)
`space_near_postfix_and_prefix_op`	一元运算符之后 - 在 ++ 和 -- 之前/之后 (C#)
`space_within_array_access_brackets`	数组括号周围 - 在数组访问括号内，可用于： C#
`space_within_array_initialization_braces`	数组 - 在数组初始化大括号内 (VB.NET)
`space_within_array_rank_brackets`	数组括号周围 - 数组维度括号内（C#）
`space_within_array_rank_empty_brackets`	数组括号周围 - 在空数组维度括号内（C#）
`space_within_array_rank_empty_parentheses`	数组 - 在空数组维度括号内 (VB.NET)
`数组维度括号中的空格`	数组 - 在数组维度括号内 (VB.NET)
`特性尖括号中的空格`	属性 - 在属性尖括号内 (VB.NET)
`特性方括号中的空格`	属性 - 属性括号内（C#）
`catch 括号中的空格`	语句中的括号内 - 'catch' 括号 (C#)
`checked 括号中的空格`	其他括号内 - 'checked' 和 'unchecked' 括号 (C#)
`default 括号中的空格`	其他括号内 - 'default' 括号（C#）
`空代码块中的空格`	大括号周围 - 空大括号之间的空格（C#）
`空方法调用括号中的空格`	附近的括号 - 在空调用括号内 (VB.NET)
`空方法括号中的空格`	附近的括号 - 在空方法声明括号内 (VB.NET)
`表达式括号中的空格`	表达式 - 在括号内，可用于：， VB.NET
`fixed 括号中的空格`	语句中括号内 - 'fixed' 括号（C#）
`for 括号中的空格`	语句中括号内 - 'for' 括号（C#）
`foreach 括号中的空格`	语句中括号内 - 'foreach' 括号（C#）
`if 括号中的空格`	语句中括号内 - 'if' 括号（C#）
`调用括号中的空格`	附近的括号 - 调用括号内 (VB.NET)
`列表模式方括号中的空格`	数组括号周围 - 列表模式和集合表达式括号内（C#）
`lock 括号中的空格`	语句中括号内 - 'lock' 括号（C#）
`方法括号中的空格`	附近的括号 - 方法声明括号内 (VB.NET)
`nameof 括号中的空格`	其他括号内 - 'nameof' 括号（C#）
`new 括号中的空格`	其他括号内 - 'new' 括号（C#）
`括号中的空格`	其他括号内 - 括号，适用于： C#
`单行数组初始化器大括号中的空格`	大括号周围 - 单行表达式大括号内（C#）
`sizeof 括号中的空格`	其他括号内 - 'sizeof' 括号 (C#)
`切片模式中的空格`	其他 - 切片模式中 '..' 之后（C#）
`switch 括号中的空格`	语句中括号内 - 'switch' 括号（C#）
`元组括号中的空格`	附近的括号 - 元组括号内 (VB.NET)
`类型实参尖括号中的空格`	尖括号周围 - 类型参数尖括号（C#）
`类型参数尖括号中的空格`	尖括号周围 - 类型形参尖括号（C#）
`类型参数括号中的空格`	附近括号 - 类型参数括号内 (VB.NET)
`typeof 括号中的空格`	其他括号内 - 'typeof' 括号（C#）
`using 括号中的空格`	语句中括号内 - 'using' 括号（C#）
`while 括号中的空格`	语句中括号内 - 'while' 括号（C#）
`特性中等号两侧的空格`	标签头部内部 - 属性中 '=' 周围的空格，适用于：
`PI 特性中等号两侧的空格`	处理指令 - 属性中 '=' 周围的空格，适用于：
`标签中的空格`	标签内容 - 起始标签后和结束标签前的空格，适用于：
`对 else if 的特殊处理`	通用 - 特殊 'else if' 处理，适用于： C#
`为 static 成员限定成员`	静态成员限定 - 需要限定的成员（C#）
`static 成员限定方式`	静态成员限定 - 使用名称限定（C#）
`粘连注释`	其他缩进 - 不缩进从第一列开始的注释，适用于： C#， VB.NET
`tab_width`	通用 - 制表符宽度，适用于： C#， ShaderLab， VB.NET
`多行列表中末尾逗号`	尾随逗号 - 多行列表中新行前 (C#)
`单行列表中末尾逗号`	尾随逗号 - 当最后一个元素后没有换行时（C#）
`类型声明的大括号`	大括号布局 - 类型和命名空间声明，适用于： C#
`在初始化器大括号内使用连续缩进`	大括号布局 - 在表达式大括号内使用连续行缩进 (C#)
`在括号内使用连续缩进`	括号 - 在括号内使用连续行缩进 (C#)
`正文样式使用启发式`	代码主体 - 应用样式启发式规则（C#）
`缩进继承自前一个元素`	其他缩进 - 在部分格式中使用前一个元素的缩进 (C#)
`使用旧版引擎`	为 Razor 格式化使用旧引擎 (Razor CSharp)
`对显式类型使用 Roslyn 逻辑`	声明中 'var' 的使用 - 偏好 Roslyn (Visual Studio) 的类型推断逻辑 (C#)
`对多行参数进行对齐`	对齐多行结构 - 调用参数 (VB.NET)
`对多行数组初始化器进行对齐`	对齐多行结构 - 数组初始化器（VB.NET）
`对多行表达式进行对齐`	对齐多行结构 - 表达式 (VB.NET)
`对多行 Implements 列表进行对齐`	对齐多行结构 - Implements/handles 列表 (VB.NET)
`对多行参数进行对齐`	对齐多行结构 - 方法参数 (VB.NET)
`对多个声明进行对齐`	对齐多行结构 - 多声明列表 (VB.NET)
`对齐制表符填充样式`	制表符和缩进 - 使用制表符缩进时的对齐方式 (VB.NET)
`允许使用别名`	引用限定 - 允许 'Imports' 别名指令 (VB.NET)
`Imports 后的空行数`	空行 - 在 Imports 部分之后 (VB.NET)
`Options 后的空行数`	空行 - 在文件选项部分之后（VB.NET）
`字段周围的空行数`	空行 - 在多行字段周围 (VB.NET)
`全局特性周围的空行数`	空行 - 全局属性之后 (VB.NET)
`可调用成员周围的空行数`	空行 - 在多行方法周围 (VB.NET)
`命名空间周围的空行数`	空行 - 在命名空间周围 (VB.NET)
`区域周围的空行数`	空行 - 区域周围 (VB.NET)
`单行字段周围的空行数`	空行 - 单行字段周围 (VB.NET)
`单行可调用成员周围的空行数`	空行 - 单行方法周围 (VB.NET)
`类型周围的空行数`	空行 - 类型周围 (VB.NET)
`区域内部的空行数`	空行 - 区域内部 (VB.NET)
`对 Select 中的 Case 进行缩进`	其他 - 将“case”缩进到“select”（VB.NET）
`缩进大小`	制表符和缩进 - 缩进大小 (VB.NET)
`缩进样式`	制表符和缩进 - 缩进样式 (VB.NET)
`保留代码中的空行`	保留现有格式 - 保留代码中的最大空行数 (VB.NET)
`保留声明中的空行`	保留现有格式 - 保留声明中的最大空行数 (VB.NET)
`保留用户换行符`	保留现有格式 - 保留现有换行符 (VB.NET)
`最大行长度`	换行 - 硬换行位置 (VB.NET)
`将事件特性放在同一行`	属性 - 将事件属性放在同一行 (VB.NET)
`将字段特性放在同一行`	属性 - 将字段属性放在同一行 (VB.NET)
`将方法特性放在同一行`	属性 - 将方法属性放在同一行 (VB.NET)
`将属性特性放在同一行`	属性 - 将属性的属性放在同一行 (VB.NET)
`将类型特性放在同一行`	属性 - 将类型属性放在同一行 (VB.NET)
`更喜欢限定引用`	引用限定 - 优先使用完全限定引用 (VB.NET)
`特性目标冒号后的空格`	属性 - 属性目标冒号后 (VB.NET)
`逗号后的空格`	其他 - 逗号后（VB.NET）
`一元运算符后的空格`	操作周围 - 一元运算符之后 (VB.NET)
`一元运算符后的空格`	操作周围 - 一元运算符之后 (VB.NET)
`加法运算符两侧的空格`	操作周围 - 加法运算符（+，-） (VB.NET)
`赋值运算符两侧的空格`	操作周围 - 赋值运算符（例如 '=' 和 '+=') (VB.NET)
`二元运算符两侧的空格`	二元运算符周围的空格（+，\|\|，=，...）（通用）
`点运算符两侧的空格`	其他 - '.' 周围 (VB.NET)
`成员访问运算符两侧的空格`	其他 - '.' 周围 (VB.NET)
`乘法运算符两侧的空格`	操作周围 - 乘法运算符 (如 '*' 和 '/') (VB.NET)
`关系运算符两侧的空格`	操作周围 - 关系运算符（<，>，<=，>=） (VB.NET)
`位移运算符两侧的空格`	操作周围 - 移位运算符（<<，>>） (VB.NET)
`语句冒号两侧的空格`	其他 - 语句 ':' 周围（VB.NET）
`数组维度括号前的空格`	数组 - 数组维度括号前 (VB.NET)
`特性目标冒号前的空格`	属性 - 属性目标冒号前 (VB.NET)
`逗号前的空格`	其他 - ',' 之前 (VB.NET)
`空方法调用括号前的空格`	附近的括号 - 空调用括号前 (VB.NET)
`空方法括号前的空格`	附近的括号 - 空方法声明括号前 (VB.NET)
`调用括号前的空格`	附近的括号 - 调用括号前 (VB.NET)
`标签冒号前的空格`	其他 - 标签中的 ':' 前 (VB.NET)
`方法括号前的空格`	附近的括号 - 方法声明括号前 (VB.NET)
`类型参数括号前的空格`	附近的括号 - 类型参数括号前 (VB.NET)
`数组初始化器大括号内的空格`	数组 - 在数组初始化大括号内 (VB.NET)
`数组维度空括号内的空格`	数组 - 在空数组维度括号内 (VB.NET)
`数组维度括号中的空格`	数组 - 在数组维度括号内 (VB.NET)
`特性尖括号中的空格`	属性 - 在属性尖括号内 (VB.NET)
`空调用括号中的空格`	附近的括号 - 在空调用括号内 (VB.NET)
`空方法括号中的空格`	附近的括号 - 在空方法声明括号内 (VB.NET)
`表达式括号中的空格`	附近的括号 - 表达式括号内 (VB.NET)
`调用括号中的空格`	附近的括号 - 调用括号内 (VB.NET)
`方法括号中的空格`	附近的括号 - 方法声明括号内 (VB.NET)
`元组括号中的空格`	附近的括号 - 元组括号内 (VB.NET)
`类型参数括号中的空格`	附近括号 - 类型参数括号内 (VB.NET)
`vb_stick_comment`	其他 - 不缩进从第一列开始的注释 (VB.NET)
`vb_tab_width`	制表符和缩进 - 制表符宽度 (VB.NET)
`vb_wrap_arguments_style`	换行 - 包装调用参数 (VB.NET)
`vb_wrap_before_binary_opsign`	换行 - 优先在二元表达式中的运算符前换行 (VB.NET)
`vb_wrap_before_declaration_lpar`	换行 - 优先在方法声明中的 '(' 前换行 (VB.NET)
`vb_wrap_before_invocation_lpar`	换行 - 优先在调用中的 '(' 前换行 (VB.NET)
`vb_wrap_extends_list_style`	换行 - 换行扩展/实现/处理列表 (VB.NET)
`vb_wrap_multiple_declaration_style`	换行 - 换行多声明列表 (VB.NET)
`vb_wrap_parameters_style`	换行 - 换行形式参数 (VB.NET)
`wrap_after_declaration_lpar`	方法签名排列 - 优先在声明中的 '(' 后换行，可用于： C#
`wrap_after_dot_in_method_calls`	成员访问表达式排列 - 优先在 '.' 后换行 (C#)
`wrap_after_invocation_lpar`	调用排列 - 优先在调用中的 '(' 后换行，可用于： C#
`wrap_after_primary_constructor_declaration_lpar`	主构造函数签名排列 - 优先在声明中的 '(' 后换行 (C#)
`wrap_after_property_in_chained_method_calls`	成员访问表达式排列 - 优先在链式方法调用中的属性和字段后换行 (C#)
`wrap_arguments_style`	调用排列 - 换行调用参数，可用于： C#， VB.NET
`wrap_around_elements`	标签内容 - 在元素前后换行，可用于：
`wrap_array_initializer_style`	初始化器排列 - 换行数组初始化器 (C#)
`wrap_before_arrow_with_expressions`	表达式主体成员排列 - 优先在 '=>' 前换行并跟随表达式 (C#)
`wrap_before_binary_opsign`	二元表达式排列 - 优先在二元表达式中的运算符前换行，可用于： C#， VB.NET
`wrap_before_binary_pattern_op`	二元表达式排列 - 优先在二元模式中的运算符前换行 (C#)
`wrap_before_comma`	通用 - 优先在 ',' 前换行，适用于： C#
`wrap_before_declaration_lpar`	方法签名排列 - 优先在声明中的 '(' 前换行，可用于： C#， VB.NET
`wrap_before_declaration_rpar`	方法签名排列 - 优先在声明中的 ')' 前换行，可用于： C#
`wrap_before_eq`	通用 - 优先在 '=' 前换行（C#）
`wrap_before_extends_colon`	类型参数、约束和基类型排列 - 优先在 ':' 前换行 (C#)
`wrap_before_first_method_call`	成员访问表达式排列 - 优先在第一个方法调用前换行 (C#)
`wrap_before_first_type_parameter_constraint`	类型参数、约束和基类型排列 - 优先在第一个约束前换行，可用于： C#
`wrap_before_invocation_lpar`	调用排列 - 优先在调用中的 '(' 前换行，可用于： C#， VB.NET
`wrap_before_invocation_rpar`	调用排列 - 优先在调用中的 ')' 前换行，可用于： C#
`wrap_before_linq_expression`	LINQ 表达式排列 - 优先在多行 LINQ 表达式前换行 (C#)
`wrap_before_primary_constructor_declaration_lpar`	主构造函数签名排列 - 优先在声明中的 '(' 前换行 (C#)
`wrap_before_primary_constructor_declaration_rpar`	主构造函数签名排列 - 优先在声明中的 ')' 前换行 (C#)
`wrap_before_ternary_opsigns`	三元表达式排列 - 优先在三元表达式中的 '?' 和 ':' 前换行，可用于： C#
`wrap_before_type_parameter_langle`	类型参数、约束和基类型排列 - 优先在类型参数列表中的开尖括号前换行 (C#)
`wrap_chained_binary_expressions`	二元表达式排列 - 换行链式二元表达式，可用于： C#
`wrap_chained_binary_patterns`	二元表达式排列 - 换行复杂的二元模式 (C#)
`wrap_chained_method_calls`	成员访问表达式排列 - 换行链式方法调用，可用于： C#
`wrap_enum_declaration`	枚举排列 - 换行枚举声明 (C#)
`wrap_extends_list_style`	类型参数、约束和基类型排列 - 换行扩展/实现列表，可用于： C#， VB.NET
`wrap_for_stmt_header_style`	语句排列 - 换行 'for' 语句头部，可用于： C#
`wrap_linq_expressions`	LINQ 表达式排列 - 换行 LINQ 表达式 (C#)
`wrap_list_pattern`	列表模式排列 - 换行列表模式和集合表达式 (C#)
`wrap_multiple_declaration_style`	语句排列 - 换行多声明，可用于： C#， VB.NET
`wrap_multiple_type_parameter_constraints_style`	类型参数、约束和基类型排列 - 换行多个类型参数约束，可用于： C#
`wrap_object_and_collection_initializer_style`	初始化器排列 - 换行对象和集合初始化器 (C#)
`wrap_parameters_style`	方法签名排列 - 换行形式参数，可用于： C#， VB.NET
`wrap_primary_constructor_parameters_style`	主构造函数签名排列 - 换行主构造函数参数 (C#)
`wrap_property_pattern`	属性模式排列 - 换行属性模式 (C#)
`wrap_switch_expression`	切换表达式排列 - 换行切换表达式 (C#)
`wrap_tags_and_pi`	换行 - 换行标签和处理指令，适用于：
`wrap_ternary_expr_style`	三元表达式的排列 - 换行三元表达式，适用于： C#
`wrap_text`	标签内容 - 换行内部文本，适用于：
`wrap_verbatim_interpolated_strings`	插值字符串的排列 - 换行插值字符串 (C#)

最后修改日期： 2025年 9月 26日