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)
`blank_lines_around_razor_helpers`	Razor 助手周围的空行 (Razor CSharp)
`blank_lines_around_razor_sections`	Razor 区段周围的空行 (Razor CSharp)
`blank_lines_around_region`	常规 - 区域周围，可用于： C#、 VB.NET
`blank_lines_around_single_line_accessor`	声明中的空行 - 单行属性/事件访问器周围（C#）
`blank_lines_around_single_line_auto_property`	声明中的空行 - 单行自动/抽象属性/事件周围（C#）
`blank_lines_around_single_line_field`	声明中的空行 - 单行字段周围，可用于： C#、 VB.NET
`blank_lines_around_single_line_invocable`	声明中的空行 - 单行方法周围，可用于： C#、 VB.NET
`blank_lines_around_single_line_local_method`	代码中的空行 - 单行局部函数周围（C#）
`blank_lines_around_single_line_property`	声明中的空行 - 单行属性/事件周围（C#）
`blank_lines_around_single_line_type`	声明中的空行 - 单行类型周围（C#）
`blank_lines_around_type`	声明中的空行 - 类型周围，可用于： C#、 VB.NET
`blank_lines_before_block_statements`	代码中的空行 - 带子块的语句之前（C#）
`blank_lines_before_case`	代码中的空行 - switch 语句中的 'case' 之前（C#）
`blank_lines_before_control_transfer_statements`	代码中的空行 - 带控制转移的语句之前（C#）
`blank_lines_before_multiline_statements`	代码中的空行 - 在多行语句之前（C#）
`blank_lines_before_single_line_comment`	通用 - 单行注释之前（C#）
`blank_lines_between_using_groups`	声明中的空行 - 不同 'using' 组之间（C#）
`blank_lines_inside_namespace`	声明中的空行 - 命名空间内（C#）
`blank_lines_inside_region`	常规 - 区域内，可用于： C#、 VB.NET
`blank_lines_inside_type`	声明中的空行 - 类型内（C#）
`brace_style`	大括号布局样式（通用）
`braces_for_dowhile`	大括号 - 在 'do-while' 语句中（C#）
`braces_for_fixed`	大括号 - 在 'fixed' 语句中（C#）
`braces_for_for`	大括号 - 在 'for' 语句中（C#）
`braces_for_foreach`	大括号 - 在 'foreach' 语句中（C#）
`braces_for_ifelse`	大括号 - 在 'if' 语句中（C#）
`braces_for_lock`	大括号 - 在 'lock' 语句中（C#）
`braces_for_using`	大括号 - 在 'using' 语句中（C#）
`braces_for_while`	大括号 - 在 'while' 语句中（C#）
`braces_redundant`	大括号 - 删除冗余的大括号（C#）
`builtin_type_apply_to_native_integer`	内置类型 - 也适用于本机大小的整数类型（C#）
`builtin_type_reference_for_member_access_style`	内置类型 - 在成员访问表达式中，优先使用（C#）
`builtin_type_reference_style`	内置类型 - 在局部变量、成员和参数中，优先使用（C#）
`can_use_global_alias`	引用限定和 'using' 指令 - 允许使用 'global::' 前缀（C#）
`case_block_braces`	大括号布局 - 'case' 标签下的块，可用于： C#
`constructor_or_destructor_body`	代码体 - 构造函数和析构函数（C#）
`continuous_indent_multiplier`	通用 - 连续行缩进倍数（C#）
`cpp_brace_style`	大括号布局样式（通用化）
`cpp_space_after_comma`	逗号后空格（通用）
`cpp_space_before_comma`	逗号前空格（通用）
`cpp_space_between_method_call_name_and_opening_parenthesis`	方法调用括号之前的空格 (通用)
`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`	代码中的空行 - 多行 'case' 部分在 switch 语句中（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#）
`csharp_blank_lines_around_single_line_field`	声明中的空行 - 在单行字段周围（C#）
`csharp_blank_lines_around_single_line_invocable`	声明中的空行 - 单行方法周围（C#）
`csharp_blank_lines_around_single_line_local_method`	代码中的空行 - 单行局部函数周围（C#）
`csharp_blank_lines_around_single_line_property`	声明中的空行 - 单行属性/事件周围（C#）
`csharp_blank_lines_around_single_line_type`	声明中的空行 - 单行类型周围（C#）
`csharp_blank_lines_around_type`	声明中的空行 - 类型周围（C#）
`csharp_blank_lines_before_block_statements`	代码中的空行 - 带子块的语句之前（C#）
`csharp_blank_lines_before_case`	代码中的空行 - switch 语句中的 'case' 之前（C#）
`csharp_blank_lines_before_control_transfer_statements`	代码中的空行 - 在带有控制转移的语句之前（C#）
`csharp_blank_lines_before_multiline_statements`	代码中的空行 - 多行语句之前（C#）
`csharp_blank_lines_before_single_line_comment`	通用 - 单行注释之前（C#）
`csharp_blank_lines_between_using_groups`	声明中的空行 - 不同 'using' 组之间（C#）
`csharp_blank_lines_inside_namespace`	声明中的空行 - 命名空间内（C#）
`csharp_blank_lines_inside_region`	通用 - 在区域内部（C#）
`csharp_blank_lines_inside_type`	声明中的空行 - 在类型内部（C#）
`csharp_brace_style`	大括号布局样式（通用）
`csharp_braces_for_dowhile`	大括号 - 在 'do-while' 语句中（C#）
`csharp_braces_for_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#)
`csharp_wrap_arguments_style`	调用的排列 - 换行调用参数 (C#)
`csharp_wrap_array_initializer_style`	初始化器排列 - 换行数组初始化器 (C#)
`csharp_wrap_before_arrow_with_expressions`	表达式主体成员排列 - 优先在 '=>' 前换行并跟随表达式 (C#)
`csharp_wrap_before_binary_opsign`	二元表达式的排列 - 偏好在二元表达式中的运算符前换行 (C#)
`csharp_wrap_before_binary_pattern_op`	二元表达式排列 - 优先在二元模式中的运算符前换行 (C#)
`csharp_wrap_before_comma`	常规 - 更倾向于在 ',' 前换行 (C#)
`csharp_wrap_before_declaration_lpar`	方法签名的排列 - 偏好在声明中 '(' 前换行 (C#)
`csharp_wrap_before_declaration_rpar`	方法签名的排列 - 偏好在声明中 ')' 前换行 (C#)
`csharp_wrap_before_eq`	通用 - 优先在 '=' 前换行（C#）
`csharp_wrap_before_extends_colon`	类型参数、约束和基类型排列 - 优先在 ':' 前换行 (C#)
`csharp_wrap_before_first_method_call`	成员访问表达式排列 - 优先在第一个方法调用前换行 (C#)
`csharp_wrap_before_first_type_parameter_constraint`	类型参数、约束和基类型的排列 - 偏好在第一个约束前换行 (C#)
`csharp_wrap_before_invocation_lpar`	调用的排列 - 偏好在调用中 '(' 前换行 (C#)
`csharp_wrap_before_invocation_rpar`	调用的排列 - 偏好在调用中 ')' 前换行 (C#)
`csharp_wrap_before_linq_expression`	LINQ 表达式排列 - 优先在多行 LINQ 表达式前换行 (C#)
`csharp_wrap_before_primary_constructor_declaration_lpar`	主构造函数签名排列 - 优先在声明中的 '(' 前换行 (C#)
`csharp_wrap_before_primary_constructor_declaration_rpar`	主构造函数签名排列 - 优先在声明中的 ')' 前换行 (C#)
`csharp_wrap_before_ternary_opsigns`	三元表达式的排列 - 偏好在三元表达式中的 '?' 和 ':' 前换行 (C#)
`csharp_wrap_before_type_parameter_langle`	类型参数、约束和基类型排列 - 优先在类型参数列表中的开尖括号前换行 (C#)
`csharp_wrap_chained_binary_expressions`	二元表达式的排列 - 换行链式二元表达式 (C#)
`csharp_wrap_chained_binary_patterns`	二元表达式排列 - 换行复杂的二元模式 (C#)
`csharp_wrap_chained_method_calls`	成员访问表达式的排列 - 换行链式方法调用 (C#)
`csharp_wrap_enum_declaration`	枚举排列 - 换行枚举声明 (C#)
`csharp_wrap_extends_list_style`	类型参数、约束和基类型的排列 - 换行扩展/实现列表 (C#)
`csharp_wrap_for_stmt_header_style`	语句的排列 - 换行 'for' 语句头部 (C#)
`csharp_wrap_linq_expressions`	LINQ 表达式排列 - 换行 LINQ 表达式 (C#)
`csharp_wrap_list_pattern`	列表模式排列 - 换行列表模式和集合表达式 (C#)
`csharp_wrap_multiple_declaration_style`	语句的排列 - 换行多重声明 (C#)
`csharp_wrap_multiple_type_parameter_constraints_style`	类型参数、约束和基类型的排列 - 换行多重类型参数约束 (C#)
`csharp_wrap_object_and_collection_initializer_style`	初始化器排列 - 换行对象和集合初始化器 (C#)
`csharp_wrap_parameters_style`	方法签名的排列 - 换行形式参数 (C#)
`csharp_wrap_primary_constructor_parameters_style`	主构造函数签名排列 - 换行主构造函数参数 (C#)
`csharp_wrap_property_pattern`	属性模式排列 - 换行属性模式 (C#)
`csharp_wrap_switch_expression`	切换表达式排列 - 换行切换表达式 (C#)
`csharp_wrap_ternary_expr_style`	三元表达式的排列 - 换行三元表达式 (C#)
`csharp_wrap_verbatim_interpolated_strings`	插值字符串的排列 - 换行插值字符串 (C#)
`default_internal_modifier`	修饰符 - 更倾向于为类型使用显式/隐式 internal 修饰符（C#）
`default_private_modifier`	修饰符 - 更倾向于为类型成员使用显式/隐式 private 修饰符（C#）
`default_value_when_type_evident`	默认值 - 当类型从用法中显而易见时 (C#)
`default_value_when_type_not_evident`	默认值 - 当类型从用法中不显而易见时 (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#
`indent_method_decl_pars`	括号 - 方法声明的括号缩进，可用于： C#
`indent_nested_fixed_stmt`	嵌套语句 - 缩进嵌套的“fixed”语句（C#）
`indent_nested_for_stmt`	嵌套语句 - 缩进嵌套的“for”语句（C#）
`indent_nested_foreach_stmt`	嵌套语句 - 缩进嵌套的 'foreach' 语句（C#）
`indent_nested_lock_stmt`	嵌套语句 - 缩进嵌套的 'lock' 语句（C#）
`indent_nested_usings_stmt`	嵌套语句 - 缩进嵌套的“using”语句（C#）
`indent_nested_while_stmt`	嵌套语句 - 缩进嵌套的“while”语句（C#）
`indent_pars`	括号 - 其他括号和方括号的缩进，可用于： C#
`indent_preprocessor_if`	预处理指令 - 缩进 #if、#else、#elif、#endif（C#）
`indent_preprocessor_other`	预处理指令 - 缩进其他预处理指令（C#）
`indent_preprocessor_region`	预处理指令 - 缩进 #region、#endregion（C#）
`indent_primary_constructor_decl_pars`	括号 - 主构造函数声明的括号缩进（C#）
`indent_raw_literal_string`	对齐多行结构 - 如何缩进原始字符串字面量（C#）
`indent_size`	通用 - 缩进大小，可用于： C#、 ShaderLab、 VB.NET
`indent_statement_pars`	括号 - 语句（if、while、for 等）的括号缩进，可用于： C#
`indent_style`	常规 - 缩进样式，可用于： C#、 ShaderLab、 VB.NET
`indent_switch_labels`	其他缩进 - 从“switch”缩进“case”，可用于： C#
`indent_text`	标签内容 - 在包含文本的元素内缩进，可用于：
`indent_type_constraints`	其他缩进 - 类型约束的缩进，可用于： C#
`indent_typearg_angles`	括号 - 类型参数的角括号缩进（C#）
`indent_typeparam_angles`	括号 - 类型参数的角括号缩进（C#）
`initializer_braces`	大括号布局 - 表达式（初始化器、switch 表达式、模式、集合表达式）（C#）
`insert_final_newline`	常规 - 文件末尾换行，可用于： C#
`instance_members_qualify_declared_in`	实例成员限定 - 限定在（C#）中声明的成员
`instance_members_qualify_members`	实例成员限定 - 对其使用 'this.' 限定符（C#）
`int_align`	对齐相似代码到列（通用化）
`int_align_assignments`	将相似代码对齐到列 - 其他赋值和初始化器（C#）
`int_align_binary_expressions`	对齐相似代码到列 - 二元表达式（C#）
`int_align_comments`	将相似代码对齐到列 - 结束注释，可用于： C#
`int_align_fields`	将相似代码对齐到列 - 字段和常量（C#）
`int_align_fix_in_adjacent`	将相似代码对齐到列 - 修复相邻行的列对齐，可用于： C#
`int_align_invocations`	对齐相似代码为列 - 相同方法的调用 (C#)
`int_align_methods`	将相似代码对齐到列 - 简单方法、运算符、委托（C#）
`int_align_nested_ternary`	将相似代码对齐到列 - 嵌套三元运算符（C#）
`int_align_parameters`	将相似代码对齐到列 - 多行方法签名（C#）
`int_align_properties`	将相似代码对齐到列 - 属性和事件（C#）
`int_align_property_patterns`	将相似代码对齐到列 - 属性模式（C#）
`int_align_switch_expressions`	将相似代码对齐到列 - Switch 表达式（C#）
`int_align_switch_sections`	将相似代码对齐到列 - 简单的 Switch 部分（C#）
`int_align_variables`	对齐相似代码为列 - 变量和局部常量 (C#)
`invocable_declaration_braces`	大括号布局 - 方法声明，可用于： C#
`js_brace_style`	大括号布局样式（通用化）
`js_space_between_method_call_name_and_opening_parenthesis`	方法调用括号之前的空格 (通用)
`js_space_between_method_declaration_name_and_open_parenthesis`	方法声明括号之前的空格 (通用)
`js_space_between_square_brackets`	括号内的空格（通用）
`keep_blank_lines_between_declarations`	空行 - 声明之间的最大空行数，适用于：
`keep_blank_lines_in_code`	代码中的空行 - 保持代码中的最大空行数，适用于： C#、 VB.NET
`keep_blank_lines_in_declarations`	声明中的空行 - 保持声明中的最大空行数，适用于： C#、 VB.NET
`keep_existing_arrangement`	保持现有代码排列（单行/多行）（通用）
`keep_existing_attribute_arrangement`	属性排列 - 保留现有的属性排列（C#）
`keep_existing_declaration_block_arrangement`	声明块排列 - 保留声明块的现有排列 (C#)
`keep_existing_declaration_parens_arrangement`	方法签名排列 - 保持声明中括号的现有排列（C#）
`keep_existing_embedded_arrangement`	嵌套语句排列 - 保留嵌套语句的现有排列 (C#)
`keep_existing_embedded_block_arrangement`	嵌套块排列 - 保留嵌套块的现有排列 (C#)
`keep_existing_enum_arrangement`	枚举排列 - 保留枚举的现有排列 (C#)
`keep_existing_expr_member_arrangement`	表达式主体成员排列 - 保留现有表达式主体成员排列 (C#)
`keep_existing_initializer_arrangement`	初始化器排列 - 保留初始化器的现有排列 (C#)
`keep_existing_invocation_parens_arrangement`	调用排列 - 保持调用中括号的现有排列（C#）
`keep_existing_linebreaks`	通用 - 保留现有的换行（C#）
`keep_existing_list_patterns_arrangement`	列表模式排列 - 保留列表模式和集合表达式的现有排列 (C#)
`keep_existing_primary_constructor_declaration_parens_arrangement`	主构造函数签名排列 - 保持声明中括号的现有排列（C#）
`keep_existing_property_patterns_arrangement`	属性模式排列 - 保留属性模式的现有排列 (C#)
`keep_existing_switch_expression_arrangement`	switch 表达式排列 - 保留 switch 表达式的现有排列 (C#)
`keep_user_linebreaks`	通用 - 保持现有换行，适用于： C#、 VB.NET
`linebreak_before_elements`	标签周围 - 将以下元素放在新行，适用于：
`linebreak_before_multiline_elements`	标签周围 - 将多行元素放在新行上，可用于：
`linebreak_before_singleline_elements`	标签周围 - 将单行元素放在新行上，可用于：
`linebreaks_around_razor_statements`	Razor 语句周围的换行 (Razor CSharp)
`linebreaks_inside_tags_for_elements_longer_than`	标签内容 - 当元素长度超过时，在起始标签后和结束标签前换行，适用于：
`linebreaks_inside_tags_for_elements_with_child_elements`	标签周围 - 在包含其他元素且无文本的元素中，在起始标签后和结束标签前换行，可用于：
`linebreaks_inside_tags_for_multiline_elements`	标签周围 - 在多行元素中，在起始标签后和结束标签前换行，适用于：
`local_function_body`	代码体 - 本地函数（C#）
`max_array_initializer_elements_on_line`	初始化器排列 - 单行中的最大数组初始化器和集合表达式元素数（C#）
`max_attribute_length_for_same_line`	属性排列 - 如果属性部分列表过长，则将其放在单独的行上 (C#)
`max_blank_lines_between_tags`	标签周围 - 标签之间的最大空行数，适用于：
`max_enum_members_on_line`	枚举排列 - 单行中的最大枚举成员数（C#）
`max_formal_parameters_on_line`	方法签名排列 - 单行中的最大正式参数数 (C#)
`max_initializer_elements_on_line`	初始化器排列 - 单行中的最大对象和集合初始化器元素数（C#）
`max_invocation_arguments_on_line`	调用排列 - 单行中的最大调用参数数（C#）
`max_line_length`	通用 - 在以下位置硬换行： C#， VB.NET
`max_primary_constructor_parameters_on_line`	主构造函数签名排列 - 单行中的最大主构造函数参数数（C#）
`method_or_operator_body`	代码主体 - 方法和运算符（C#）
`modifiers_order`	修饰符 - 修饰符顺序（C#）
`namespace_body`	代码体 - 命名空间（C#）
`nested_ternary_style`	三元表达式排列 - 嵌套三元表达式样式（C#）
`new_line_before_catch`	语句的排列 - 将 'catch' 放在新行上，可用于： C#
`new_line_before_else`	语句的排列 - 将 'else' 放在新行上，可用于： C#
`new_line_before_finally`	语句的排列 - 将 'finally' 放在新行上，可用于： C#
`new_line_before_while`	语句的排列 - 将 'while' 放在新行上，可用于： C#
`null_checking_pattern_style`	模式 - 空检查模式样式（C#）
`object_creation_when_type_evident`	对象创建 - 当创建的类型从用法中显而易见时（C#）
`object_creation_when_type_not_evident`	对象创建 - 当创建的类型从用法中不显而易见时（C#）
`old_engine`	ReSharper 其他 - 恢复旧的格式化引擎（C#）
`other_braces`	大括号布局 - 其他，可用于： C#
`outdent_binary_ops`	对齐多行结构 - 减少二元操作符的缩进（C#）
`outdent_binary_pattern_ops`	对齐多行结构 - 减少二元模式的缩进（C#）
`outdent_commas`	对齐多行结构 - 减少逗号的缩进，可用于： C#
`outdent_dots`	对齐多行结构 - 减少链式方法调用中点的缩进，可用于： C#
`outdent_statement_labels`	其他缩进 - 减少语句标签的缩进（C#）
`parentheses_group_non_obvious_operations`	添加括号以避免不明显的优先级 - 当以下组的操作嵌套时（C#）
`parentheses_non_obvious_operations`	添加括号以避免不明显的优先级 - 在以下操作的操作数周围（C#）
`parentheses_redundancy_style`	括号 - 删除多余的括号（C#）
`parentheses_same_type_operations`	添加括号以避免不明显的优先级 - 即使是同类型操作的嵌套（C#）
`pi_attribute_style`	处理指令 - 属性格式，可用于：
`pi_attributes_indent`	处理指令 - 属性缩进，可用于：
`place_abstract_accessorholder_on_single_line`	声明块的排列 - 将抽象/自动属性/索引器/事件声明放在单行（C#）
`place_accessor_attribute_on_same_line`	属性的排列 - 将访问器属性放在同一行（C#）
`place_accessor_with_attrs_holder_on_single_line`	声明块的排列 - 即使访问器上有属性，也将其放在单行（C#）
`place_accessorholder_attribute_on_same_line`	属性的排列 - 将属性/索引器/事件属性放在同一行（C#）
`place_attribute_on_same_line`	将简单属性与所有者放在同一行（通用）
`place_comments_at_first_column`	其他缩进 - 注释代码时将注释放在第一列，可用于： C#
`place_constructor_initializer_on_same_line`	方法签名的排列 - 允许构造函数初始化器在同一行（C#）
`place_event_attribute_on_same_line`	属性 - 将事件属性放在同一行 (VB.NET)
`place_expr_accessor_on_single_line`	表达式主体成员的排列 - 将属性访问器表达式主体放在同一行（C#）
`place_expr_method_on_single_line`	表达式主体成员的排列 - 将方法表达式主体放在同一行（C#）
`place_expr_property_on_single_line`	表达式主体成员的排列 - 将属性表达式主体放在同一行（C#）
`place_field_attribute_on_same_line`	属性的排列 - 将字段属性放在同一行（C#）
`place_linq_into_on_new_line`	LINQ 表达式的排列 - 在 LINQ 表达式中将 'into' 放在新行（C#）
`place_method_attribute_on_same_line`	属性的排列 - 将方法属性放在同一行（C#）
`place_property_attribute_on_same_line`	属性 - 将属性属性放在同一行（VB.NET）
`place_record_field_attribute_on_same_line`	属性的排列 - 将记录字段属性放在同一行（C#）
`place_simple_accessor_on_single_line`	声明块的排列 - 将简单访问器放在单行（C#）
`place_simple_accessorholder_on_single_line`	声明块的排列 - 将简单属性/索引器/事件声明放在单行（C#）
`place_simple_anonymousmethod_on_single_line`	嵌套块的排列 - 将简单匿名方法放在单行（C#）
`place_simple_blocks_on_single_line`	将简单块放在单行（通用）
`place_simple_case_statement_on_same_line`	嵌套语句的排列 - 将简单 'case' 语句放在同一行（C#）
`place_simple_declaration_blocks_on_single_line`	将简单类型成员的块放在单行（通用）
`place_simple_embedded_block_on_same_line`	嵌套块的排列 - 将包含单个简单语句的块放在同一行（C#）
`place_simple_embedded_statement_on_same_line`	嵌套语句的排列 - 将简单嵌套语句放在同一行（C#）
`place_simple_enum_on_single_line`	枚举的排列 - 将简单枚举放在单行（C#）
`place_simple_initializer_on_single_line`	初始化器的排列 - 将简单数组、对象和集合放在单行（C#）
`place_simple_list_pattern_on_single_line`	列表模式的排列 - 将简单列表模式和集合表达式放在单行（C#）
`place_simple_method_on_single_line`	声明块的排列 - 将简单方法放在单行（C#）
`place_simple_property_pattern_on_single_line`	属性模式的排列 - 将简单属性模式放在单行（C#）
`place_simple_switch_expression_on_single_line`	切换表达式的排列 - 将简单切换表达式放在单行（C#）
`place_type_attribute_on_same_line`	属性排列 - 将类型属性放在同一行 (C#)
`place_type_constraints_on_same_line`	类型参数、约束和基类型的排列 - 允许类型约束在同一行，可用于： C#
`prefer_explicit_discard_declaration`	'var' 声明的使用 - 对于丢弃值使用 'var' 关键字 (C#)
`prefer_qualified_reference`	引用限定和 'using' 指令 - 优先使用完全限定的引用，可用于： C#、 Razor CSharp、 VB.NET
`prefer_separate_deconstructed_variables_declaration`	'var' 声明的使用 - 对解构变量优先使用单独的声明 (C#)
`protobuf_brace_style`	大括号布局样式（通用化）
`qualified_using_at_nested_scope`	引用限定和 'using' 指令 - 在嵌套作用域中优先使用完全限定的 'using' 名称 (C#)
`quote_style`	引号 - 引号样式，可用于：
`razor_always_use_end_of_line_brace_style`	为 C# 覆盖大括号样式以始终使用 '行尾 (K&R 样式)'（Razor CSharp）
`razor_prefer_qualified_reference`	为 @inherits 和 @model 指令使用完全限定的名称 (Razor CSharp)
`razor_remove_blank_lines_near_braces`	在 @functions (Razor CSharp) 中删除 '{' 后和 '}' 前的空行
`razor_remove_this_qualifier`	始终删除 'this.' 限定符 (覆盖相应的 C# 设置) (Razor CSharp)
`remove_blank_lines_near_braces`	在 @functions (Razor CSharp) 中删除 '{' 后和 '}' 前的空行
`remove_blank_lines_near_braces_in_code`	代码中的空行 - 删除代码中 '{' 后和 '}' 前的空行，可用于： C#
`remove_blank_lines_near_braces_in_declarations`	声明中的空行 - 删除声明中 '{' 后和 '}' 前的空行，可用于： C#
`remove_this_qualifier`	始终删除 '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' 表达式的首选样式
`resharper_arrange_object_creation_when_type_not_evident_highlighting`	代码检查：当创建的类型不显而易见时，使用 'new' 表达式的首选样式
`resharper_arrange_redundant_parentheses_highlighting`	代码检查：移除多余的括号
`resharper_arrange_static_member_qualifier_highlighting`	代码检查：为静态成员添加/移除限定符
`resharper_arrange_this_qualifier_highlighting`	代码检查：添加/移除 'this.' 限定符
`resharper_arrange_trailing_comma_in_multiline_lists_highlighting`	代码检查：在多行列表中，在新行前使用尾随逗号的首选样式
`resharper_arrange_trailing_comma_in_singleline_lists_highlighting`	代码检查：当最后一个元素后没有新行时，使用尾随逗号的首选样式
`resharper_arrange_type_member_modifiers_highlighting`	代码检查：为类型成员使用显式或隐式修饰符定义
`resharper_arrange_type_modifiers_highlighting`	代码检查：为类型使用显式或隐式修饰符定义
`resharper_arrange_var_keywords_in_deconstructing_declaration_highlighting`	代码检查：在解构声明中合并或分离 'var'
`resharper_asp_content_placeholder_not_resolved_highlighting`	代码检查：未知内容占位符
`resharper_asp_custom_page_parser_filter_type_highlighting`	代码检查：不支持的 pageParserFilterType
`resharper_asp_dead_code_highlighting`	代码检查： ASP.NET 无效代码
`resharper_asp_image_highlighting`	代码检查：错误的图像大小
`resharper_asp_invalid_control_type_highlighting`	代码检查：无效的控件类型
`resharper_asp_not_resolved_highlighting`	代码检查：未知符号
`resharper_asp_ods_method_reference_resolve_error_highlighting`	代码检查：对象数据源方法解析问题
`resharper_asp_resolve_warning_highlighting`	代码检查： ASP.NET 解析警告
`resharper_asp_skin_not_resolved_highlighting`	代码检查：未知皮肤
`resharper_asp_tag_attribute_with_optional_value_highlighting`	代码检查：具有可选值的问题的属性
`resharper_asp_theme_not_resolved_highlighting`	代码检查：未知主题
`resharper_asp_unused_register_directive_highlighting_highlighting`	代码检查：未使用的注册指令
`resharper_asp_warning_highlighting`	代码检查： ASP.NET 警告
`resharper_assign_null_to_not_null_attribute_highlighting`	代码检查：可能将 'null' 分配给非空实体
`resharper_assign_to_constant_highlighting`	代码检查：对常量的赋值
`resharper_assign_to_implicit_global_in_function_scope_highlighting`	代码检查：对隐式声明的全局变量的赋值
`resharper_assigned_value_is_never_used_highlighting`	代码检查：赋值的值从未使用
`resharper_assigned_value_wont_be_assigned_to_corresponding_field_highlighting`	代码检查：在构造函数中分配的参数属性值不会分配给类属性
`resharper_assignment_in_condition_expression_highlighting`	代码检查：在条件语句中对变量的赋值
`resharper_assignment_in_conditional_expression_highlighting`	代码检查：条件表达式中的赋值
`resharper_assignment_instead_of_discard_highlighting`	代码检查：可疑地使用了具有丢弃样式名称的变量
`resharper_assignment_is_fully_discarded_highlighting`	代码检查：赋值结果被完全丢弃
`resharper_asxx_path_error_highlighting`	代码检查：路径错误
`resharper_async_iterator_invocation_without_await_foreach_highlighting`	代码检查：异步迭代器调用未使用 'await foreach'
`resharper_async_void_lambda_highlighting`	代码检查：避免在委托类型返回 'void' 时使用 'async' lambda
`resharper_async_void_method_highlighting`	代码检查：避免使用返回类型为 'void' 的 'async' 方法
`resharper_attribute_indent`	标签头部内部 - 属性缩进，可用于：
`resharper_attribute_style`	标签头部内部 - 属性格式，可用于：
`resharper_auto_property_can_be_made_get_only_global_highlighting`	代码检查：自动属性可以设置为仅 get（非私有访问性）
`resharper_auto_property_can_be_made_get_only_local_highlighting`	代码检查：自动属性可以设置为仅 get（私有访问性）
`resharper_bad_attribute_brackets_spaces_highlighting`	代码检查：属性周围的间距不正确
`resharper_bad_braces_spaces_highlighting`	代码检查：大括号周围的间距不正确
`resharper_bad_child_statement_indent_highlighting`	代码检查：子语句周围的缩进不正确
`resharper_bad_colon_spaces_highlighting`	代码检查：冒号周围的间距不正确
`resharper_bad_comma_spaces_highlighting`	代码检查：逗号周围的间距不正确
`resharper_bad_control_braces_indent_highlighting`	代码检查：语句大括号周围的缩进不正确
`resharper_bad_control_braces_line_breaks_highlighting`	代码检查：语句大括号周围的换行不正确
`resharper_bad_declaration_braces_indent_highlighting`	代码检查：声明大括号周围的缩进不正确
`resharper_bad_declaration_braces_line_breaks_highlighting`	代码检查：声明大括号周围的换行不正确
`resharper_bad_empty_braces_line_breaks_highlighting`	代码检查：空大括号周围的换行不正确
`resharper_bad_expression_braces_indent_highlighting`	代码检查：表达式大括号周围的缩进不正确
`resharper_bad_expression_braces_line_breaks_highlighting`	代码检查：表达式大括号周围的换行不正确
`resharper_bad_generic_brackets_spaces_highlighting`	代码检查：泛型括号周围的间距不正确
`resharper_bad_indent_highlighting`	代码检查：多余的缩进/缩出导致的缩进不正确
`resharper_bad_linq_line_breaks_highlighting`	代码检查： LINQ 查询周围的换行不正确
`resharper_bad_list_line_breaks_highlighting`	代码检查：列表中逗号周围的换行不正确
`resharper_bad_member_access_spaces_highlighting`	代码检查：成员访问符号周围的间距不正确
`resharper_bad_namespace_braces_indent_highlighting`	代码检查：命名空间大括号周围的缩进不正确
`resharper_bad_parens_line_breaks_highlighting`	代码检查：括号周围的换行不正确
`resharper_bad_parens_spaces_highlighting`	代码检查：括号周围的间距不正确
`resharper_bad_preprocessor_indent_highlighting`	代码检查：预处理指令周围的缩进不正确
`resharper_bad_semicolon_spaces_highlighting`	代码检查：分号周围的间距不正确
`resharper_bad_spaces_after_keyword_highlighting`	代码检查：关键字与括号之间的间距不正确
`resharper_bad_square_brackets_spaces_highlighting`	代码检查：语句中方括号周围的间距不正确
`resharper_bad_switch_braces_indent_highlighting`	代码检查： switch 语句周围的缩进不正确
`resharper_bad_symbol_spaces_highlighting`	代码检查：运算符号周围的间距不正确
`resharper_base_member_has_params_highlighting`	代码检查：基类成员具有 'params' 参数，但重写者没有
`resharper_base_method_call_with_default_parameter_highlighting`	代码检查：调用基类成员时使用了隐式默认参数
`resharper_base_object_equals_is_object_equals_highlighting`	代码检查：调用 'base.Equals(...)' 是引用相等
`resharper_base_object_get_hash_code_call_in_get_hash_code_highlighting`	代码检查：重写的 GetHashCode 调用了基类 'Object.GetHashCode()'
`resharper_bitwise_operator_on_enum_without_flags_highlighting`	代码检查：对枚举的按位操作未标记 [Flags] 属性
`resharper_blank_line_after_pi`	处理指令 - 处理指令后留空行，可用于：
`resharper_blank_lines_after_block_statements`	代码中的空行 - 在带有子块的语句之后（C#）
`resharper_blank_lines_after_case`	代码中的空行 - 在 switch 语句中的 'case' 之后（C#）
`resharper_blank_lines_after_control_transfer_statements`	代码中的空行 - 在带有控制转移的语句之后（C#）
`resharper_blank_lines_after_file_scoped_namespace_directive`	声明中的空行 - 在文件范围的命名空间指令之后（C#）
`resharper_blank_lines_after_imports`	空行 - 在 Imports 部分之后 (VB.NET)
`resharper_blank_lines_after_multiline_statements`	代码中的空行 - 在多行语句之后 (C#)
`resharper_blank_lines_after_options`	空行 - 在文件选项部分之后（VB.NET）
`resharper_blank_lines_after_start_comment`	声明中的空行 - 文件头注释后（C#）
`resharper_blank_lines_after_using_list`	声明中的空行 - 'using' 列表后（C#）
`resharper_blank_lines_around_accessor`	声明中的空行 - 属性/事件访问器周围（C#）
`resharper_blank_lines_around_auto_property`	声明中的空行 - 自动/抽象属性/事件周围（C#）
`resharper_blank_lines_around_block_case_section`	代码中的空行 - 在 switch 语句中带有块的 'case' 部分周围（C#）
`resharper_blank_lines_around_field`	声明中的空行 - 字段周围，可用于： C#、 VB.NET
`resharper_blank_lines_around_global_attribute`	空行 - 在全局属性之后（VB.NET）
`resharper_blank_lines_around_invocable`	声明中的空行 - 方法周围，可用于： C#、 VB.NET
`resharper_blank_lines_around_local_method`	代码中的空行 - 在局部函数周围（C#）
`resharper_blank_lines_around_multiline_case_section`	代码中的空行 - 多行 'case' 部分在 switch 语句中（C#）
`resharper_blank_lines_around_namespace`	声明中的空行 - 命名空间周围，可用于： C#、 VB.NET
`resharper_blank_lines_around_property`	声明中的空行 - 在属性/事件周围（C#）
`resharper_blank_lines_around_razor_functions`	Razor @functions 块周围的空行（Razor CSharp）
`resharper_blank_lines_around_razor_helpers`	Razor 助手周围的空行（Razor CSharp）
`resharper_blank_lines_around_razor_sections`	Razor 区段周围的空行 (Razor CSharp)
`resharper_blank_lines_around_region`	常规 - 区域周围，可用于： C#、 VB.NET
`resharper_blank_lines_around_single_line_accessor`	声明中的空行 - 在单行属性/事件访问器周围（C#）
`resharper_blank_lines_around_single_line_auto_property`	声明中的空行 - 在单行自动/抽象属性/事件周围（C#）
`resharper_blank_lines_around_single_line_field`	声明中的空行 - 单行字段周围，可用于： C#、 VB.NET
`resharper_blank_lines_around_single_line_invocable`	声明中的空行 - 单行方法周围，可用于： C#、 VB.NET
`resharper_blank_lines_around_single_line_local_method`	代码中的空行 - 单行局部函数周围（C#）
`resharper_blank_lines_around_single_line_property`	声明中的空行 - 单行属性/事件周围（C#）
`resharper_blank_lines_around_single_line_type`	声明中的空行 - 单行类型周围（C#）
`resharper_blank_lines_around_type`	声明中的空行 - 类型周围，可用于： C#、 VB.NET
`resharper_blank_lines_before_block_statements`	代码中的空行 - 带子块的语句之前（C#）
`resharper_blank_lines_before_case`	代码中的空行 - switch 语句中的 'case' 之前（C#）
`resharper_blank_lines_before_control_transfer_statements`	代码中的空行 - 带控制转移的语句之前（C#）
`resharper_blank_lines_before_multiline_statements`	代码中的空行 - 多行语句之前（C#）
`resharper_blank_lines_before_single_line_comment`	通用 - 单行注释之前（C#）
`resharper_blank_lines_between_using_groups`	声明中的空行 - 不同 'using' 组之间（C#）
`resharper_blank_lines_inside_namespace`	声明中的空行 - 命名空间内（C#）
`resharper_blank_lines_inside_region`	常规 - 区域内，可用于： C#、 VB.NET
`resharper_blank_lines_inside_type`	声明中的空行 - 类型内（C#）
`resharper_blazor_editor_required_highlighting`	代码检查：缺少必需属性的值
`resharper_block_scope_redeclaration_highlighting`	代码检查：重复声明 let/const
`resharper_brace_style`	大括号布局样式（通用）
`resharper_braces_for_dowhile`	大括号 - 在 'do-while' 语句中（C#）
`resharper_braces_for_fixed`	大括号 - 在 'fixed' 语句中（C#）
`resharper_braces_for_for`	大括号 - 在 'for' 语句中（C#）
`resharper_braces_for_foreach`	大括号 - 在 'foreach' 语句中（C#）
`resharper_braces_for_ifelse`	大括号 - 在 'if' 语句中（C#）
`resharper_braces_for_lock`	大括号 - 在 'lock' 语句中（C#）
`resharper_braces_for_using`	大括号 - 在 'using' 语句中（C#）
`resharper_braces_for_while`	大括号 - 在 'while' 语句中（C#）
`resharper_braces_redundant`	大括号 - 删除冗余的大括号（C#）
`resharper_built_in_type_reference_style_for_member_access_highlighting`	代码检查：将内置类型引用替换为 CLR 类型名称或静态成员访问表达式中的关键字
`resharper_built_in_type_reference_style_highlighting`	代码检查：将内置类型引用替换为 CLR 类型名称或关键字
`resharper_builtin_type_apply_to_native_integer`	内置类型 - 也适用于本机大小的整数类型（C#）
`resharper_builtin_type_reference_for_member_access_style`	内置类型 - 在成员访问表达式中，优先使用（C#）
`resharper_builtin_type_reference_style`	内置类型 - 在局部变量、成员和参数中，优先使用（C#）
`resharper_by_ref_argument_is_volatile_field_highlighting`	代码检查：对 'volatile' 字段的捕获引用不会被视为 'volatile'
`resharper_c_sharp_build_cs_invalid_module_name_highlighting`	代码检查：不存在此名称的模块
`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`	代码中的空行 - 多行 'case' 部分在 switch 语句中（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#)
`resharper_csharp_place_expr_accessor_on_single_line`	表达式主体成员的排列 - 将属性访问器表达式主体放在同一行（C#）
`resharper_csharp_place_expr_method_on_single_line`	表达式主体成员的排列 - 将方法表达式主体放在同一行（C#）
`resharper_csharp_place_expr_property_on_single_line`	表达式主体成员的排列 - 将属性表达式主体放在同一行（C#）
`resharper_csharp_place_field_attribute_on_same_line`	属性的排列 - 将字段属性放在同一行（C#）
`resharper_csharp_place_linq_into_on_new_line`	LINQ 表达式的排列 - 在 LINQ 表达式中将 'into' 放在新行（C#）
`resharper_csharp_place_method_attribute_on_same_line`	属性的排列 - 将方法属性放在同一行（C#）
`resharper_csharp_place_record_field_attribute_on_same_line`	属性的排列 - 将记录字段属性放在同一行（C#）
`resharper_csharp_place_simple_accessor_on_single_line`	声明块的排列 - 将简单访问器放在单行（C#）
`resharper_csharp_place_simple_accessorholder_on_single_line`	声明块的排列 - 将简单属性/索引器/事件声明放在单行（C#）
`resharper_csharp_place_simple_anonymousmethod_on_single_line`	嵌套块的排列 - 将简单匿名方法放在单行（C#）
`resharper_csharp_place_simple_blocks_on_single_line`	将简单块放在单行（通用）
`resharper_csharp_place_simple_case_statement_on_same_line`	嵌套语句的排列 - 将简单 'case' 语句放在同一行（C#）
`resharper_csharp_place_simple_declaration_blocks_on_single_line`	将简单类型成员的块放在单行（通用）
`resharper_csharp_place_simple_embedded_block_on_same_line`	嵌套块的排列 - 将只有一个简单语句的块放在同一行 (C#)
`resharper_csharp_place_simple_embedded_statement_on_same_line`	嵌套语句的排列 - 将简单嵌套语句放在同一行（C#）
`resharper_csharp_place_simple_enum_on_single_line`	枚举的排列 - 将简单枚举放在单行（C#）
`resharper_csharp_place_simple_initializer_on_single_line`	初始化器的排列 - 将简单数组、对象和集合放在单行（C#）
`resharper_csharp_place_simple_list_pattern_on_single_line`	列表模式的排列 - 将简单列表模式和集合表达式放在单行（C#）
`resharper_csharp_place_simple_method_on_single_line`	声明块的排列 - 将简单方法放在单行（C#）
`resharper_csharp_place_simple_property_pattern_on_single_line`	属性模式的排列 - 将简单属性模式放在单行（C#）
`resharper_csharp_place_simple_switch_expression_on_single_line`	切换表达式的排列 - 将简单切换表达式放在单行（C#）
`resharper_csharp_place_type_attribute_on_same_line`	属性排列 - 将类型属性放在同一行 (C#)
`resharper_csharp_place_type_constraints_on_same_line`	类型参数、约束和基类型的排列 - 允许类型约束放在同一行 (C#)
`resharper_csharp_prefer_explicit_discard_declaration`	'var' 声明的使用 - 对于丢弃值使用 'var' 关键字 (C#)
`resharper_csharp_prefer_qualified_reference`	引用限定和 'using' 指令 - 优先使用完全限定的引用 (C#)
`resharper_csharp_prefer_separate_deconstructed_variables_declaration`	'var' 在声明中的使用 - 对解构变量优先使用单独声明 (C#)
`resharper_csharp_qualified_using_at_nested_scope`	引用限定和 'using' 指令 - 在嵌套作用域中优先使用完全限定的 'using' 名称 (C#)
`resharper_csharp_remove_blank_lines_near_braces_in_code`	代码中的空行 - 移除代码中 '{' 后和 '}' 前的空行 (C#)
`resharper_csharp_remove_blank_lines_near_braces_in_declarations`	声明中的空行 - 移除声明中 '{' 后和 '}' 前的空行 (C#)
`resharper_csharp_sort_usings_with_system_first`	引用限定和 'using' 指令 - 排序 'using' 指令时优先放置 'System.' 和 'Windows.' 命名空间 (C#)
`resharper_csharp_space_after_ampersand_op`	一元运算符后 - 不安全的取地址运算符 (&)（C#）
`resharper_csharp_space_after_asterik_op`	一元运算符后 - 不安全的星号运算符 (*)（C#）
`resharper_csharp_space_after_attribute_colon`	围绕冒号 - 在其他冒号之后 (C#)
`resharper_csharp_space_after_attributes`	属性 - 属性后（C#）
`resharper_csharp_space_after_colon`	围绕冒号 - 在其他冒号之后 (C#)
`resharper_csharp_space_after_colon_in_case`	围绕冒号 - 在 'case' 语句中的冒号之后 (C#)
`resharper_csharp_space_after_logical_not_op`	一元运算符后 - 逻辑非运算符 (!)（C#）
`resharper_csharp_space_after_operator_keyword`	其他 - 运算符关键字后 (C#)
`resharper_csharp_space_after_ternary_colon`	在三元运算符中 - 在 ':' 之后 (C#)
`resharper_csharp_space_after_ternary_quest`	在三元运算符中 - 在 '?' 之后 (C#)
`resharper_csharp_space_after_type_parameter_constraint_colon`	围绕冒号 - 在类型参数约束冒号之后 (C#)
`resharper_csharp_space_after_unary_minus_op`	一元运算符后 - 一元减号运算符 (-)（C#）
`resharper_csharp_space_after_unary_operator`	一元运算符后空格 (!, -, ~,...)（通用）
`resharper_csharp_space_after_unary_plus_op`	一元运算符后 - 一元加号运算符 (+)（C#）
`resharper_csharp_space_around_additive_op`	围绕二元运算符 - 加法运算符 (+,-) (C#)
`resharper_csharp_space_around_alias_eq`	其他 - 命名空间别名指令中的 '=' 周围 (C#)
`resharper_csharp_space_around_arrow_op`	二元运算符周围 - 不安全箭头运算符（->）（C#）
`resharper_csharp_space_around_assignment_op`	围绕二元运算符 - 赋值运算符 (如 '=' 和 '+=') (C#)
`resharper_csharp_space_around_binary_operator`	在二元运算符周围的空格（+，\|\|，=，...）（通用）
`resharper_csharp_space_around_bitwise_op`	围绕二元运算符 - 按位运算符 (&,\|,^) (C#)
`resharper_csharp_space_around_dot`	其他 - 在点号周围 (C#)
`resharper_csharp_space_around_equality_op`	围绕二元运算符 - 相等运算符 (==,!=) (C#)
`resharper_csharp_space_around_lambda_arrow`	其他 - 在 lambda 箭头周围（C#）
`resharper_csharp_space_around_logical_op`	围绕二元运算符 - 逻辑运算符 (&&,\|\|) (C#)
`resharper_csharp_space_around_member_access_operator`	在成员访问运算符周围的空格（.，->，...）（通用）
`resharper_csharp_space_around_multiplicative_op`	围绕二元运算符 - 乘法运算符 (*,/,%) (C#)
`resharper_csharp_space_around_nullcoalescing_op`	围绕二元运算符 - 空合并运算符 (??) (C#)
`resharper_csharp_space_around_relational_op`	围绕二元运算符 - 关系运算符 (<,>,<=,>=) (C#)
`resharper_csharp_space_around_shift_op`	围绕二元运算符 - 移位运算符 (<<,>>,>>>) (C#)
`resharper_csharp_space_around_ternary_operator`	三元运算符周围的空格（?、:）（通用）
`resharper_csharp_space_before_array_access_brackets`	围绕数组括号 - 在数组访问括号之前 (C#)
`resharper_csharp_space_before_array_rank_brackets`	围绕数组括号 - 在数组维度括号之前 (C#)
`resharper_csharp_space_before_attribute_colon`	冒号周围 - 其他冒号前（C#）
`resharper_csharp_space_before_catch_parentheses`	语句中的括号前 - 'catch' 括号（C#）
`resharper_csharp_space_before_checked_parentheses`	其他括号前 - 'checked' 和 'unchecked' 括号（C#）
`resharper_csharp_space_before_colon`	围绕冒号 - 在其他冒号之前 (C#)
`resharper_csharp_space_before_colon_in_case`	围绕冒号 - 在 'case' 语句中的冒号之前 (C#)
`resharper_csharp_space_before_default_parentheses`	在其他括号之前 - 'default' 括号（C#）
`resharper_csharp_space_before_empty_method_call_parentheses`	在其他括号之前 - 方法调用空括号 (C#)
`resharper_csharp_space_before_empty_method_parentheses`	在其他括号之前 - 方法声明空括号 (C#)
`resharper_csharp_space_before_fixed_parentheses`	在语句中的括号之前 - 'fixed' 括号（C#）
`resharper_csharp_space_before_for_parentheses`	在语句中的括号之前 - 'for' 括号 (C#)
`resharper_csharp_space_before_foreach_parentheses`	在语句中的括号之前 - 'foreach' 括号（C#）
`resharper_csharp_space_before_if_parentheses`	在语句中的括号之前 - 'if' 括号（C#）
`resharper_csharp_space_before_lock_parentheses`	在语句中的括号之前 - 'lock' 括号 (C#)
`resharper_csharp_space_before_method_call_parentheses`	在其他括号之前 - 方法调用括号 (C#)
`resharper_csharp_space_before_method_parentheses`	在其他括号之前 - 方法声明括号 (C#)
`resharper_csharp_space_before_nameof_parentheses`	在其他括号之前 - 'nameof' 括号 (C#)
`resharper_csharp_space_before_new_parentheses`	在其他括号之前 - 'new' 括号 (C#)
`resharper_csharp_space_before_nullable_mark`	其他 - 在可空标记之前（C#）
`resharper_csharp_space_before_pointer_asterik_declaration`	其他 - 在不安全指针声明之前（C#）
`resharper_csharp_space_before_semicolon`	围绕逗号和分号 - 在分号之前 (C#)
`resharper_csharp_space_before_singleline_accessorholder`	围绕大括号 - 在单行访问器块之前 (C#)
`resharper_csharp_space_before_sizeof_parentheses`	在其他括号之前 - 'sizeof' 括号 (C#)
`resharper_csharp_space_before_switch_parentheses`	语句中括号之前 - 'switch' 括号（C#）
`resharper_csharp_space_before_ternary_colon`	三元运算符中 - ':' 之前（C#）
`resharper_csharp_space_before_ternary_quest`	三元运算符中 - '?' 之前（C#）
`resharper_csharp_space_before_trailing_comment`	其他 - 行尾注释之前（C#）
`resharper_csharp_space_before_type_argument_angle`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`resharper_csharp_space_before_type_parameter_angle`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`resharper_csharp_space_before_type_parameter_constraint_colon`	冒号周围 - 类型参数约束冒号之前（C#）
`resharper_csharp_space_before_typeof_parentheses`	其他括号之前 - 'typeof' 括号（C#）
`resharper_csharp_space_before_using_parentheses`	语句中括号之前 - 'using' 括号（C#）
`resharper_csharp_space_before_while_parentheses`	语句中括号之前 - 'while' 括号（C#）
`resharper_csharp_space_between_accessors_in_singleline_property`	大括号周围 - 在单行属性/事件访问器之间 (C#)
`resharper_csharp_space_between_attribute_sections`	属性 - 在属性部分之间 (C#)
`resharper_csharp_space_between_keyword_and_expression`	其他括号之前 - 关键字和表达式之间（C#）
`resharper_csharp_space_between_keyword_and_type`	其他括号之前 - 关键字和类型之间（C#）
`resharper_csharp_space_between_parentheses_of_control_flow_statements`	控制流语句括号内的空格 (通用)
`resharper_csharp_space_between_typecast_parentheses`	其他括号内 - 类型转换括号（C#）
`resharper_csharp_space_in_singleline_accessorholder`	大括号周围 - 在单行访问器内 (C#)
`resharper_csharp_space_in_singleline_anonymous_method`	大括号周围 - 在单行匿名方法内 (C#)
`resharper_csharp_space_in_singleline_method`	大括号周围 - 在单行方法内 (C#)
`resharper_csharp_space_near_postfix_and_prefix_op`	一元运算符之后 - ++ 和 -- 之前/之后（C#）
`resharper_csharp_space_within_array_access_brackets`	数组括号周围 - 数组访问括号内（C#）
`resharper_csharp_space_within_array_rank_brackets`	数组括号周围 - 在数组维度括号内 (C#)
`resharper_csharp_space_within_array_rank_empty_brackets`	数组括号周围 - 在数组维度空括号内 (C#)
`resharper_csharp_space_within_attribute_brackets`	属性 - 属性括号内（C#）
`resharper_csharp_space_within_catch_parentheses`	语句中括号内 - 'catch' 括号（C#）
`resharper_csharp_space_within_checked_parentheses`	其他括号内 - 'checked' 和 'unchecked' 括号 (C#)
`resharper_csharp_space_within_default_parentheses`	其他括号内 - 'default' 括号（C#）
`resharper_csharp_space_within_empty_braces`	大括号周围 - 空大括号之间的空格（C#）
`resharper_csharp_space_within_fixed_parentheses`	语句中括号内 - 'fixed' 括号（C#）
`resharper_csharp_space_within_for_parentheses`	语句中括号内 - 'for' 括号（C#）
`resharper_csharp_space_within_foreach_parentheses`	语句中括号内 - 'foreach' 括号（C#）
`resharper_csharp_space_within_if_parentheses`	语句中的括号 - 'if' 括号 (C#)
`resharper_csharp_space_within_list_pattern_brackets`	数组括号周围 - 列表模式和集合表达式括号内（C#）
`resharper_csharp_space_within_lock_parentheses`	语句中的括号 - 'lock' 括号 (C#)
`resharper_csharp_space_within_nameof_parentheses`	其他括号内 - 'nameof' 括号（C#）
`resharper_csharp_space_within_new_parentheses`	其他括号内 - 'new' 括号（C#）
`resharper_csharp_space_within_parentheses`	其他括号内 - 括号（C#）
`resharper_csharp_space_within_single_line_array_initializer_braces`	大括号周围 - 单行表达式大括号内（C#）
`resharper_csharp_space_within_sizeof_parentheses`	其他括号内 - 'sizeof' 括号（C#）
`resharper_csharp_space_within_slice_pattern`	其他 - 切片模式中 '..' 之后（C#）
`resharper_csharp_space_within_switch_parentheses`	语句中括号内 - 'switch' 括号（C#）
`resharper_csharp_space_within_type_argument_angles`	尖括号周围 - 类型参数尖括号（C#）
`resharper_csharp_space_within_type_parameter_angles`	尖括号周围 - 类型形参尖括号（C#）
`resharper_csharp_space_within_typeof_parentheses`	其他括号内 - 'typeof' 括号 (C#)
`resharper_csharp_space_within_using_parentheses`	语句中括号内 - 'using' 括号（C#）
`resharper_csharp_space_within_while_parentheses`	语句中括号内 - 'while' 括号（C#）
`resharper_csharp_special_else_if_treatment`	通用 - 特殊的 'else if' 处理（C#）
`resharper_csharp_static_members_qualify_members`	静态成员限定 - 需要限定的成员（C#）
`resharper_csharp_static_members_qualify_with`	静态成员限定 - 使用名称限定（C#）
`resharper_csharp_stick_comment`	其他缩进 - 不缩进从第一列开始的注释（C#）
`resharper_csharp_tab_width`	常规 - 制表符宽度 (C#)
`resharper_csharp_trailing_comma_in_multiline_lists`	尾随逗号 - 多行列表中新行前 (C#)
`resharper_csharp_trailing_comma_in_singleline_lists`	尾随逗号 - 当最后一个元素后没有换行时（C#）
`resharper_csharp_type_declaration_braces`	大括号布局 - 类型和命名空间声明 (C#)
`resharper_csharp_use_continuous_indent_inside_initializer_braces`	大括号布局 - 在表达式大括号内使用连续行缩进（C#）
`resharper_csharp_use_continuous_indent_inside_parens`	括号 - 在括号内使用连续行缩进 (C#)
`resharper_csharp_use_heuristics_for_body_style`	代码主体 - 应用样式启发式规则（C#）
`resharper_csharp_use_indent_from_previous_element`	其他缩进 - 在部分格式中使用前一个元素的缩进 (C#)
`resharper_csharp_use_roslyn_logic_for_evident_types`	声明中 'var' 的使用 - 偏好 Roslyn (Visual Studio) 的类型推断逻辑 (C#)
`resharper_csharp_wrap_after_declaration_lpar`	方法签名的排列 - 偏好在声明中 '(' 后换行 (C#)
`resharper_csharp_wrap_after_dot_in_method_calls`	成员访问表达式排列 - 优先在 '.' 后换行 (C#)
`resharper_csharp_wrap_after_invocation_lpar`	调用的排列 - 偏好在调用中 '(' 后换行 (C#)
`resharper_csharp_wrap_after_primary_constructor_declaration_lpar`	主构造函数签名排列 - 优先在声明中的 '(' 后换行 (C#)
`resharper_csharp_wrap_after_property_in_chained_method_calls`	成员访问表达式排列 - 优先在链式方法调用中的属性和字段后换行 (C#)
`resharper_csharp_wrap_arguments_style`	调用的排列 - 换行调用参数 (C#)
`resharper_csharp_wrap_array_initializer_style`	初始化器排列 - 换行数组初始化器 (C#)
`resharper_csharp_wrap_before_arrow_with_expressions`	表达式主体成员排列 - 优先在 '=>' 前换行并跟随表达式 (C#)
`resharper_csharp_wrap_before_binary_opsign`	二元表达式的排列 - 偏好在二元表达式中的运算符前换行 (C#)
`resharper_csharp_wrap_before_binary_pattern_op`	二元表达式排列 - 优先在二元模式中的运算符前换行 (C#)
`resharper_csharp_wrap_before_comma`	常规 - 更倾向于在 ',' 前换行 (C#)
`resharper_csharp_wrap_before_declaration_lpar`	方法签名的排列 - 偏好在声明中 '(' 前换行 (C#)
`resharper_csharp_wrap_before_declaration_rpar`	方法签名的排列 - 偏好在声明中 ')' 前换行 (C#)
`resharper_csharp_wrap_before_eq`	通用 - 优先在 '=' 前换行（C#）
`resharper_csharp_wrap_before_extends_colon`	类型参数、约束和基类型排列 - 优先在 ':' 前换行 (C#)
`resharper_csharp_wrap_before_first_method_call`	成员访问表达式排列 - 优先在第一个方法调用前换行 (C#)
`resharper_csharp_wrap_before_first_type_parameter_constraint`	类型参数、约束和基类型的排列 - 偏好在第一个约束前换行 (C#)
`resharper_csharp_wrap_before_invocation_lpar`	调用的排列 - 偏好在调用中 '(' 前换行 (C#)
`resharper_csharp_wrap_before_invocation_rpar`	调用的排列 - 偏好在调用中 ')' 前换行 (C#)
`resharper_csharp_wrap_before_linq_expression`	LINQ 表达式排列 - 优先在多行 LINQ 表达式前换行 (C#)
`resharper_csharp_wrap_before_primary_constructor_declaration_lpar`	主构造函数签名排列 - 优先在声明中的 '(' 前换行 (C#)
`resharper_csharp_wrap_before_primary_constructor_declaration_rpar`	主构造函数签名排列 - 优先在声明中的 ')' 前换行 (C#)
`resharper_csharp_wrap_before_ternary_opsigns`	三元表达式的排列 - 偏好在三元表达式中的 '?' 和 ':' 前换行 (C#)
`resharper_csharp_wrap_before_type_parameter_langle`	类型参数、约束和基类型排列 - 优先在类型参数列表中的开尖括号前换行 (C#)
`resharper_csharp_wrap_chained_binary_expressions`	二元表达式的排列 - 换行链式二元表达式 (C#)
`resharper_csharp_wrap_chained_binary_patterns`	二元表达式排列 - 换行复杂的二元模式 (C#)
`resharper_csharp_wrap_chained_method_calls`	成员访问表达式的排列 - 换行链式方法调用 (C#)
`resharper_csharp_wrap_enum_declaration`	枚举排列 - 换行枚举声明 (C#)
`resharper_csharp_wrap_extends_list_style`	类型参数、约束和基类型的排列 - 换行扩展/实现列表 (C#)
`resharper_csharp_wrap_for_stmt_header_style`	语句的排列 - 换行 'for' 语句头部 (C#)
`resharper_csharp_wrap_linq_expressions`	LINQ 表达式排列 - 换行 LINQ 表达式 (C#)
`resharper_csharp_wrap_list_pattern`	列表模式排列 - 换行列表模式和集合表达式 (C#)
`resharper_csharp_wrap_multiple_declaration_style`	语句的排列 - 换行多重声明 (C#)
`resharper_csharp_wrap_multiple_type_parameter_constraints_style`	类型参数、约束和基类型的排列 - 换行多重类型参数约束 (C#)
`resharper_csharp_wrap_object_and_collection_initializer_style`	初始化器排列 - 换行对象和集合初始化器 (C#)
`resharper_csharp_wrap_parameters_style`	方法签名的排列 - 换行形式参数 (C#)
`resharper_csharp_wrap_primary_constructor_parameters_style`	主构造函数签名排列 - 换行主构造函数参数 (C#)
`resharper_csharp_wrap_property_pattern`	属性模式排列 - 换行属性模式 (C#)
`resharper_csharp_wrap_switch_expression`	切换表达式排列 - 换行切换表达式 (C#)
`resharper_csharp_wrap_ternary_expr_style`	三元表达式的排列 - 换行三元表达式 (C#)
`resharper_csharp_wrap_verbatim_interpolated_strings`	插值字符串的排列 - 换行插值字符串 (C#)
`resharper_cyclic_reference_comment_highlighting`	代码检查：引用注释创建了循环依赖
`resharper_declaration_hides_highlighting`	代码检查：声明隐藏了外部作用域中的另一个声明
`resharper_declaration_visibility_error_highlighting`	代码检查：导出的实体使用了私有实体
`resharper_default_internal_modifier`	修饰符 - 更倾向于为类型使用显式/隐式 internal 修饰符（C#）
`resharper_default_private_modifier`	修饰符 - 更倾向于为类型成员使用显式/隐式 private 修饰符（C#）
`resharper_default_value_attribute_for_optional_parameter_highlighting`	代码检查：可能误导的 'DefaultValueAttribute' 用法用于定义可选参数值
`resharper_default_value_when_type_evident`	默认值 - 当类型从用法中显而易见时（C#）
`resharper_default_value_when_type_not_evident`	默认值 - 当类型从用法中不显而易见时 (C#)
`resharper_deleting_non_qualified_reference_highlighting`	代码检查：在 'strict mode' 中对非限定标识符调用 'delete'
`resharper_dispose_on_using_variable_highlighting`	代码检查：已被 'using' 语句捕获的变量的处置
`resharper_double_negation_in_pattern_highlighting`	代码检查：简化否定模式
`resharper_double_negation_of_boolean_highlighting`	代码检查：布尔值的双重否定是多余的
`resharper_double_negation_operator_highlighting`	代码检查：双重否定运算符
`resharper_duplicate_identifier_error_highlighting`	代码检查：重复的标识符
`resharper_duplicate_reference_comment_highlighting`	代码检查：重复的引用注释是多余的
`resharper_duplicate_resource_highlighting`	代码检查：重复的资源名称
`resharper_duplicating_local_declaration_highlighting`	代码检查：重复的局部声明
`resharper_duplicating_parameter_declaration_error_highlighting`	代码检查：在 'strict mode' 中重复的参数声明
`resharper_duplicating_property_declaration_error_highlighting`	代码检查：在 'strict mode' 中重复的属性声明
`resharper_duplicating_property_declaration_highlighting`	代码检查：重复的属性声明
`resharper_duplicating_switch_label_highlighting`	代码检查：重复的 switch 标签
`resharper_elided_trailing_element_highlighting`	代码检查：数组的尾部元素被省略
`resharper_empty_block_style`	大括号布局 - 空大括号格式化，可用于： C#
`resharper_empty_constructor_highlighting`	代码检查：空构造函数
`resharper_empty_destructor_highlighting`	代码检查：空析构函数
`resharper_empty_embedded_statement_highlighting`	代码检查：空控制语句体
`resharper_empty_for_statement_highlighting`	代码检查：空的 'for' 循环是多余的
`resharper_empty_general_catch_clause_highlighting`	代码检查：空的一般 catch 子句
`resharper_empty_namespace_highlighting`	代码检查：空的命名空间声明
`resharper_empty_object_property_declaration_highlighting`	代码检查：预期的对象属性声明
`resharper_empty_region_highlighting`	代码检查：空区域
`resharper_empty_return_value_for_type_annotated_function_highlighting`	代码检查：类型注解函数的空返回值
`resharper_empty_statement_highlighting`	代码检查：空语句是多余的
`resharper_enforce_do_while_statement_braces_highlighting`	代码检查：使用首选的大括号样式（在 'do-while' 语句中强制使用大括号）
`resharper_enforce_fixed_statement_braces_highlighting`	代码检查：使用首选的大括号样式（在 'fixed' 语句中强制使用大括号）
`resharper_enforce_for_statement_braces_highlighting`	代码检查：使用首选的大括号样式（在 'for' 语句中强制使用大括号）
`resharper_enforce_foreach_statement_braces_highlighting`	代码检查：使用首选的大括号样式（在 'foreach' 语句中强制使用大括号）
`resharper_enforce_if_statement_braces_highlighting`	代码检查：使用首选的大括号样式（在 'if' 语句中强制使用大括号）
`resharper_enforce_lock_statement_braces_highlighting`	代码检查：使用首选的大括号样式（在 'lock' 语句中强制使用大括号）
`resharper_enforce_using_statement_braces_highlighting`	代码检查：使用首选的大括号样式（在 'using' 语句中强制使用大括号）
`resharper_enforce_while_statement_braces_highlighting`	代码检查：使用首选的大括号样式（在 'while' 语句中强制使用大括号）
`resharper_entity_framework_client_side_db_function_call_highlighting`	代码检查：数据库函数不得在非数据库上下文中调用
`resharper_entity_framework_model_validation_circular_dependency_highlighting`	代码检查：此属性定义的关系导致了依赖循环
`resharper_entity_framework_model_validation_unlimited_string_length_highlighting`	代码检查：由于字符串长度无限可能导致性能问题
`resharper_entity_framework_n_plus_one_incomplete_data_query_highlighting`	代码检查：查询可能会返回不完整的相关实体数据
`resharper_entity_framework_n_plus_one_incomplete_data_usage_highlighting`	代码检查：导航属性的使用可能会返回不完整的数据
`resharper_entity_framework_n_plus_one_query_highlighting`	代码检查：可能对相关实体的数据库进行多次查询（N+1 问题）
`resharper_entity_framework_n_plus_one_usage_highlighting`	代码检查：可能对数据库进行多次查询（N+1 问题）
`resharper_entity_framework_unsupported_server_side_function_call_highlighting`	代码检查：函数无法转换为 SQL，且不得在数据库上下文中调用
`resharper_entity_name_captured_only_global_highlighting`	代码检查：实体仅用于捕获其名称（非私有可访问性）
`resharper_entity_name_captured_only_local_highlighting`	代码检查：实体仅用于捕获其名称（私有可访问性）
`resharper_enum_underlying_type_is_int_highlighting`	代码检查：枚举的基础类型为 'int'
`resharper_enumerable_sum_in_explicit_unchecked_context_highlighting`	代码检查：在显式未检查上下文中调用 'Enumerable.Sum'
`resharper_equal_expression_comparison_highlighting`	代码检查：相似表达式比较
`resharper_error_in_xml_doc_reference_highlighting`	代码检查： XML 文档注释引用中的错误
`resharper_es6_feature_highlighting`	代码检查：在 ES 5 或更低版本中使用 ECMAScript 2015 功能
`resharper_es7_feature_highlighting`	代码检查：在 ES 2015 或更低版本中使用 ECMAScript 2016 功能
`resharper_eval_arguments_name_error_highlighting`	代码检查：在 'strict mode' 中使用 'eval'/'arguments' 名称
`resharper_event_never_invoked_global_highlighting`	代码检查：抽象或虚拟（可重写）事件从未被调用
`resharper_event_never_invoked_highlighting`	代码检查：事件从未被调用
`resharper_event_never_subscribed_to_global_highlighting`	代码检查：事件从未被订阅（非私有可访问性）
`resharper_event_never_subscribed_to_local_highlighting`	代码检查：事件从未被订阅（私有可访问性）
`resharper_event_unsubscription_via_anonymous_delegate_highlighting`	代码检查：通过匿名委托取消事件订阅
`resharper_experimental_feature_highlighting`	代码检查：在语言级别设置为稳定时使用实验性功能
`resharper_explicit_caller_info_argument_highlighting`	代码检查：向具有调用者信息属性的参数显式传递参数
`resharper_expression_is_always_const_highlighting`	代码检查：表达式始终为常量
`resharper_expression_is_always_null_highlighting`	代码检查：表达式始终为 'null'
`resharper_extra_spaces`	保留现有格式 - 内部的额外空格，适用于： C#
`resharper_extract_common_property_pattern_highlighting`	代码检查：提取公共属性模式
`resharper_field_can_be_made_read_only_global_highlighting`	代码检查：字段可以设为只读（非私有可访问性）
`resharper_field_can_be_made_read_only_local_highlighting`	代码检查：字段可以设为只读（私有可访问性）
`resharper_field_hides_interface_property_with_default_implementation_highlighting`	代码检查：字段隐藏了接口中具有默认实现的属性
`resharper_for_built_in_types`	声明中 'var' 的使用 - 对于内置类型（C#）
`resharper_for_can_be_converted_to_foreach_highlighting`	代码检查： For 循环可以转换为 Foreach 循环
`resharper_for_other_types`	声明中 'var' 的使用 - 其他地方（C#）
`resharper_for_simple_types`	声明中 'var' 的使用 - 对于简单类型（C#）
`resharper_for_statement_condition_is_true_highlighting`	代码检查： 'true' 作为 'for' 语句条件是多余的
`resharper_force_attribute_style`	属性 - 在部分中合并或分离属性（C#）
`resharper_force_chop_compound_do_expression`	二元表达式的排列 - 强制在 'do' 语句中分割复合条件（C#）
`resharper_force_chop_compound_if_expression`	二元表达式的排列 - 强制在 'if' 语句中分割复合条件（C#）
`resharper_force_chop_compound_while_expression`	二元表达式的排列 - 强制在 'while' 语句中分割复合条件（C#）
`resharper_foreach_can_be_converted_to_query_using_another_get_enumerator_highlighting`	代码检查： Foreach 循环可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法
`resharper_foreach_can_be_partly_converted_to_query_using_another_get_enumerator_highlighting`	代码检查： Foreach 循环的一部分可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法
`resharper_format_string_placeholders_mismatch_highlighting`	代码检查：格式字符串占位符不匹配
`resharper_format_string_problem_highlighting`	代码检查：字符串格式化方法问题
`resharper_function_complexity_overflow_highlighting`	代码检查：函数体过于复杂，无法分析
`resharper_function_never_returns_highlighting`	代码检查：函数从未返回
`resharper_function_parameter_named_arguments_highlighting`	代码检查：参数名称 'arguments' 与预定义的 JS 函数作用域变量冲突
`resharper_function_recursive_on_all_paths_highlighting`	代码检查：函数在所有执行路径上都是递归的
`resharper_function_used_out_of_scope_highlighting`	代码检查：函数在声明范围之外被使用
`resharper_functions_used_before_declared_highlighting`	代码检查：函数在声明之前被使用
`resharper_gc_suppress_finalize_for_type_without_destructor_highlighting`	代码检查： 'GC.SuppressFinalize' 被调用于没有析构函数的类型
`resharper_grammar_mistake_in_comment_highlighting`	代码检查：注释中的语法错误
`resharper_grammar_mistake_in_markup_attribute_highlighting`	代码检查：标记属性值中的语法错误
`resharper_grammar_mistake_in_markup_text_highlighting`	代码检查：标记文本中的语法错误
`resharper_grammar_mistake_in_string_literal_highlighting`	代码检查：字符串字面量中的语法错误
`resharper_heuristic_unreachable_code_highlighting`	代码检查：启发式不可达代码
`resharper_heuristically_unreachable_code_highlighting`	代码检查：启发式不可达代码
`resharper_html_blank_lines_around_razor_functions`	Razor @functions 块周围的空行 (Razor CSharp)
`resharper_html_blank_lines_around_razor_helpers`	Razor 助手周围的空行 (Razor CSharp)
`resharper_html_blank_lines_around_razor_sections`	Razor 区段周围的空行 (Razor CSharp)
`resharper_html_linebreaks_around_razor_statements`	Razor 语句周围的换行 (Razor CSharp)
`resharper_html_use_old_engine`	为 Razor 格式化使用旧引擎（Razor CSharp）
`resharper_identifier_typo_highlighting`	代码检查：标识符中的拼写错误
`resharper_implicit_any_error_highlighting`	代码检查：当设置 NoImplicitAny 时的“隐式 any”检查
`resharper_implicit_any_type_warning_highlighting`	代码检查：元素具有隐式的“any”类型
`resharper_import_keyword_not_with_invocation_highlighting`	代码检查：此处不允许使用“import”关键字
`resharper_in_parameter_with_must_dispose_resource_attribute_highlighting`	代码检查：输入参数的 [MustDisposeResource] 注解无意义
`resharper_inactive_preprocessor_branch_highlighting`	代码检查：非活动的预处理器分支
`resharper_inconsistent_function_returns_highlighting`	代码检查：函数返回值不一致
`resharper_inconsistent_naming_highlighting`	代码检查：命名不一致
`resharper_inconsistent_order_of_locks_highlighting`	代码检查：获取锁的顺序不一致
`resharper_inconsistently_synchronized_field_highlighting`	代码检查：字段上的同步不一致
`resharper_incorrect_blank_lines_near_braces_highlighting`	代码检查：空行不正确（大括号附近的空行数量不正确）
`resharper_incorrect_operand_in_type_of_comparison_highlighting`	代码检查： “typeof”表达式与不正确的值进行比较
`resharper_incorrect_triple_slash_location_highlighting`	代码检查：三斜杠指令仅在文件顶部有效
`resharper_indent_anonymous_method_block`	对齐多行结构 - 匿名方法体（C#）
`resharper_indent_braces_inside_statement_conditions`	其他缩进 - 在语句条件内缩进大括号（C#）
`resharper_indent_case_from_select`	其他 - 将“case”缩进到“select”（VB.NET）
`resharper_indent_child_elements`	标签内容 - 在不包含文本的元素内缩进，可用于：
`resharper_indent_inside_namespace`	大括号布局 - 在命名空间声明内缩进（C#）
`resharper_indent_invocation_pars`	括号 - 方法调用的括号缩进，可用于： C#
`resharper_indent_method_decl_pars`	括号 - 方法声明的括号缩进，可用于： C#
`resharper_indent_nested_fixed_stmt`	嵌套语句 - 缩进嵌套的“fixed”语句（C#）
`resharper_indent_nested_for_stmt`	嵌套语句 - 缩进嵌套的“for”语句（C#）
`resharper_indent_nested_foreach_stmt`	嵌套语句 - 缩进嵌套的“foreach”语句（C#）
`resharper_indent_nested_lock_stmt`	嵌套语句 - 缩进嵌套的 'lock' 语句（C#）
`resharper_indent_nested_usings_stmt`	嵌套语句 - 缩进嵌套的 'using' 语句（C#）
`resharper_indent_nested_while_stmt`	嵌套语句 - 缩进嵌套的 'while' 语句（C#）
`resharper_indent_pars`	括号 - 其他括号和方括号的缩进，可用于： C#
`resharper_indent_preprocessor_if`	预处理指令 - 缩进 #if、#else、#elif、#endif（C#）
`resharper_indent_preprocessor_other`	预处理指令 - 缩进其他预处理指令（C#）
`resharper_indent_preprocessor_region`	预处理指令 - 缩进 #region、#endregion（C#）
`resharper_indent_primary_constructor_decl_pars`	括号 - 主构造函数声明的括号缩进（C#）
`resharper_indent_raw_literal_string`	对齐多行结构 - 如何缩进原始字符串字面量（C#）
`resharper_indent_statement_pars`	括号 - 语句（if、while、for 等）的括号缩进，可用于： C#
`resharper_indent_switch_labels`	其他缩进 - 从“switch”缩进“case”，可用于： C#
`resharper_indent_text`	标签内容 - 在包含文本的元素内缩进，可用于：
`resharper_indent_type_constraints`	其他缩进 - 类型约束的缩进，可用于： C#
`resharper_indent_typearg_angles`	括号 - 类型参数的角括号缩进（C#）
`resharper_indent_typeparam_angles`	括号 - 类型参数的角括号缩进（C#）
`resharper_indexing_by_invalid_range_highlighting`	代码检查：可能的 'System.ArgumentOutOfRangeException'。起始索引必须小于或等于结束索引。
`resharper_inheritdoc_consider_usage_highlighting`	代码检查：在根级别使用 <inheritdoc /> 从基候选项继承文档
`resharper_inheritdoc_invalid_usage_highlighting`	代码检查： <inheritdoc /> 的使用无效
`resharper_initializer_braces`	大括号布局 - 表达式（初始化器、switch 表达式、模式、集合表达式）（C#）
`resharper_inline_out_variable_declaration_highlighting`	代码检查：内联“out”变量声明
`resharper_inline_temporary_variable_highlighting`	代码检查：内联临时变量
`resharper_instance_members_qualify_declared_in`	实例成员限定 - 限定在（C#）中声明的成员
`resharper_instance_members_qualify_members`	实例成员限定 - 对其使用 'this.' 限定符（C#）
`resharper_int_align`	对齐相似代码到列（通用化）
`resharper_int_align_assignments`	将相似代码对齐到列 - 其他赋值和初始化器（C#）
`resharper_int_align_binary_expressions`	对齐相似代码到列 - 二元表达式（C#）
`resharper_int_align_comments`	将相似代码对齐到列 - 结束注释，可用于： C#
`resharper_int_align_fields`	对齐相似代码为列 - 字段和常量 (C#)
`resharper_int_align_fix_in_adjacent`	将相似代码对齐到列 - 修复相邻行的列对齐，可用于： C#
`resharper_int_align_invocations`	对齐相似代码为列 - 相同方法的调用 (C#)
`resharper_int_align_methods`	对齐相似代码为列 - 简单方法、运算符、委托 (C#)
`resharper_int_align_nested_ternary`	对齐相似代码为列 - 嵌套三元运算符 (C#)
`resharper_int_align_parameters`	对齐相似代码为列 - 多行方法签名 (C#)
`resharper_int_align_properties`	对齐相似代码为列 - 属性和事件 (C#)
`resharper_int_align_property_patterns`	将相似代码对齐到列 - 属性模式（C#）
`resharper_int_align_switch_expressions`	对齐相似代码为列 - switch 表达式 (C#)
`resharper_int_align_switch_sections`	将相似代码对齐到列 - 简单的 Switch 部分（C#）
`resharper_int_align_variables`	对齐相似代码为列 - 变量和局部常量 (C#)
`resharper_int_division_by_zero_highlighting`	代码检查：至少一个执行路径中存在除零操作
`resharper_int_variable_overflow_highlighting`	代码检查：可能的溢出
`resharper_int_variable_overflow_in_checked_context_highlighting`	代码检查：在 checked 上下文中可能的溢出
`resharper_int_variable_overflow_in_unchecked_context_highlighting`	代码检查：在 unchecked 上下文中可能的溢出
`resharper_internal_module_highlighting`	代码检查：立即调用的函数表达式可以转换为内部模块
`resharper_internal_or_private_member_not_documented_highlighting`	代码检查：私有或内部类型或成员缺少 XML 注释
`resharper_interpolated_string_expression_is_not_i_formattable_highlighting`	代码检查：指定了格式，但插值字符串表达式不是 IFormattable
`resharper_introduce_optional_parameters_global_highlighting`	代码检查：引入可选参数（非私有可访问性）
`resharper_introduce_optional_parameters_local_highlighting`	代码检查：引入可选参数（私有可访问性）
`resharper_introduce_variable_to_apply_guard_highlighting`	代码检查：引入变量将允许应用类型守卫
`resharper_invalid_attribute_value_highlighting`	代码检查：无效的属性值
`resharper_invalid_json_syntax_highlighting`	代码检查：无效的 JSON 语法
`resharper_invalid_task_element_highlighting`	代码检查：无效的任务元素
`resharper_invalid_value_type_highlighting`	代码检查：资源值类型无效
`resharper_invalid_xml_doc_comment_highlighting`	代码检查：无效的 XML 文档注释
`resharper_invert_condition_1_highlighting`	代码检查：反转条件
`resharper_invert_if_highlighting`	代码检查：反转 'if' 语句以减少嵌套
`resharper_invocable_declaration_braces`	大括号布局 - 方法声明，可用于： C#
`resharper_invocation_is_skipped_highlighting`	代码检查：方法调用被跳过
`resharper_invocation_of_non_function_highlighting`	代码检查：调用非函数表达式
`resharper_invoke_as_extension_method_highlighting`	代码检查：将静态方法调用转换为扩展方法调用
`resharper_invoked_expression_maybe_non_function_highlighting`	代码检查：调用的表达式不是函数值
`resharper_is_expression_always_false_highlighting`	代码检查： 'is' 运算符的表达式从不属于提供的类型
`resharper_is_expression_always_true_highlighting`	代码检查： 'is' 运算符的给定表达式始终属于提供的类型
`resharper_iterator_method_result_is_ignored_highlighting`	代码检查：迭代器的返回值未被使用
`resharper_iterator_never_returns_highlighting`	代码检查：迭代器从不返回
`resharper_join_declaration_and_initializer_highlighting`	代码检查：合并局部变量声明和赋值
`resharper_join_declaration_and_initializer_js_highlighting`	代码检查：合并局部变量声明和赋值
`resharper_join_null_check_with_usage_highlighting`	代码检查：将空检查与赋值合并
`resharper_js_brace_style`	大括号布局样式（通用化）
`resharper_js_path_not_found_highlighting`	代码检查：未找到引用注释的路径
`resharper_js_space_between_method_call_name_and_opening_parenthesis`	方法调用括号之前的空格 (通用)
`resharper_js_space_between_method_declaration_name_and_open_parenthesis`	方法声明括号之前的空格 (通用)
`resharper_js_space_between_square_brackets`	括号内的空格（通用）
`resharper_js_unreachable_code_highlighting`	代码检查：不可达代码
`resharper_json_validation_failed_highlighting`	代码检查： JSON 验证失败
`resharper_jump_must_be_in_loop_highlighting`	代码检查：在循环体外使用 'break' 或 'continue'
`resharper_keep_blank_lines_between_declarations`	空行 - 声明之间的最大空行数，适用于：
`resharper_keep_blank_lines_in_code`	代码中的空行 - 保持代码中的最大空行数，适用于： C#、 VB.NET
`resharper_keep_blank_lines_in_declarations`	声明中的空行 - 保持声明中的最大空行数，适用于： C#、 VB.NET
`resharper_keep_existing_arrangement`	保持现有代码排列（单行/多行）（通用）
`resharper_keep_existing_attribute_arrangement`	属性排列 - 保留现有属性排列（C#）
`resharper_keep_existing_declaration_block_arrangement`	声明块排列 - 保留现有声明块排列（C#）
`resharper_keep_existing_declaration_parens_arrangement`	方法签名排列 - 保持声明中括号的现有排列（C#）
`resharper_keep_existing_embedded_arrangement`	嵌套语句排列 - 保留嵌套语句的现有排列 (C#)
`resharper_keep_existing_embedded_block_arrangement`	嵌套块排列 - 保留嵌套块的现有排列 (C#)
`resharper_keep_existing_enum_arrangement`	枚举排列 - 保留枚举的现有排列 (C#)
`resharper_keep_existing_expr_member_arrangement`	表达式主体成员排列 - 保留现有表达式主体成员排列 (C#)
`resharper_keep_existing_initializer_arrangement`	初始化器排列 - 保留现有初始化器排列（C#）
`resharper_keep_existing_invocation_parens_arrangement`	调用排列 - 保持调用中括号的现有排列（C#）
`resharper_keep_existing_linebreaks`	通用 - 保留现有的换行（C#）
`resharper_keep_existing_list_patterns_arrangement`	列表模式排列 - 保留列表模式和集合表达式的现有排列 (C#)
`resharper_keep_existing_primary_constructor_declaration_parens_arrangement`	主构造函数签名排列 - 保持声明中括号的现有排列（C#）
`resharper_keep_existing_property_patterns_arrangement`	属性模式排列 - 保留现有属性模式排列（C#）
`resharper_keep_existing_switch_expression_arrangement`	Switch 表达式排列 - 保留现有 Switch 表达式排列（C#）
`resharper_keep_user_linebreaks`	通用 - 保持现有换行，适用于： C#、 VB.NET
`resharper_l_value_is_expected_highlighting`	代码检查：需要左值错误
`resharper_label_or_semicolon_expected_highlighting`	代码检查：在 'break' 或 'continue' 之后使用表达式
`resharper_lambda_expression_can_be_made_static_highlighting`	代码检查： Lambda 表达式/匿名方法可以设为 'static'
`resharper_lambda_expression_must_be_static_highlighting`	代码检查： Lambda 表达式/匿名方法必须设为 'static' 以避免分配
`resharper_lambda_highlighting`	代码检查：函数表达式可以转换为 Lambda 表达式
`resharper_lambda_should_not_capture_context_highlighting`	代码检查： Lambda 表达式/匿名方法不得捕获包含上下文
`resharper_less_specific_overload_than_main_signature_highlighting`	代码检查：重载比主签名更不具体
`resharper_lexical_declaration_needs_block_highlighting`	代码检查：词法声明只能在块内声明
`resharper_linebreak_before_elements`	标签周围 - 将以下元素放在新行，适用于：
`resharper_linebreak_before_multiline_elements`	标签周围 - 将多行元素放在新行，适用于：
`resharper_linebreak_before_singleline_elements`	标签周围 - 将单行元素放在新行上，可用于：
`resharper_linebreaks_around_razor_statements`	Razor 语句周围的换行 (Razor CSharp)
`resharper_linebreaks_inside_tags_for_elements_longer_than`	标签内容 - 当元素长度超过时，在起始标签后和结束标签前换行，可用于：
`resharper_linebreaks_inside_tags_for_elements_with_child_elements`	标签周围 - 在包含其他元素且无文本的元素中，在起始标签后和结束标签前换行，适用于：
`resharper_linebreaks_inside_tags_for_multiline_elements`	标签周围 - 在多行元素中，在起始标签后和结束标签前换行，适用于：
`resharper_local_function_body`	代码主体 - 局部函数（C#）
`resharper_local_function_can_be_made_static_highlighting`	代码检查：本地函数可以设为 static
`resharper_local_function_hides_method_highlighting`	代码检查：本地函数隐藏了方法
`resharper_local_function_redefined_later_highlighting`	代码检查：本地函数稍后被重新定义
`resharper_local_variable_hides_member_highlighting`	代码检查：本地变量隐藏了成员
`resharper_local_variable_hides_primary_constructor_parameter_highlighting`	代码检查：本地变量隐藏了主构造函数参数
`resharper_localizable_element_highlighting`	代码检查：元素是可本地化的
`resharper_long_literal_ending_lower_l_highlighting`	代码检查： 'l' 后缀容易与数字 '1' 混淆
`resharper_loop_can_be_converted_to_query_highlighting`	代码检查：循环可以转换为 LINQ 表达式
`resharper_loop_can_be_partly_converted_to_query_highlighting`	代码检查：循环体的一部分可以转换为 LINQ 表达式
`resharper_loop_variable_is_never_changed_inside_loop_highlighting`	代码检查：循环控制变量在循环内从未更改
`resharper_math_abs_method_is_redundant_highlighting`	代码检查： Math.Abs() 参数始终为非负数
`resharper_math_clamp_min_greater_than_max_highlighting`	代码检查：传递给 'Math.Clamp()' 方法的参数不一致
`resharper_max_array_initializer_elements_on_line`	初始化器排列 - 单行中的最大数组初始化器和集合表达式元素数（C#）
`resharper_max_attribute_length_for_same_line`	属性排列 - 如果属性部分列表过长，则将其放在单独的行上 (C#)
`resharper_max_blank_lines_between_tags`	标签周围 - 标签之间的最大空行数，适用于：
`resharper_max_enum_members_on_line`	枚举排列 - 单行中的最大枚举成员数（C#）
`resharper_max_formal_parameters_on_line`	方法签名排列 - 单行中的最大正式参数数 (C#)
`resharper_max_initializer_elements_on_line`	初始化器排列 - 单行中的最大对象和集合初始化器元素数（C#）
`resharper_max_invocation_arguments_on_line`	调用排列 - 单行中的最大调用参数数 (C#)
`resharper_max_primary_constructor_parameters_on_line`	主构造函数签名排列 - 单行中的最大主构造函数参数数（C#）
`resharper_meaningless_default_parameter_value_highlighting`	代码检查： 'DefaultParameterValueAttribute' 必须与 'OptionalAttribute' 一起使用
`resharper_member_can_be_file_local_highlighting`	代码检查：类型可以设为文件本地
`resharper_member_can_be_internal_highlighting`	代码检查：成员或类型可以设为内部 (友元)
`resharper_member_can_be_made_static_global_highlighting`	代码检查：成员可以设为静态 (共享) (非私有可访问性)
`resharper_member_can_be_made_static_local_highlighting`	代码检查：成员可以设为静态 (共享) (私有可访问性)
`resharper_member_can_be_private_global_highlighting`	代码检查：成员可以设为私有 (非私有可访问性)
`resharper_member_can_be_private_local_highlighting`	代码检查：成员可以设为私有 (私有可访问性)
`resharper_member_can_be_protected_global_highlighting`	代码检查：成员可以设为受保护 (非私有可访问性)
`resharper_member_can_be_protected_local_highlighting`	代码检查：成员可以设为受保护 (私有可访问性)
`resharper_member_hides_interface_member_with_default_implementation_highlighting`	代码检查：实现类中的非公共成员隐藏了接口中的默认实现
`resharper_member_hides_static_from_outer_class_highlighting`	代码检查：成员隐藏了外部类的静态成员
`resharper_member_initializer_value_ignored_highlighting`	代码检查：成员初始化的值被忽略
`resharper_merge_and_pattern_highlighting`	代码检查：合并 'and' 模式
`resharper_merge_cast_with_type_check_highlighting`	代码检查：类型检查和强制转换可以合并
`resharper_merge_conditional_expression_highlighting`	代码检查：将条件 ?: 表达式合并为条件访问
`resharper_merge_into_logical_pattern_highlighting`	代码检查：将空值/模式/值检查合并为 'or'/'and' 模式
`resharper_merge_into_negated_pattern_highlighting`	代码检查：将取反的空值/模式检查合并为复杂模式
`resharper_merge_into_pattern_highlighting`	代码检查：将空值/模式检查合并为复杂模式
`resharper_merge_nested_property_patterns_highlighting`	代码检查：合并嵌套属性模式
`resharper_merge_sequential_checks_highlighting`	代码检查：将连续检查合并为单个条件访问检查
`resharper_method_has_async_overload_highlighting`	代码检查：方法具有异步重载
`resharper_method_has_async_overload_with_cancellation_highlighting`	代码检查：方法具有支持取消的异步重载
`resharper_method_or_operator_body`	代码主体 - 方法和运算符（C#）
`resharper_method_overload_with_optional_parameter_highlighting`	代码检查：带有可选或 'params' 参数的方法被重载隐藏
`resharper_method_safe_this_highlighting`	代码检查：由函数赋值的成员可以转换为函数成员
`resharper_method_supports_cancellation_highlighting`	代码检查：方法支持取消
`resharper_mismatched_asmdef_filename_highlighting`	代码检查：文件名应与程序集名称匹配
`resharper_missing_attribute_highlighting`	代码检查：缺少必需的属性
`resharper_missing_blank_lines_highlighting`	代码检查：空行不正确 (其他地方缺少空行)
`resharper_missing_has_own_property_in_foreach_highlighting`	代码检查：在 'for in' 循环体中没有 .hasOwnProperty() 检查。这将导致枚举原型属性。
`resharper_missing_indent_highlighting`	代码检查：缩进不正确 (其他地方缺少缩进/缩出)
`resharper_missing_linebreak_highlighting`	代码检查：换行不正确 (其他地方缺少换行)
`resharper_missing_space_highlighting`	代码检查：间距不正确 (其他地方缺少间距)
`resharper_misuse_of_owner_function_this_highlighting`	代码检查：在内部函数中误用 'this' 限定符
`resharper_modifiers_order`	修饰符 - 修饰符顺序（C#）
`resharper_more_specific_foreach_variable_type_available_highlighting`	代码检查：迭代变量可以用更具体的类型声明
`resharper_more_specific_signature_after_less_specific_highlighting`	代码检查：更具体的签名跟随不太具体的签名
`resharper_move_local_function_after_jump_statement_highlighting`	代码检查：将局部函数放在 'return' 或 'continue' 之后
`resharper_move_to_existing_positional_deconstruction_pattern_highlighting`	代码检查：移动到现有的位置解构模式
`resharper_move_variable_declaration_inside_loop_condition_highlighting`	代码检查：将变量声明移到循环条件内
`resharper_multiple_declarations_in_foreach_highlighting`	代码检查： 'for in' 错误中的多个声明
`resharper_multiple_nullable_attributes_usage_highlighting`	代码检查：多个可空属性的使用
`resharper_multiple_order_by_highlighting`	代码检查：多次连续调用 'OrderBy'
`resharper_multiple_output_tags_highlighting`	代码检查：定义了多个输出标签
`resharper_multiple_resolve_candidates_in_text_highlighting`	代码检查：文本参数中存在模糊符号
`resharper_multiple_spaces_highlighting`	代码检查：间距不正确（禁止多个空格）
`resharper_multiple_statements_on_one_line_highlighting`	代码检查：换行不正确（同一行包含多个语句）
`resharper_multiple_type_members_on_one_line_highlighting`	代码检查：换行不正确（同一行包含多个类型成员）
`resharper_must_use_return_value_highlighting`	代码检查： [MustUseReturnValue] 注解方法的返回值未被使用
`resharper_mvc_action_not_resolved_highlighting`	代码检查： MVC（未知操作）
`resharper_mvc_area_not_resolved_highlighting`	代码检查： MVC（未知区域）
`resharper_mvc_controller_not_resolved_highlighting`	代码检查： MVC（未知控制器）
`resharper_mvc_invalid_model_type_highlighting`	代码检查： MVC（模型类型不匹配）
`resharper_mvc_masterpage_not_resolved_highlighting`	代码检查： MVC（未知母版页）
`resharper_mvc_partial_view_not_resolved_highlighting`	代码检查： MVC（未知部分视图）
`resharper_mvc_template_not_resolved_highlighting`	代码检查： MVC（未知模板）
`resharper_mvc_view_component_not_resolved_highlighting`	代码检查： MVC（未知视图组件）
`resharper_mvc_view_component_view_not_resolved_highlighting`	代码检查： MVC（未知视图组件视图）
`resharper_mvc_view_not_resolved_highlighting`	代码检查： MVC（未知视图）
`resharper_n_unit_async_method_must_be_task_highlighting`	代码检查： NUnit。异步测试方法必须返回 Task 或 Task<T>
`resharper_n_unit_attribute_produces_too_many_tests_highlighting`	代码检查： NUnit。指定的属性值生成了过多的测试。
`resharper_n_unit_auto_fixture_incorrect_argument_type_highlighting`	代码检查： NUnit.AutoFixture。参数类型不兼容或参数值不正确。
`resharper_n_unit_auto_fixture_missed_test_or_test_fixture_attribute_highlighting`	代码检查： NUnit.AutoFixture。缺少 Test 或 TestFixture 属性。
`resharper_n_unit_auto_fixture_redundant_argument_in_inline_auto_data_attribute_highlighting`	代码检查： NUnit.AutoFixture。 InlineAutoData 属性中存在多余的参数。
`resharper_n_unit_duplicate_values_highlighting`	代码检查： NUnit。重复的值。
`resharper_n_unit_ignored_parameter_attribute_highlighting`	代码检查： NUnit。被忽略的参数属性。
`resharper_n_unit_implicit_unspecified_null_values_highlighting`	代码检查： NUnit。隐式未指定的空值。
`resharper_n_unit_incorrect_argument_type_highlighting`	代码检查： NUnit。参数类型不兼容或参数值不正确。
`resharper_n_unit_incorrect_expected_result_type_highlighting`	代码检查： NUnit。预期结果类型不兼容或值不正确。
`resharper_n_unit_incorrect_range_bounds_highlighting`	代码检查： NUnit。范围边界不正确。 'to' 必须大于或等于 'from'。
`resharper_n_unit_method_with_parameters_and_test_attribute_highlighting`	代码检查： NUnit。未为测试方法参数提供值。
`resharper_n_unit_missing_arguments_in_test_case_attribute_highlighting`	代码检查： NUnit。 TestCase 属性中缺少参数。
`resharper_n_unit_no_values_provided_highlighting`	代码检查： NUnit。属性中未提供任何值。
`resharper_n_unit_non_public_method_with_test_attribute_highlighting`	代码检查： NUnit。非公共测试方法。
`resharper_n_unit_parameter_type_is_not_compatible_with_attribute_highlighting`	代码检查： NUnit。指定的值与测试参数类型不兼容。
`resharper_n_unit_range_attribute_bounds_are_out_of_range_highlighting`	代码检查： NUnit。范围内的值与测试参数的类型不匹配。
`resharper_n_unit_range_step_sign_mismatch_highlighting`	代码检查： NUnit。范围步长符号不匹配。
`resharper_n_unit_range_step_value_must_not_be_zero_highlighting`	代码检查： NUnit。范围的 'step' 参数值必须为非零。
`resharper_n_unit_range_to_value_is_not_reachable_highlighting`	代码检查： NUnit。使用当前步长值无法达到最大范围值。
`resharper_n_unit_redundant_argument_in_test_case_attribute_highlighting`	代码检查： NUnit。 TestCase 属性中存在多余的参数。
`resharper_n_unit_redundant_argument_instead_of_expected_result_highlighting`	代码检查： NUnit。多余的参数代替了 ExpectedResult。
`resharper_n_unit_redundant_expected_result_in_test_case_attribute_highlighting`	代码检查： NUnit。对于 void 测试方法，多余的预期结果。
`resharper_n_unit_test_case_attribute_requires_expected_result_highlighting`	代码检查： NUnit。对于非 void 测试方法，缺少预期结果。
`resharper_n_unit_test_case_result_property_duplicates_expected_result_highlighting`	代码检查： NUnit。测试用例的 Result 属性与 ExpectedResult 重复。
`resharper_n_unit_test_case_result_property_is_obsolete_highlighting`	代码检查： 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#)
`resharper_place_event_attribute_on_same_line`	属性 - 将事件属性放在同一行（VB.NET）
`resharper_place_expr_accessor_on_single_line`	表达式主体成员的排列 - 将属性访问器表达式主体放在同一行（C#）
`resharper_place_expr_method_on_single_line`	表达式主体成员的排列 - 将方法表达式主体放在同一行（C#）
`resharper_place_expr_property_on_single_line`	表达式主体成员的排列 - 将属性表达式主体放在同一行（C#）
`resharper_place_field_attribute_on_same_line`	属性的排列 - 将字段属性放在同一行（C#）
`resharper_place_linq_into_on_new_line`	LINQ 表达式的排列 - 在 LINQ 表达式中将 'into' 放在新行（C#）
`resharper_place_method_attribute_on_same_line`	属性的排列 - 将方法属性放在同一行（C#）
`resharper_place_property_attribute_on_same_line`	属性 - 将属性的属性放在同一行 (VB.NET)
`resharper_place_record_field_attribute_on_same_line`	属性的排列 - 将记录字段属性放在同一行（C#）
`resharper_place_simple_accessor_on_single_line`	声明块的排列 - 将简单访问器放在单行（C#）
`resharper_place_simple_accessorholder_on_single_line`	声明块的排列 - 将简单属性/索引器/事件声明放在单行（C#）
`resharper_place_simple_anonymousmethod_on_single_line`	嵌套块的排列 - 将简单匿名方法放在单行（C#）
`resharper_place_simple_blocks_on_single_line`	将简单块放在单行（通用）
`resharper_place_simple_case_statement_on_same_line`	嵌套语句的排列 - 将简单 'case' 语句放在同一行（C#）
`resharper_place_simple_declaration_blocks_on_single_line`	将简单类型成员的块放在单行（通用）
`resharper_place_simple_embedded_block_on_same_line`	嵌套块的排列 - 将包含单个简单语句的块放在同一行（C#）
`resharper_place_simple_embedded_statement_on_same_line`	嵌套语句的排列 - 将简单嵌套语句放在同一行（C#）
`resharper_place_simple_enum_on_single_line`	枚举的排列 - 将简单枚举放在单行（C#）
`resharper_place_simple_initializer_on_single_line`	初始化器的排列 - 将简单数组、对象和集合放在单行（C#）
`resharper_place_simple_list_pattern_on_single_line`	列表模式的排列 - 将简单列表模式和集合表达式放在单行（C#）
`resharper_place_simple_method_on_single_line`	声明块的排列 - 将简单方法放在单行（C#）
`resharper_place_simple_property_pattern_on_single_line`	属性模式的排列 - 将简单属性模式放在单行（C#）
`resharper_place_simple_switch_expression_on_single_line`	切换表达式的排列 - 将简单切换表达式放在单行（C#）
`resharper_place_type_attribute_on_same_line`	属性排列 - 将类型属性放在同一行 (C#)
`resharper_place_type_constraints_on_same_line`	类型参数、约束和基类型的排列 - 允许类型约束在同一行，可用于： C#
`resharper_polymorphic_field_like_event_invocation_highlighting`	代码检查：多态字段式事件的调用
`resharper_possible_infinite_inheritance_highlighting`	代码检查：可能的无限继承
`resharper_possible_intended_rethrow_highlighting`	代码检查：可能有意的异常重新抛出
`resharper_possible_interface_member_ambiguity_highlighting`	代码检查：通过接口访问成员时可能的歧义
`resharper_possible_invalid_cast_exception_highlighting`	代码检查：可能的 'System.InvalidCastException'
`resharper_possible_invalid_cast_exception_in_foreach_loop_highlighting`	代码检查：在 foreach 循环中可能的 'System.InvalidCastException'
`resharper_possible_invalid_operation_exception_highlighting`	代码检查：可能的 'System.InvalidOperationException'
`resharper_possible_loss_of_fraction_highlighting`	代码检查：可能的分数丢失
`resharper_possible_mistaken_argument_highlighting`	代码检查：可能的错误参数
`resharper_possible_mistaken_call_to_get_type_1_highlighting`	代码检查：可能错误地调用了 GetType()
`resharper_possible_mistaken_call_to_get_type_2_highlighting`	代码检查：可能错误地调用了 GetType()
`resharper_possible_multiple_enumeration_highlighting`	代码检查：可能的多次枚举
`resharper_possible_multiple_write_access_in_double_check_locking_highlighting`	代码检查：可能错误实现了双重检查锁定模式。可能对已检查字段的多次写入访问。
`resharper_possible_null_reference_exception_highlighting`	代码检查：可能的 'System.NullReferenceException'
`resharper_possible_struct_member_modification_of_non_variable_struct_highlighting`	代码检查：赋值给非变量限定符表达式的属性可能会丢失
`resharper_possible_unintended_linear_search_in_set_highlighting`	代码检查：在集合中可能无意的线性搜索
`resharper_possible_unintended_queryable_as_enumerable_highlighting`	代码检查： IQueryable 可能无意中用作 IEnumerable
`resharper_possible_unintended_reference_comparison_highlighting`	代码检查：可能无意的引用比较
`resharper_possible_write_to_me_highlighting`	代码检查：可能对 'Me' 的写入
`resharper_possibly_impure_method_call_on_readonly_variable_highlighting`	代码检查：在只读变量上调用可能不纯的结构体方法：结构体值在调用前总是被复制
`resharper_possibly_incorrectly_broken_statement_highlighting`	代码检查：语句可能被换行符错误地中断
`resharper_possibly_missing_indexer_initializer_comma_highlighting`	代码检查：索引器初始化器前可能缺少逗号
`resharper_possibly_mistaken_use_of_interpolated_string_insert_highlighting`	代码检查：可能无意的字符串插值而非格式字符串模板
`resharper_possibly_unassigned_property_highlighting`	代码检查：可能使用了未赋值的属性或全局变量
`resharper_prefer_explicit_discard_declaration`	'var' 声明的使用 - 对于丢弃值使用 'var' 关键字 (C#)
`resharper_prefer_qualified_reference`	引用限定和 'using' 指令 - 优先使用完全限定的引用，可用于： C#、 Razor CSharp、 VB.NET
`resharper_prefer_separate_deconstructed_variables_declaration`	'var' 在声明中的使用 - 对解构变量优先使用单独声明 (C#)
`resharper_private_field_can_be_converted_to_local_variable_highlighting`	代码检查：私有字段可以转换为局部变量
`resharper_private_variable_can_be_made_readonly_highlighting`	代码检查：私有类字段可以设为只读
`resharper_property_can_be_made_init_only_global_highlighting`	代码检查：属性可以设为仅初始化 (非私有访问权限)
`resharper_property_can_be_made_init_only_local_highlighting`	代码检查：属性可以设为仅初始化 (私有访问权限)
`resharper_property_field_keyword_is_never_assigned_highlighting`	代码检查：后备字段已使用但从未赋值
`resharper_property_field_keyword_is_never_used_highlighting`	代码检查：后备字段已赋值但从未使用
`resharper_property_getter_cannot_have_parameters_highlighting`	代码检查：属性 getter 不能有参数
`resharper_property_not_resolved_highlighting`	代码检查：无法解析属性
`resharper_property_setter_must_have_single_parameter_highlighting`	代码检查：属性 setter 必须有一个参数
`resharper_protobuf_brace_style`	大括号布局样式（通用）
`resharper_public_constructor_in_abstract_class_highlighting`	代码检查：在抽象类中将构造函数设为受保护
`resharper_pure_attribute_on_void_method_highlighting`	代码检查： 'void' 方法带有 [Pure] 属性注解
`resharper_qualified_expression_is_null_highlighting`	代码检查：限定符为 'null' 或 'undefined'
`resharper_qualified_expression_maybe_null_highlighting`	代码检查：限定符可能为 'null' 或 'undefined'
`resharper_qualified_using_at_nested_scope`	引用限定和 'using' 指令 - 在嵌套作用域中优先使用完全限定的 'using' 名称 (C#)
`resharper_quote_style`	引号 - 引号样式，可用于：
`resharper_raw_string_can_be_simplified_highlighting`	代码检查：原始字符串可以简化
`resharper_razor_always_use_end_of_line_brace_style`	为 C# 覆盖大括号样式以始终使用 '行尾 (K&R 样式)'（Razor CSharp）
`resharper_razor_layout_not_resolved_highlighting`	代码检查：未知的 Razor 布局
`resharper_razor_prefer_qualified_reference`	为 @inherits 和 @model 指令使用完全限定的名称 (Razor CSharp)
`resharper_razor_remove_blank_lines_near_braces`	在 @functions (Razor CSharp) 中删除 '{' 后和 '}' 前的空行
`resharper_razor_remove_this_qualifier`	始终删除 'this.' 限定符 (覆盖相应的 C# 设置) (Razor CSharp)
`resharper_razor_section_not_resolved_highlighting`	代码检查：未知的 Razor 部分
`resharper_read_access_in_double_check_locking_highlighting`	代码检查：可能错误实现了双重检查锁定模式。读取已检查字段的访问。
`resharper_redundant_abstract_modifier_highlighting`	代码检查：多余的 'abstract' 修饰符
`resharper_redundant_accessor_body_highlighting`	代码检查：多余的访问器主体
`resharper_redundant_always_match_subpattern_highlighting`	代码检查：始终匹配的子模式是多余的
`resharper_redundant_anonymous_type_property_name_highlighting`	代码检查：多余的匿名类型属性显式名称
`resharper_redundant_argument_default_value_highlighting`	代码检查：具有默认值的多余参数
`resharper_redundant_array_creation_expression_highlighting`	代码检查：数组创建可以替换为数组初始化器
`resharper_redundant_array_lower_bound_specification_highlighting`	代码检查：多余的数组下界指定
`resharper_redundant_assignment_highlighting`	代码检查：赋值未被使用
`resharper_redundant_attribute_parentheses_highlighting`	代码检查：如果属性没有参数，则括号是多余的
`resharper_redundant_attribute_suffix_highlighting`	代码检查：多余的 'Attribute' 后缀
`resharper_redundant_attribute_usage_property_highlighting`	代码检查：多余的 [AttributeUsage] 属性属性赋值
`resharper_redundant_base_constructor_call_highlighting`	代码检查：多余的基类构造函数调用
`resharper_redundant_base_qualifier_highlighting`	代码检查：多余的 'base.' 限定符
`resharper_redundant_blank_lines_highlighting`	代码检查：不正确的空行（其他地方的空行是多余的）
`resharper_redundant_block_highlighting`	代码检查：多余的代码块
`resharper_redundant_bool_compare_highlighting`	代码检查：多余的布尔比较
`resharper_redundant_caller_argument_expression_default_value_highlighting`	代码检查：传递给调用方参数表达式参数的多余参数
`resharper_redundant_case_label_highlighting`	代码检查：多余的 'case' 标签
`resharper_redundant_cast_highlighting`	代码检查：多余的强制转换
`resharper_redundant_catch_clause_highlighting`	代码检查：多余的 catch 子句
`resharper_redundant_check_before_assignment_highlighting`	代码检查：赋值前的多余条件检查
`resharper_redundant_collection_initializer_element_braces_highlighting`	代码检查：集合初始化器中的多余大括号
`resharper_redundant_comparison_with_boolean_highlighting`	代码检查：布尔值与布尔值的比较等同于值或取反值
`resharper_redundant_configure_await_highlighting`	代码检查：多余的 'ConfigureAwait(true)'
`resharper_redundant_declaration_semicolon_highlighting`	代码检查：类型或命名空间声明后的多余分号
`resharper_redundant_default_member_initializer_highlighting`	代码检查：多余的成员初始化器
`resharper_redundant_delegate_creation_highlighting`	代码检查：显式委托创建表达式是多余的
`resharper_redundant_dictionary_contains_key_before_adding_highlighting`	代码检查：在添加到集合之前多余的字典 'ContainsKey'
`resharper_redundant_discard_designation_highlighting`	代码检查：多余的丢弃符号指定
`resharper_redundant_else_block_highlighting`	代码检查：多余的 'else' 块
`resharper_redundant_empty_case_else_highlighting`	代码检查：多余的空 'Case Else' 语句
`resharper_redundant_empty_constructor_highlighting`	代码检查：没有参数的多余空构造函数
`resharper_redundant_empty_finally_block_highlighting`	代码检查：多余的空 finally 块
`resharper_redundant_empty_object_creation_argument_list_highlighting`	代码检查：对象创建表达式上的多余空参数列表
`resharper_redundant_empty_object_or_collection_initializer_highlighting`	代码检查：多余的空对象或集合初始化器
`resharper_redundant_empty_switch_section_highlighting`	代码检查：多余的空 switch 部分
`resharper_redundant_enum_case_label_for_default_section_highlighting`	代码检查：默认部分前的多余 'case' 标签
`resharper_redundant_enumerable_cast_call_highlighting`	代码检查：多余的 'IEnumerable.Cast<T>' 或 'IEnumerable.OfType<T>' 调用
`resharper_redundant_explicit_array_creation_highlighting`	代码检查：数组创建中的多余显式类型
`resharper_redundant_explicit_array_size_highlighting`	代码检查：数组创建中的多余显式大小指定
`resharper_redundant_explicit_nullable_creation_highlighting`	代码检查：多余的显式可空类型创建
`resharper_redundant_explicit_params_array_creation_highlighting`	代码检查： 'params' 参数的参数中的多余显式数组创建
`resharper_redundant_explicit_positional_property_declaration_highlighting`	代码检查：多余的显式位置属性声明
`resharper_redundant_explicit_tuple_component_name_highlighting`	代码检查：多余的显式元组组件名称
`resharper_redundant_extends_list_entry_highlighting`	代码检查：基类型列表中的多余类或接口指定
`resharper_redundant_fixed_pointer_declaration_highlighting`	代码检查：多余的固定指针声明
`resharper_redundant_if_else_block_highlighting`	代码检查：多余的 'else' 关键字
`resharper_redundant_if_statement_then_keyword_highlighting`	代码检查：在多行 'If' 语句中，'Then' 关键字是多余的
`resharper_redundant_immediate_delegate_invocation_highlighting`	代码检查：立即委托调用
`resharper_redundant_intermediate_variable_highlighting`	代码检查：中间局部变量是多余的，可以安全地内联
`resharper_redundant_is_before_relational_pattern_highlighting`	代码检查：多余的 'is'
`resharper_redundant_iterator_keyword_highlighting`	代码检查：没有 'Yield' 语句的迭代器函数
`resharper_redundant_jump_statement_highlighting`	代码检查：多余的控制流跳转语句
`resharper_redundant_lambda_parameter_type_highlighting`	代码检查：多余的 lambda 表达式参数类型说明
`resharper_redundant_lambda_signature_parentheses_highlighting`	代码检查：多余的 lambda 签名括号
`resharper_redundant_linebreak_highlighting`	代码检查：不正确的换行（其他地方的换行是多余的）
`resharper_redundant_local_class_name_highlighting`	代码检查：多余的局部类名
`resharper_redundant_local_function_name_highlighting`	代码检查：多余的局部函数名
`resharper_redundant_logical_conditional_expression_operand_highlighting`	代码检查：逻辑条件表达式中的多余操作数
`resharper_redundant_me_qualifier_highlighting`	代码检查：多余的 'Me.' 限定符
`resharper_redundant_my_base_qualifier_highlighting`	代码检查：多余的 'MyBase.' 限定符
`resharper_redundant_my_class_qualifier_highlighting`	代码检查：多余的 'MyClass.' 限定符
`resharper_redundant_name_qualifier_highlighting`	代码检查：多余的名称限定符
`resharper_redundant_not_null_constraint_highlighting`	代码检查：对由非空基类型约束的类型参数的多余 'notnull' 约束
`resharper_redundant_nullable_annotation_on_reference_type_constraint_highlighting`	代码检查：对由非空基类型约束的类型参数的 'class?' 约束的多余可空注解
`resharper_redundant_nullable_annotation_on_type_constraint_has_non_nullable_base_type_highlighting`	代码检查：对由另一个非空基类型约束的类型参数的基类型约束的多余可空注解
`resharper_redundant_nullable_annotation_on_type_constraint_has_non_nullable_type_kind_highlighting`	代码检查：对具有非空类型种类的类型参数的基类型约束的多余可空注解
`resharper_redundant_nullable_directive_highlighting`	代码检查：多余的可空指令
`resharper_redundant_nullable_flow_attribute_highlighting`	代码检查：多余的可空属性
`resharper_redundant_nullable_type_mark_highlighting`	代码检查：对可空类型的类型检查等同于对底层类型的检查
`resharper_redundant_nullness_attribute_with_nullable_reference_types_highlighting`	代码检查： [NotNull] 或 [CanBeNull] 属性应用于已从可空引用类型中获得相同注解的类型
`resharper_redundant_overflow_checking_context_highlighting`	代码检查：多余的算术溢出检查上下文
`resharper_redundant_overload_global_highlighting`	代码检查：多余的方法重载（非私有可访问性）
`resharper_redundant_overload_local_highlighting`	代码检查：多余的方法重载（私有可访问性）
`resharper_redundant_overridden_member_highlighting`	代码检查：多余的成员重写
`resharper_redundant_params_highlighting`	代码检查： 'params' 修饰符在重写中始终被忽略
`resharper_redundant_parent_type_declaration_highlighting`	代码检查：在 extends/implements 中多余的父类型说明
`resharper_redundant_parentheses_highlighting`	代码检查：移除多余的括号
`resharper_redundant_pattern_parentheses_highlighting`	代码检查：移除多余的模式匹配括号
`resharper_redundant_property_parentheses_highlighting`	代码检查：无参数属性的括号是多余的
`resharper_redundant_property_pattern_clause_highlighting`	代码检查：多余的属性模式子句
`resharper_redundant_qualifier_highlighting`	代码检查：多余的限定符
`resharper_redundant_query_order_by_ascending_keyword_highlighting`	代码检查：多余的 'orderby' 子句中的 'ascending' 关键字
`resharper_redundant_range_bound_highlighting`	代码检查：多余的范围边界
`resharper_redundant_readonly_modifier_highlighting`	代码检查：多余的 'readonly' 修饰符
`resharper_redundant_record_class_keyword_highlighting`	代码检查：记录声明中多余的 'class' 关键字
`resharper_redundant_scoped_parameter_modifier_highlighting`	代码检查：多余的 'scoped' 参数修饰符
`resharper_redundant_setter_value_parameter_declaration_highlighting`	代码检查：显式的 'value' 参数声明是多余的
`resharper_redundant_space_highlighting`	代码检查：不正确的空格（其他地方的空格是多余的）
`resharper_redundant_string_format_call_highlighting`	代码检查：多余的 'string.Format()' 调用
`resharper_redundant_string_interpolation_highlighting`	代码检查：多余的字符串插值
`resharper_redundant_string_to_char_array_call_highlighting`	代码检查：多余的 'string.ToCharArray()' 调用
`resharper_redundant_string_type_highlighting`	代码检查：多余的字符串类型
`resharper_redundant_suppress_nullable_warning_expression_highlighting`	代码检查：多余的可空警告抑制表达式
`resharper_redundant_ternary_expression_highlighting`	代码检查：多余的条件三元表达式用法
`resharper_redundant_to_string_call_for_value_type_highlighting`	代码检查：对值类型的冗余 'object.ToString()' 调用
`resharper_redundant_to_string_call_highlighting`	代码检查：冗余的 'object.ToString()' 调用
`resharper_redundant_type_arguments_of_method_highlighting`	代码检查：方法的冗余类型参数
`resharper_redundant_type_cast_highlighting`	代码检查：类型转换是多余的：表达式始终为提供的类型
`resharper_redundant_type_cast_structural_highlighting`	代码检查：类型转换是多余的：表达式是结构兼容的类型
`resharper_redundant_type_check_in_pattern_highlighting`	代码检查：模式中的冗余类型检查
`resharper_redundant_type_declaration_body_highlighting`	代码检查：冗余的类型声明体
`resharper_redundant_unsafe_context_highlighting`	代码检查：不安全上下文声明是多余的
`resharper_redundant_using_directive_global_highlighting`	代码检查：冗余的全局 using 指令
`resharper_redundant_using_directive_highlighting`	代码检查：冗余的 using 指令
`resharper_redundant_variable_type_specification_highlighting`	代码检查：类型说明是多余的，因为变量类型可以从赋值值的类型上下文中确定
`resharper_redundant_verbatim_prefix_highlighting`	代码检查：冗余的逐字前缀
`resharper_redundant_verbatim_string_prefix_highlighting`	代码检查：冗余的逐字字符串前缀
`resharper_redundant_virtual_modifier_highlighting`	代码检查：冗余的 'virtual' 修饰符
`resharper_redundant_with_cancellation_highlighting`	代码检查：冗余的 'WithCancellation()' 调用
`resharper_redundant_with_expression_highlighting`	代码检查：空的 'with' 表达式是多余的
`resharper_reference_equals_with_value_type_highlighting`	代码检查： 'Object.ReferenceEquals' 始终为 false，因为它是用值类型调用的
`resharper_reg_exp_inspections_highlighting`	代码检查：正则表达式检查
`resharper_remove_blank_lines_near_braces`	在 @functions (Razor CSharp) 中删除 '{' 后和 '}' 前的空行
`resharper_remove_blank_lines_near_braces_in_code`	代码中的空行 - 删除代码中 '{' 后和 '}' 前的空行，可用于： C#
`resharper_remove_blank_lines_near_braces_in_declarations`	声明中的空行 - 删除声明中 '{' 后和 '}' 前的空行，可用于： C#
`resharper_remove_constructor_invocation_highlighting`	代码检查：删除构造函数调用
`resharper_remove_redundant_braces_highlighting`	代码检查：使用首选的大括号样式（删除多余的大括号）
`resharper_remove_redundant_or_statement_false_highlighting`	代码检查：删除冗余语句
`resharper_remove_redundant_or_statement_true_highlighting`	代码检查：删除冗余语句
`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'
`resharper_service_contract_without_operations_highlighting`	代码检查：标记为 ServiceContract 的接口应至少声明一个 OperationContract
`resharper_shaderlab_alignment_tab_fill_style`	制表符和缩进 - 使用制表符进行缩进时如何对齐（ShaderLab）
`resharper_shaderlab_allow_far_alignment`	制表符和缩进 - 即使结果缩进过大也要对齐（ShaderLab）
`resharper_shaderlab_brace_style`	大括号布局样式（通用化）
`resharper_shaderlab_indent_size`	制表符和缩进 - 缩进大小（ShaderLab）
`resharper_shaderlab_indent_style`	制表符和缩进 - 缩进样式（ShaderLab）
`resharper_shaderlab_tab_width`	制表符和缩进 - 制表符宽度（ShaderLab）
`resharper_shift_expression_real_shift_count_is_zero_highlighting`	代码检查：实际移位计数等于零
`resharper_shift_expression_result_equals_zero_highlighting`	代码检查：具有非零操作数的常量移位表达式结果为零值
`resharper_shift_expression_right_operand_not_equal_real_count_highlighting`	代码检查：对于此类型的左操作数，移位计数可疑
`resharper_shift_expression_zero_left_operand_highlighting`	代码检查：左操作数为零的移位表达式结果为零
`resharper_similar_anonymous_type_nearby_highlighting`	代码检查：附近检测到相似的匿名类型
`resharper_similar_expressions_comparison_highlighting`	代码检查：相似表达式比较
`resharper_simple_embedded_statement_style`	换行 - 在单个嵌入语句中换行，可用于：
`resharper_simplify_conditional_operator_highlighting`	代码检查：简化条件运算符
`resharper_simplify_conditional_ternary_expression_highlighting`	代码检查：简化条件三元表达式
`resharper_simplify_i_if_highlighting`	代码检查：简化 'IIf'
`resharper_simplify_linq_expression_use_all_highlighting`	代码检查：简化 LINQ 表达式（使用 'All'）
`resharper_simplify_linq_expression_use_any_highlighting`	代码检查：简化 LINQ 表达式（使用 'Any'）
`resharper_simplify_linq_expression_use_min_by_and_max_by_highlighting`	代码检查：使用 'MinBy' 或 'MaxBy' 替代排序后取 'First' 或 'Last'
`resharper_simplify_string_interpolation_highlighting`	代码检查：在插值字符串中使用格式说明符
`resharper_sort_usings_with_system_first`	引用限定和 'using' 指令 - 排序 'using' 指令时优先放置 'System.' 和 'Windows.' 命名空间 (C#)
`resharper_space_after_ampersand_op`	一元运算符后 - 不安全的取地址运算符 (&)（C#）
`resharper_space_after_asterik_op`	一元运算符后 - 不安全的星号运算符 (*)（C#）
`resharper_space_after_attribute_colon`	围绕冒号 - 在其他冒号之后 (C#)
`resharper_space_after_attribute_target_colon`	属性 - 属性目标冒号后 (VB.NET)
`resharper_space_after_attributes`	属性 - 属性后（C#）
`resharper_space_after_cast`	其他 - 类型转换括号后，可用于： C#
`resharper_space_after_colon`	围绕冒号 - 在其他冒号之后 (C#)
`resharper_space_after_colon_in_case`	冒号周围 - “case”语句中的冒号后，可用于： C#
`resharper_space_after_colon_in_inheritance_clause`	冒号周围 - 基类型列表冒号后，可用于： C#
`resharper_space_after_comma`	逗号后空格（通用）
`resharper_space_after_keywords_in_control_flow_statements`	控制流语句括号前空格（通用）
`resharper_space_after_last_attribute`	标签头部内部 - 最后一个属性后的空格，可用于：
`resharper_space_after_last_pi_attribute`	处理指令 - 最后一个属性后的空格，可用于：
`resharper_space_after_logical_not_op`	一元运算符后 - 逻辑非运算符 (!)（C#）
`resharper_space_after_operator_keyword`	其他 - 运算符关键字后 (C#)
`resharper_space_after_property_colon`	属性 - 冒号后，可用于：
`resharper_space_after_semicolon_in_for_statement`	逗号和分号周围 - “for”分号后，可用于： C#
`resharper_space_after_ternary_colon`	三元运算符中 - “:”后，可用于： C#
`resharper_space_after_ternary_quest`	三元运算符中 - “?”后，可用于： C#
`resharper_space_after_type_parameter_constraint_colon`	冒号周围 - 类型参数约束冒号后，可用于： C#
`resharper_space_after_unary_minus_op`	一元运算符后 - 一元减号运算符 (-)（C#）
`resharper_space_after_unary_op`	操作周围 - 一元运算符之后 (VB.NET)
`resharper_space_after_unary_operator`	一元运算符后空格 (!, -, ~,...)（通用）
`resharper_space_after_unary_plus_op`	一元运算符后 - 一元加号运算符 (+)（C#）
`resharper_space_around_additive_op`	二元运算符周围 - 加法运算符（+、-），可用于： C#， VB.NET
`resharper_space_around_alias_eq`	其他 - 命名空间别名指令中的 '=' 周围，可用于： C#
`resharper_space_around_arrow_op`	围绕二元运算符 - 不安全箭头运算符 (->) (C#)
`resharper_space_around_assignment_op`	在二元运算符周围 - 赋值运算符（例如 '=' 和 '+='），适用于： C#， VB.NET
`resharper_space_around_assignment_operator`	在表达式中 - 在赋值运算符周围，适用于：
`resharper_space_around_binary_operator`	二元运算符周围的空格（+，\|\|，=，...）（通用）
`resharper_space_around_bitwise_op`	在二元运算符周围 - 按位运算符（&，\|，^）（C#）
`resharper_space_around_dot`	其他 - 在点号周围，适用于： C#， VB.NET
`resharper_space_around_equality_op`	围绕二元运算符 - 相等运算符 (==,!=) (C#)
`resharper_space_around_lambda_arrow`	其他 - 在 lambda 箭头周围（C#）
`resharper_space_around_logical_op`	围绕二元运算符 - 逻辑运算符 (&&,\|\|) (C#)
`resharper_space_around_member_access_operator`	在成员访问运算符周围的空格（.，->，...）（通用）
`resharper_space_around_multiplicative_op`	在二元运算符周围 - 乘法运算符（*，/，%），适用于： C#， VB.NET
`resharper_space_around_nullcoalescing_op`	在二元运算符周围 - 空合并运算符（??）（C#）
`resharper_space_around_relational_op`	在二元运算符周围 - 关系运算符（<，>，<=，>=），适用于： C#， VB.NET
`resharper_space_around_shift_op`	在二元运算符周围 - 移位运算符（<<，>>，>>>），适用于： C#， VB.NET
`resharper_space_around_stmt_colon`	其他 - 在语句 ':' 周围（VB.NET）
`resharper_space_around_ternary_operator`	在三元运算符（?，:）周围的空格（通用）
`resharper_space_before_array_access_brackets`	在数组括号周围 - 在数组访问括号之前，适用于： C#
`resharper_space_before_array_rank_brackets`	数组括号周围 - 数组维度括号前（C#）
`resharper_space_before_array_rank_parentheses`	数组 - 数组维度括号前 (VB.NET)
`resharper_space_before_attribute_colon`	围绕冒号 - 在其他冒号之前 (C#)
`resharper_space_before_attribute_target_colon`	属性 - 属性目标冒号前 (VB.NET)
`resharper_space_before_catch_parentheses`	在语句中的括号之前 - 'catch' 括号 (C#)
`resharper_space_before_checked_parentheses`	在其他括号之前 - 'checked' 和 'unchecked' 括号 (C#)
`resharper_space_before_colon`	在冒号周围 - 在其他冒号之前（C#）
`resharper_space_before_colon_in_case`	在冒号周围 - 在 'case' 语句中的冒号之前，适用于： C#
`resharper_space_before_colon_in_inheritance_clause`	在冒号周围 - 在基类型列表冒号之前，适用于： C#
`resharper_space_before_comma`	逗号前空格（通用）
`resharper_space_before_default_parentheses`	在其他括号之前 - 'default' 括号（C#）
`resharper_space_before_empty_invocation_parentheses`	附近的括号 - 空调用括号前 (VB.NET)
`resharper_space_before_empty_method_call_parentheses`	在其他括号之前 - 方法调用的空括号，适用于： C#
`resharper_space_before_empty_method_parentheses`	在其他括号之前 - 方法声明的空括号，适用于： C#， VB.NET
`resharper_space_before_fixed_parentheses`	在语句中的括号之前 - 'fixed' 括号（C#）
`resharper_space_before_for_parentheses`	在语句中的括号之前 - 'for' 括号（C#）
`resharper_space_before_foreach_parentheses`	在语句中的括号之前 - 'foreach' 括号（C#）
`resharper_space_before_if_parentheses`	在语句中的括号之前 - 'if' 括号（C#）
`resharper_space_before_invocation_parentheses`	附近的括号 - 调用括号前 (VB.NET)
`resharper_space_before_label_colon`	其他 - 标签中的 ':' 前 (VB.NET)
`resharper_space_before_lock_parentheses`	在语句中的括号之前 - 'lock' 括号（C#）
`resharper_space_before_method_call_parentheses`	在其他括号之前 - 方法调用括号，适用于： C#
`resharper_space_before_method_parentheses`	在其他括号之前 - 方法声明括号，适用于： C#， VB.NET
`resharper_space_before_nameof_parentheses`	在其他括号之前 - 'nameof' 括号 (C#)
`resharper_space_before_new_parentheses`	在其他括号之前 - 'new' 括号 (C#)
`resharper_space_before_nullable_mark`	其他 - 在可空标记之前（C#）
`resharper_space_before_open_square_brackets`	括号前的空格（通用）
`resharper_space_before_pointer_asterik_declaration`	其他 - 在不安全指针声明之前（C#）
`resharper_space_before_property_colon`	属性 - 在冒号之前，适用于：
`resharper_space_before_self_closing`	在标签头部内部 - 在 '/>' 之前的空格，适用于：
`resharper_space_before_semicolon`	在逗号和分号周围 - 在分号之前，适用于： C#
`resharper_space_before_semicolon_in_for_statement`	逗号和分号周围 - 在 'for' 分号之前，可用于： C#
`resharper_space_before_singleline_accessorholder`	围绕大括号 - 在单行访问器块之前 (C#)
`resharper_space_before_sizeof_parentheses`	在其他括号之前 - 'sizeof' 括号 (C#)
`resharper_space_before_switch_parentheses`	语句中括号之前 - 'switch' 括号（C#）
`resharper_space_before_ternary_colon`	三元运算符中 - 在 ':' 之前，可用于： C#
`resharper_space_before_ternary_quest`	三元运算符中 - 在 '?' 之前，可用于： C#
`resharper_space_before_trailing_comment`	其他 - 在行尾注释之前，可用于： C#
`resharper_space_before_type_argument_angle`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`resharper_space_before_type_parameter_angle`	尖括号周围 - 在类型参数列表的尖括号之前 (C#)
`resharper_space_before_type_parameter_constraint_colon`	冒号周围 - 在类型参数约束冒号之前，可用于： C#
`resharper_space_before_type_parameter_parentheses`	附近的括号 - 类型参数括号前 (VB.NET)
`resharper_space_before_typeof_parentheses`	其他括号之前 - 'typeof' 括号（C#）
`resharper_space_before_using_parentheses`	语句中括号之前 - 'using' 括号（C#）
`resharper_space_before_while_parentheses`	语句中括号之前 - 'while' 括号（C#）
`resharper_space_between_accessors_in_singleline_property`	大括号周围 - 在单行属性/事件访问器之间 (C#)
`resharper_space_between_attribute_sections`	属性 - 在属性部分之间 (C#)
`resharper_space_between_empty_square_brackets`	数组括号周围 - 在数组维度空括号内，可用于： C#
`resharper_space_between_keyword_and_expression`	其他括号之前 - 关键字和表达式之间（C#）
`resharper_space_between_keyword_and_type`	其他括号之前 - 关键字和类型之间（C#）
`resharper_space_between_method_call_empty_parameter_list_parentheses`	其他括号内 - 方法调用空括号内，可用于： C#
`resharper_space_between_method_call_name_and_opening_parenthesis`	方法调用括号之前的空格 (通用)
`resharper_space_between_method_call_parameter_list_parentheses`	其他括号内 - 方法调用括号内，可用于： C#
`resharper_space_between_method_declaration_empty_parameter_list_parentheses`	其他括号内 - 方法声明空括号内，可用于： C#
`resharper_space_between_method_declaration_name_and_open_parenthesis`	方法声明括号之前的空格 (通用)
`resharper_space_between_method_declaration_parameter_list_parentheses`	其他括号内 - 方法声明括号内，可用于： C#
`resharper_space_between_parentheses_of_control_flow_statements`	控制流语句括号内的空格（通用）
`resharper_space_between_square_brackets`	括号内的空格 (通用)
`resharper_space_between_typecast_parentheses`	其他括号内 - 类型转换括号内，可用于： C#
`resharper_space_in_singleline_accessorholder`	大括号周围 - 在单行访问器内 (C#)
`resharper_space_in_singleline_anonymous_method`	大括号周围 - 在单行匿名方法内 (C#)
`resharper_space_in_singleline_method`	大括号周围 - 在单行方法内 (C#)
`resharper_space_near_postfix_and_prefix_op`	一元运算符之后 - ++ 和 -- 之前/之后（C#）
`resharper_space_within_array_access_brackets`	数组括号周围 - 在数组访问括号内，可用于： C#
`resharper_space_within_array_initialization_braces`	数组 - 在数组初始化大括号内 (VB.NET)
`resharper_space_within_array_rank_brackets`	数组括号周围 - 数组维度括号内（C#）
`resharper_space_within_array_rank_empty_brackets`	数组括号周围 - 在空数组维度括号内（C#）
`resharper_space_within_array_rank_empty_parentheses`	数组 - 在空数组维度括号内 (VB.NET)
`resharper_space_within_array_rank_parentheses`	数组 - 在数组维度括号内 (VB.NET)
`resharper_space_within_attribute_angles`	属性 - 在属性尖括号内 (VB.NET)
`resharper_space_within_attribute_brackets`	属性 - 属性括号内（C#）
`resharper_space_within_catch_parentheses`	语句中括号内 - 'catch' 括号（C#）
`resharper_space_within_checked_parentheses`	其他括号内 - 'checked' 和 'unchecked' 括号（C#）
`resharper_space_within_default_parentheses`	其他括号内 - 'default' 括号（C#）
`resharper_space_within_empty_braces`	大括号周围 - 空大括号之间的空格（C#）
`resharper_space_within_empty_invocation_parentheses`	附近的括号 - 在空调用括号内 (VB.NET)
`resharper_space_within_empty_method_parentheses`	附近的括号 - 在空方法声明括号内 (VB.NET)
`resharper_space_within_expression_parentheses`	表达式 - 在括号内，可用于：， VB.NET
`resharper_space_within_fixed_parentheses`	语句中括号内 - 'fixed' 括号（C#）
`resharper_space_within_for_parentheses`	语句中的括号内 - 'for' 括号 (C#)
`resharper_space_within_foreach_parentheses`	语句中的括号内 - 'foreach' 括号 (C#)
`resharper_space_within_if_parentheses`	语句中括号内 - 'if' 括号（C#）
`resharper_space_within_invocation_parentheses`	附近的括号 - 调用括号内 (VB.NET)
`resharper_space_within_list_pattern_brackets`	数组括号周围 - 列表模式和集合表达式括号内（C#）
`resharper_space_within_lock_parentheses`	语句中括号内 - 'lock' 括号（C#）
`resharper_space_within_method_parentheses`	附近的括号 - 方法声明括号内 (VB.NET)
`resharper_space_within_nameof_parentheses`	其他括号内 - 'nameof' 括号（C#）
`resharper_space_within_new_parentheses`	其他括号内 - 'new' 括号（C#）
`resharper_space_within_parentheses`	其他括号内 - 括号，适用于： C#
`resharper_space_within_single_line_array_initializer_braces`	大括号周围 - 单行表达式大括号内（C#）
`resharper_space_within_sizeof_parentheses`	其他括号内 - 'sizeof' 括号（C#）
`resharper_space_within_slice_pattern`	其他 - 切片模式中 '..' 之后（C#）
`resharper_space_within_switch_parentheses`	语句中括号内 - 'switch' 括号（C#）
`resharper_space_within_tuple_parentheses`	附近的括号 - 元组括号内 (VB.NET)
`resharper_space_within_type_argument_angles`	尖括号周围 - 类型参数尖括号（C#）
`resharper_space_within_type_parameter_angles`	尖括号周围 - 类型形参尖括号（C#）
`resharper_space_within_type_parameter_parentheses`	附近括号 - 类型参数括号内 (VB.NET)
`resharper_space_within_typeof_parentheses`	其他括号内 - 'typeof' 括号（C#）
`resharper_space_within_using_parentheses`	语句中括号内 - 'using' 括号（C#）
`resharper_space_within_while_parentheses`	语句中括号内 - 'while' 括号（C#）
`resharper_spaces_around_eq_in_attribute`	标签头部内部 - 属性中 '=' 周围的空格，适用于：
`resharper_spaces_around_eq_in_pi_attribute`	处理指令 - 属性中 '=' 周围的空格，适用于：
`resharper_spaces_inside_tags`	标签内容 - 起始标签后和结束标签前的空格，适用于：
`resharper_special_else_if_treatment`	通用 - 特殊 'else if' 处理，适用于： C#
`resharper_specify_a_culture_in_string_conversion_explicitly_highlighting`	代码检查：显式指定字符串区域性
`resharper_specify_string_comparison_highlighting`	代码检查：显式指定字符串比较
`resharper_specify_variable_type_explicitly_highlighting`	代码检查：可以显式指定变量类型
`resharper_spin_lock_in_readonly_field_highlighting`	代码检查：不要在只读字段中存储 SpinLock
`resharper_stack_alloc_inside_loop_highlighting`	代码检查：在循环中使用 stackalloc
`resharper_statement_termination_highlighting`	代码检查：语句终止符不符合代码样式设置
`resharper_static_member_in_generic_type_highlighting`	代码检查：泛型类型中的静态字段或自动属性
`resharper_static_member_initializer_referes_to_member_below_highlighting`	代码检查：静态成员初始化器引用了下面或其他部分的静态成员
`resharper_static_members_qualify_members`	静态成员限定 - 需要限定的成员（C#）
`resharper_static_members_qualify_with`	静态成员限定 - 使用名称限定（C#）
`resharper_static_problem_in_text_highlighting`	代码检查：无法访问文本参数中的静态符号
`resharper_stick_comment`	其他缩进 - 不缩进从第一列开始的注释，适用于： C#， VB.NET
`resharper_string_compare_is_culture_specific_1_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string) 是特定于文化的）
`resharper_string_compare_is_culture_specific_2_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string, bool) 是特定于文化的）
`resharper_string_compare_is_culture_specific_3_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string, bool) 是特定于文化的）
`resharper_string_compare_is_culture_specific_4_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int) 是特定于文化的）
`resharper_string_compare_is_culture_specific_5_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的）
`resharper_string_compare_is_culture_specific_6_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的）
`resharper_string_compare_to_is_culture_specific_highlighting`	代码检查： String.CompareTo 是特定于文化的
`resharper_string_concatenation_to_template_string_highlighting`	代码检查：字符串连接可以转换为模板字符串
`resharper_string_ends_with_is_culture_specific_highlighting`	代码检查： String.EndsWith 是特定于文化的（string.EndsWith(string) 是特定于文化的）
`resharper_string_index_of_is_culture_specific_1_highlighting`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string) 是特定于文化的）
`resharper_string_index_of_is_culture_specific_2_highlighting`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string, int) 是特定于文化的）
`resharper_string_index_of_is_culture_specific_3_highlighting`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string, int) 是特定于文化的）
`resharper_string_last_index_of_is_culture_specific_1_highlighting`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string) 是特定于文化的）
`resharper_string_last_index_of_is_culture_specific_2_highlighting`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string, int) 是特定于文化的）
`resharper_string_last_index_of_is_culture_specific_3_highlighting`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string, int) 是特定于文化的）
`resharper_string_literal_as_interpolation_argument_highlighting`	代码检查：字符串字面量可以内联
`resharper_string_literal_typo_highlighting`	代码检查：字符串字面量中有拼写错误
`resharper_string_literal_wrong_quotes_highlighting`	代码检查：字符串字面量周围的引号不符合规范
`resharper_string_starts_with_is_culture_specific_highlighting`	代码检查： String.StartsWith 是特定于文化的（string.StartsWith(string) 是特定于文化的）
`resharper_struct_can_be_made_read_only_highlighting`	代码检查：结构体可以声明为 readonly
`resharper_struct_member_can_be_made_read_only_highlighting`	代码检查：结构体成员可以声明为 readonly
`resharper_structured_message_template_problem_highlighting`	代码检查：结构化消息模板存在问题
`resharper_suggest_base_type_for_parameter_highlighting`	代码检查：参数可以声明为基类型
`resharper_suggest_base_type_for_parameter_in_constructor_highlighting`	代码检查：参数可以声明为基类型
`resharper_suggest_discard_declaration_var_style_highlighting`	代码检查：使用首选的丢弃声明样式
`resharper_suggest_var_or_type_built_in_types_highlighting`	代码检查：使用首选的 'var' 样式（针对内置类型）
`resharper_suggest_var_or_type_deconstruction_declarations_highlighting`	代码检查：使用首选的 'var' 样式（在解构声明中）
`resharper_suggest_var_or_type_elsewhere_highlighting`	代码检查：使用首选的 'var' 样式（其他地方）
`resharper_suggest_var_or_type_simple_types_highlighting`	代码检查：使用首选的 'var' 样式（当类型简单时）
`resharper_super_call_highlighting`	代码检查：父类调用可以转换为 super 调用
`resharper_super_call_prohibits_this_highlighting`	代码检查：在派生类的构造函数中，必须在访问 'this' 之前调用 'super'
`resharper_suppress_nullable_warning_expression_as_inverted_is_expression_highlighting`	代码检查：可空警告抑制运算符可能与反转的 'is' 表达式混淆
`resharper_suspicious_instanceof_check_highlighting`	代码检查：可疑的 'instanceof' 检查
`resharper_suspicious_lambda_block_highlighting`	代码检查：可能的错误：模糊的 lambda 块和对象字面量
`resharper_suspicious_lock_over_synchronization_primitive_highlighting`	代码检查：在同步原语上的可疑锁定
`resharper_suspicious_math_sign_method_highlighting`	代码检查： Math.Sign() 方法始终返回相同的结果
`resharper_suspicious_parameter_name_in_argument_null_exception_highlighting`	代码检查： ArgumentNullException 中的参数名称可疑
`resharper_suspicious_this_usage_highlighting`	代码检查：在类成员内的局部函数上下文中对 'this' 的可疑使用
`resharper_suspicious_type_conversion_global_highlighting`	代码检查：可疑的类型转换或检查
`resharper_suspicious_typeof_check_highlighting`	代码检查：可疑的 'typeof' 检查
`resharper_swap_via_deconstruction_highlighting`	代码检查：使用解构来交换变量
`resharper_switch_expression_handles_some_known_enum_values_with_exception_in_default_highlighting`	代码检查：枚举的一些值未在 'switch' 表达式中处理，而是通过默认分支中的异常处理
`resharper_switch_statement_handles_some_known_enum_values_with_default_highlighting`	代码检查：枚举的一些值未在 'switch' 语句中处理，而是通过默认部分处理
`resharper_switch_statement_missing_some_enum_cases_no_default_highlighting`	代码检查：枚举的一些值未在 'switch' 语句中处理
`resharper_symbol_from_not_copied_locally_reference_used_warning_highlighting`	代码检查：模块中的符号可能在运行时丢失
`resharper_tabs_and_spaces_mismatch_highlighting`	代码检查：缩进不正确（制表符/空格不匹配）
`resharper_tabs_are_disallowed_highlighting`	代码检查：禁止使用制表符进行缩进
`resharper_tabs_outside_indent_highlighting`	代码检查：间距不正确（此处禁止使用制表符）
`resharper_tail_recursive_call_highlighting`	代码检查：尾递归调用可以替换为循环
`resharper_tasks_not_loaded_highlighting`	代码检查：未知的任务程序集
`resharper_ternary_can_be_replaced_by_its_condition_highlighting`	代码检查：三元运算符可以用其条件替换
`resharper_this_in_global_context_highlighting`	代码检查：在全局上下文中使用 'this'
`resharper_thread_static_at_instance_field_highlighting`	代码检查： [ThreadStatic] 无法与实例字段一起使用
`resharper_thread_static_field_has_initializer_highlighting`	代码检查：线程静态字段具有初始化器
`resharper_throw_must_be_followed_by_expression_highlighting`	代码检查： 'throw' 语句后需要表达式
`resharper_too_wide_local_variable_scope_highlighting`	代码检查：局部变量的声明范围过宽
`resharper_trailing_comma_in_multiline_lists`	尾随逗号 - 多行列表中新行前 (C#)
`resharper_trailing_comma_in_singleline_lists`	尾随逗号 - 当最后一个元素后没有换行时（C#）
`resharper_try_cast_always_succeeds_highlighting`	代码检查：安全类型转换表达式始终成功
`resharper_try_statements_can_be_merged_highlighting`	代码检查： try-catch 和 try-finally 语句可以合并
`resharper_ts_not_resolved_highlighting`	代码检查：使用未声明的变量
`resharper_ts_resolved_from_inaccessible_module_highlighting`	代码检查：无法解析，可能符号位于不可访问的模块中
`resharper_type_declaration_braces`	大括号布局 - 类型和命名空间声明，适用于： C#
`resharper_type_guard_doesnt_affect_anything_highlighting`	代码检查：类型保护对变量的类型没有任何影响
`resharper_type_guard_produces_never_type_highlighting`	代码检查：类型保护明确为变量生成了 'never' 类型
`resharper_type_parameter_can_be_variant_highlighting`	代码检查：类型参数可以声明为协变或逆变
`resharper_type_parameter_hides_type_param_from_outer_scope_highlighting`	代码检查：类型参数隐藏了外部作用域中声明的类型参数
`resharper_unassigned_field_compiler_highlighting`	代码检查：未赋值的字段
`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_unused_member_local_highlighting`	代码检查：类型成员从未使用过（私有可访问性）
`resharper_unused_method_return_value_global_highlighting`	代码检查：方法返回值从未使用过（非私有可访问性）
`resharper_unused_method_return_value_local_highlighting`	代码检查：方法返回值从未使用过（私有可访问性）
`resharper_unused_nullable_directive_highlighting`	代码检查：未使用的可空指令
`resharper_unused_parameter_global_highlighting`	代码检查：未使用的参数（非私有可访问性）
`resharper_unused_parameter_highlighting`	代码检查：未使用的参数
`resharper_unused_parameter_in_partial_method_highlighting`	代码检查：部分方法中的未使用参数
`resharper_unused_parameter_local_highlighting`	代码检查：未使用的参数（私有可访问性）
`resharper_unused_positional_parameter_compiler_highlighting`	代码检查：未使用的位置参数
`resharper_unused_property_highlighting`	代码检查：未使用的属性或函数
`resharper_unused_tuple_component_in_return_value_highlighting`	代码检查：元组的组件从未使用过
`resharper_unused_type_global_highlighting`	代码检查：类型从未使用过（非私有可访问性）
`resharper_unused_type_local_highlighting`	代码检查：类型从未使用过（私有可访问性）
`resharper_unused_type_parameter_highlighting`	代码检查：未使用的类型参数
`resharper_unused_variable_compiler_highlighting`	代码检查：未使用的局部变量
`resharper_unused_variable_highlighting`	代码检查：未使用的局部变量
`resharper_usage_of_definitely_unassigned_value_highlighting`	代码检查：使用未赋值的局部变量
`resharper_usage_of_possibly_unassigned_value_highlighting`	代码检查：使用可能未赋值的局部变量
`resharper_use_array_creation_expression_1_highlighting`	代码检查：使用数组创建表达式
`resharper_use_array_creation_expression_2_highlighting`	代码检查：使用数组创建表达式
`resharper_use_array_empty_method_highlighting`	代码检查：使用 'Array.Empty<T>()'
`resharper_use_as_instead_of_type_cast_highlighting`	代码检查：使用 'as' 运算符代替类型断言
`resharper_use_await_using_highlighting`	代码检查：转换为 'await using' 语句或声明
`resharper_use_cancellation_token_for_i_async_enumerable_highlighting`	代码检查：使用取消令牌
`resharper_use_collection_count_property_highlighting`	代码检查：使用集合的 count 属性
`resharper_use_collection_expression_highlighting`	代码检查：使用集合表达式语法
`resharper_use_configure_await_false_for_async_disposable_highlighting`	代码检查：在库代码中缺少 '.ConfigureAwait(false)' 用于异步可释放对象
`resharper_use_configure_await_false_highlighting`	代码检查：在库代码中缺少 '.ConfigureAwait(false)'
`resharper_use_continuous_indent_inside_initializer_braces`	大括号布局 - 在表达式大括号内使用连续行缩进（C#）
`resharper_use_continuous_indent_inside_parens`	括号 - 在括号内使用连续行缩进 (C#)
`resharper_use_deconstruction_highlighting`	代码检查：使用解构
`resharper_use_discard_assignment_highlighting`	代码检查：使用丢弃赋值
`resharper_use_empty_types_field_highlighting`	代码检查：使用 'Type.EmptyTypes'
`resharper_use_event_args_empty_field_highlighting`	代码检查：使用 'EventArgs.Empty'
`resharper_use_format_specifier_in_format_string_highlighting`	代码检查：在格式字符串中使用格式说明符
`resharper_use_heuristics_for_body_style`	代码主体 - 应用样式启发式规则（C#）
`resharper_use_implicit_by_val_modifier_highlighting`	代码检查：使用隐式 'ByVal' 修饰符
`resharper_use_implicitly_typed_variable_evident_highlighting`	代码检查：使用隐式类型变量声明（显而易见）
`resharper_use_implicitly_typed_variable_highlighting`	代码检查：使用隐式类型变量声明
`resharper_use_indent_from_previous_element`	其他缩进 - 在部分格式中使用前一个元素的缩进 (C#)
`resharper_use_index_from_end_expression_highlighting`	代码检查：使用从末尾表达式的索引
`resharper_use_indexed_property_highlighting`	代码检查：使用索引属性
`resharper_use_is_operator_1_highlighting`	代码检查：使用 'is' 运算符
`resharper_use_is_operator_2_highlighting`	代码检查：使用 'is' 运算符
`resharper_use_method_any_0_highlighting`	代码检查：请改用方法 Any()
`resharper_use_method_any_1_highlighting`	代码检查：请改用方法 Any()
`resharper_use_method_any_2_highlighting`	代码检查：请改用方法 Any()
`resharper_use_method_any_3_highlighting`	代码检查：请改用方法 Any()
`resharper_use_method_any_4_highlighting`	代码检查：请改用方法 Any()
`resharper_use_method_is_instance_of_type_highlighting`	代码检查：请改用方法 IsInstanceOfType(..)
`resharper_use_name_of_instead_of_type_of_highlighting`	代码检查：使用 'nameof' 表达式引用类型名称
`resharper_use_nameof_expression_for_part_of_the_string_highlighting`	代码检查：使用 'nameof' 表达式在字符串字面量的一部分中引用名称
`resharper_use_nameof_expression_highlighting`	代码检查：使用 'nameof' 表达式引用名称
`resharper_use_nameof_for_dependency_property_highlighting`	代码检查：在注册 DependencyProperty 时使用 'nameof' 表达式
`resharper_use_negated_pattern_in_is_expression_highlighting`	代码检查：将取反的 'is' 表达式转换为带有取反模式的 'is' 表达式
`resharper_use_negated_pattern_matching_highlighting`	代码检查：将 'as' 表达式类型检查和后续的空检查转换为取反模式匹配
`resharper_use_null_propagation_highlighting`	代码检查：用空传播代码替换 if 语句
`resharper_use_nullable_annotation_instead_of_attribute_highlighting`	代码检查：使用可空注解代替属性
`resharper_use_nullable_attributes_supported_by_compiler_highlighting`	代码检查：使用编译器支持的可空属性
`resharper_use_nullable_reference_types_annotation_syntax_highlighting`	代码检查：使用类型注解语法
`resharper_use_object_or_collection_initializer_highlighting`	代码检查：在可能的情况下使用对象或集合初始化器
`resharper_use_of_implicit_global_in_function_scope_highlighting`	代码检查：使用隐式声明的全局变量
`resharper_use_of_possibly_unassigned_property_highlighting`	代码检查：在静态初始化器中使用可能未赋值的属性
`resharper_use_old_engine`	为 Razor 格式化使用旧引擎（Razor CSharp）
`resharper_use_pattern_matching_highlighting`	代码检查：将 'as' 表达式类型检查和后续的空检查转换为模式匹配
`resharper_use_positional_deconstruction_pattern_highlighting`	代码检查：使用位置解构模式
`resharper_use_raw_string_highlighting`	代码检查：使用原始字符串
`resharper_use_roslyn_logic_for_evident_types`	声明中 'var' 的使用 - 偏好 Roslyn (Visual Studio) 的类型推断逻辑 (C#)
`resharper_use_string_interpolation_highlighting`	代码检查：使用字符串插值表达式
`resharper_use_switch_case_pattern_variable_highlighting`	代码检查：类型模式和强制转换可以合并
`resharper_use_symbol_alias_highlighting`	代码检查：使用别名
`resharper_use_throw_if_null_method_highlighting`	代码检查：使用 'ArgumentNullException.ThrowIfNull'
`resharper_use_unsigned_right_shift_operator_highlighting`	代码检查：使用无符号右移运算符 '>>>'
`resharper_use_utf8_string_literal_highlighting`	代码检查：使用 UTF-8 字符串字面量
`resharper_use_verbatim_string_highlighting`	代码检查：通过使用逐字字符串减少字面量长度
`resharper_use_with_expression_to_copy_anonymous_object_highlighting`	代码检查：使用 'with' 表达式复制匿名对象
`resharper_use_with_expression_to_copy_record_highlighting`	代码检查：使用 'with' 表达式复制记录
`resharper_use_with_expression_to_copy_struct_highlighting`	代码检查：使用 'with' 表达式复制结构体
`resharper_use_with_expression_to_copy_tuple_highlighting`	代码检查：使用 'with' 表达式复制元组
`resharper_useless_binary_operation_highlighting`	代码检查：无用的算术运算
`resharper_useless_comparison_to_integral_constant_highlighting`	代码检查：与整数常量的比较是无用的
`resharper_using_of_reserved_word_error_highlighting`	代码检查：在“严格模式”中使用未来保留关键字
`resharper_using_of_reserved_word_highlighting`	代码检查：使用未来保留字
`resharper_using_statement_resource_initialization_expression_highlighting`	代码检查：不要为“using”变量使用对象初始化器（对象初始化器表达式在初始化“using”变量时可能抛出异常）
`resharper_using_statement_resource_initialization_highlighting`	代码检查：不要为“using”变量使用对象初始化器
`resharper_value_parameter_not_used_highlighting`	代码检查： “value”参数未被使用
`resharper_value_range_attribute_violation_highlighting`	代码检查：可能违反“ValueRange”/“NonNegativeValue”属性
`resharper_variable_can_be_made_const_highlighting`	代码检查：变量可以声明为常量
`resharper_variable_can_be_made_let_highlighting`	代码检查： “var”变量可以改为“let”变量
`resharper_variable_can_be_moved_to_inner_block_highlighting`	代码检查：局部变量可以安全地移动到内部块
`resharper_variable_can_be_not_nullable_highlighting`	代码检查：变量可以声明为非空
`resharper_variable_hides_outer_variable_highlighting`	代码检查：局部函数中的变量隐藏了外部作用域的变量
`resharper_variable_used_before_declared_highlighting`	代码检查：变量在声明之前被使用
`resharper_variable_used_in_inner_scope_before_declared_highlighting`	代码检查：变量在内部作用域中被使用时尚未声明
`resharper_variable_used_out_of_scope_highlighting`	代码检查：变量在声明的作用域之外被使用
`resharper_vb_align_multiline_argument`	对齐多行结构 - 调用参数 (VB.NET)
`resharper_vb_align_multiline_array_initializer`	对齐多行结构 - 数组初始化器（VB.NET）
`resharper_vb_align_multiline_expression`	对齐多行结构 - 表达式 (VB.NET)
`resharper_vb_align_multiline_implements_list`	对齐多行结构 - Implements/handles 列表 (VB.NET)
`resharper_vb_align_multiline_parameter`	对齐多行结构 - 方法参数 (VB.NET)
`resharper_vb_align_multiple_declaration`	对齐多行结构 - 多声明列表 (VB.NET)
`resharper_vb_alignment_tab_fill_style`	制表符和缩进 - 使用制表符缩进时的对齐方式 (VB.NET)
`resharper_vb_allow_alias`	引用限定 - 允许 'Imports' 别名指令 (VB.NET)
`resharper_vb_blank_lines_after_imports`	空行 - 在 Imports 部分之后 (VB.NET)
`resharper_vb_blank_lines_after_options`	空行 - 在文件选项部分之后（VB.NET）
`resharper_vb_blank_lines_around_field`	空行 - 在多行字段周围 (VB.NET)
`resharper_vb_blank_lines_around_global_attribute`	空行 - 在全局属性之后（VB.NET）
`resharper_vb_blank_lines_around_invocable`	空行 - 在多行方法周围 (VB.NET)
`resharper_vb_blank_lines_around_namespace`	空行 - 在命名空间周围 (VB.NET)
`resharper_vb_blank_lines_around_region`	空行 - 区域周围 (VB.NET)
`resharper_vb_blank_lines_around_single_line_field`	空行 - 单行字段周围 (VB.NET)
`resharper_vb_blank_lines_around_single_line_invocable`	空行 - 单行方法周围 (VB.NET)
`resharper_vb_blank_lines_around_type`	空行 - 类型周围 (VB.NET)
`resharper_vb_blank_lines_inside_region`	空行 - 区域内部 (VB.NET)
`resharper_vb_check_for_reference_equality_instead_1_highlighting`	代码检查：检查引用相等性
`resharper_vb_check_for_reference_equality_instead_2_highlighting`	代码检查：检查引用相等性
`resharper_vb_indent_case_from_select`	其他 - 将“case”缩进到“select”（VB.NET）
`resharper_vb_indent_size`	制表符和缩进 - 缩进大小（VB.NET）
`resharper_vb_indent_style`	制表符和缩进 - 缩进样式 (VB.NET)
`resharper_vb_keep_blank_lines_in_code`	保留现有格式 - 保留代码中的最大空行数 (VB.NET)
`resharper_vb_keep_blank_lines_in_declarations`	保留现有格式 - 保留声明中的最大空行数 (VB.NET)
`resharper_vb_keep_user_linebreaks`	保留现有格式 - 保留现有换行符 (VB.NET)
`resharper_vb_max_line_length`	换行 - 硬换行位置 (VB.NET)
`resharper_vb_place_event_attribute_on_same_line`	属性 - 将事件属性放在同一行 (VB.NET)
`resharper_vb_place_field_attribute_on_same_line`	属性 - 将字段属性放在同一行 (VB.NET)
`resharper_vb_place_method_attribute_on_same_line`	属性 - 将方法属性放在同一行（VB.NET）
`resharper_vb_place_property_attribute_on_same_line`	属性 - 将属性属性放在同一行（VB.NET）
`resharper_vb_place_type_attribute_on_same_line`	属性 - 将类型属性放在同一行（VB.NET）
`resharper_vb_possible_mistaken_argument_highlighting`	代码检查：可能的错误参数
`resharper_vb_possible_mistaken_call_to_get_type_1_highlighting`	代码检查：可能错误地调用了 GetType()
`resharper_vb_possible_mistaken_call_to_get_type_2_highlighting`	代码检查：可能错误地调用了 GetType()
`resharper_vb_prefer_qualified_reference`	引用限定 - 优先使用完全限定引用 (VB.NET)
`resharper_vb_remove_to_list_1_highlighting`	代码检查：移除 ToList()
`resharper_vb_remove_to_list_2_highlighting`	代码检查：移除 ToList()
`resharper_vb_replace_with_first_or_default_highlighting`	代码检查：替换为 FirstOrDefault($args$)
`resharper_vb_replace_with_last_or_default_highlighting`	代码检查：替换为 LastOrDefault($args$)
`resharper_vb_replace_with_of_type_1_highlighting`	代码检查：替换为 OfType<T>()（替换为 OfType(Of ..)()）
`resharper_vb_replace_with_of_type_2_highlighting`	代码检查：替换为 OfType<T>()（替换为 OfType(Of ..)()）
`resharper_vb_replace_with_of_type_any_1_highlighting`	代码检查：替换为 OfType<T>().Any()（替换为 OfType(Of ..)().Any()）
`resharper_vb_replace_with_of_type_any_2_highlighting`	代码检查：替换为 OfType<T>().Any()（替换为 OfType(Of ..)().Any(..)）
`resharper_vb_replace_with_of_type_count_1_highlighting`	代码检查：替换为 OfType<T>().Count()（替换为 OfType(Of ..)().Count()）
`resharper_vb_replace_with_of_type_count_2_highlighting`	代码检查：替换为 OfType<T>().Count()（替换为 OfType(Of ..)().Count(..)）
`resharper_vb_replace_with_of_type_first_1_highlighting`	代码检查：替换为 OfType<T>().First()（替换为 OfType(Of ..)().First()）
`resharper_vb_replace_with_of_type_first_2_highlighting`	代码检查：替换为 OfType<T>().First()（替换为 OfType(Of ..)().First(..)）
`resharper_vb_replace_with_of_type_first_or_default_1_highlighting`	代码检查：替换为 OfType<T>().FirstOrDefault()（替换为 OfType(Of ..)().FirstOrDefault()）
`resharper_vb_replace_with_of_type_first_or_default_2_highlighting`	代码检查：替换为 OfType<T>().FirstOrDefault()（替换为 OfType(Of ..)().FirstOrDefault(..)）
`resharper_vb_replace_with_of_type_last_1_highlighting`	代码检查：替换为 OfType<T>().Last()（替换为 OfType(Of ..)().Last()）
`resharper_vb_replace_with_of_type_last_2_highlighting`	代码检查：替换为 OfType<T>().Last()（替换为 OfType(Of ..)().Last(..)）
`resharper_vb_replace_with_of_type_last_or_default_1_highlighting`	代码检查：替换为 OfType<T>().LastOrDefault()（替换为 OfType(Of ..)().LastOrDefault()）
`resharper_vb_replace_with_of_type_last_or_default_2_highlighting`	代码检查：替换为 OfType<T>().LastOrDefault()（替换为 OfType(Of ..)().LastOrDefault(..)）
`resharper_vb_replace_with_of_type_single_1_highlighting`	代码检查：替换为 OfType<T>().Single()（替换为 OfType(Of ..)().Single()）
`resharper_vb_replace_with_of_type_single_2_highlighting`	代码检查：替换为 OfType<T>().Single()（替换为 OfType(Of ..)().Single(..)）
`resharper_vb_replace_with_of_type_single_or_default_1_highlighting`	代码检查：替换为 OfType<T>().SingleOrDefault()（替换为 OfType(Of ..)().SingleOrDefault()）
`resharper_vb_replace_with_of_type_single_or_default_2_highlighting`	代码检查：替换为 OfType<T>().SingleOrDefault()（替换为 OfType(Of ..)().SingleOrDefault(..)）
`resharper_vb_replace_with_of_type_where_highlighting`	代码检查：替换为 OfType<T>().Where()（替换为 OfType(Of ..)().Where(..)）
`resharper_vb_replace_with_single_assignment_1_highlighting`	代码检查：替换为单一赋值
`resharper_vb_replace_with_single_assignment_2_highlighting`	代码检查：替换为单一赋值
`resharper_vb_replace_with_single_call_to_any_highlighting`	代码检查：替换为单次调用 Any(..)
`resharper_vb_replace_with_single_call_to_count_highlighting`	代码检查：替换为单次调用 Count(..)
`resharper_vb_replace_with_single_call_to_first_highlighting`	代码检查：替换为单次调用 First(..)
`resharper_vb_replace_with_single_call_to_first_or_default_highlighting`	代码检查：替换为单次调用 FirstOrDefault(..)
`resharper_vb_replace_with_single_call_to_last_highlighting`	代码检查：替换为单次调用 Last(..)
`resharper_vb_replace_with_single_call_to_last_or_default_highlighting`	代码检查：替换为单次调用 LastOrDefault(..)
`resharper_vb_replace_with_single_call_to_single_highlighting`	代码检查：替换为单次调用 Single(..)
`resharper_vb_replace_with_single_call_to_single_or_default_highlighting`	代码检查：替换为单次调用 SingleOrDefault(..)
`resharper_vb_replace_with_single_or_default_highlighting`	代码检查：替换为 SingleOrDefault($args$)
`resharper_vb_simplify_linq_expression_1_highlighting`	代码检查：简化表达式
`resharper_vb_simplify_linq_expression_10_highlighting`	代码检查：简化表达式
`resharper_vb_simplify_linq_expression_2_highlighting`	代码检查：简化表达式
`resharper_vb_simplify_linq_expression_3_highlighting`	代码检查：简化表达式
`resharper_vb_simplify_linq_expression_4_highlighting`	代码检查：简化表达式
`resharper_vb_simplify_linq_expression_5_highlighting`	代码检查：简化表达式
`resharper_vb_simplify_linq_expression_6_highlighting`	代码检查：简化表达式
`resharper_vb_simplify_linq_expression_7_highlighting`	代码检查：简化表达式
`resharper_vb_simplify_linq_expression_8_highlighting`	代码检查：简化表达式
`resharper_vb_simplify_linq_expression_9_highlighting`	代码检查：简化表达式
`resharper_vb_space_after_attribute_target_colon`	属性 - 属性目标冒号后 (VB.NET)
`resharper_vb_space_after_comma`	其他 - 逗号后（VB.NET）
`resharper_vb_space_after_unary_op`	操作周围 - 一元运算符之后 (VB.NET)
`resharper_vb_space_after_unary_operator`	操作周围 - 一元运算符之后 (VB.NET)
`resharper_vb_space_around_additive_op`	操作周围 - 加法运算符（+，-） (VB.NET)
`resharper_vb_space_around_assignment_op`	操作周围 - 赋值运算符 (如 '=' 和 '+=') (VB.NET)
`resharper_vb_space_around_binary_operator`	在二元运算符周围的空格（+，\|\|，=，...）（通用）
`resharper_vb_space_around_dot`	其他 - '.' 周围 (VB.NET)
`resharper_vb_space_around_member_access_operator`	其他 - '.' 周围 (VB.NET)
`resharper_vb_space_around_multiplicative_op`	操作周围 - 乘法运算符 (如 '*' 和 '/') (VB.NET)
`resharper_vb_space_around_relational_op`	操作周围 - 关系运算符（<，>，<=，>=） (VB.NET)
`resharper_vb_space_around_shift_op`	操作周围 - 移位运算符（<<，>>） (VB.NET)
`resharper_vb_space_around_stmt_colon`	其他 - 在语句 ':' 周围（VB.NET）
`resharper_vb_space_before_array_rank_parentheses`	数组 - 数组维度括号前 (VB.NET)
`resharper_vb_space_before_attribute_target_colon`	属性 - 属性目标冒号前 (VB.NET)
`resharper_vb_space_before_comma`	其他 - ',' 之前 (VB.NET)
`resharper_vb_space_before_empty_invocation_parentheses`	附近的括号 - 空调用括号前 (VB.NET)
`resharper_vb_space_before_empty_method_parentheses`	附近的括号 - 空方法声明括号前 (VB.NET)
`resharper_vb_space_before_invocation_parentheses`	附近的括号 - 调用括号前 (VB.NET)
`resharper_vb_space_before_label_colon`	其他 - 标签中的 ':' 前 (VB.NET)
`resharper_vb_space_before_method_parentheses`	附近的括号 - 方法声明括号前 (VB.NET)
`resharper_vb_space_before_type_parameter_parentheses`	附近的括号 - 类型参数括号前 (VB.NET)
`resharper_vb_space_within_array_initialization_braces`	数组 - 在数组初始化大括号内 (VB.NET)
`resharper_vb_space_within_array_rank_empty_parentheses`	数组 - 在空数组维度括号内 (VB.NET)
`resharper_vb_space_within_array_rank_parentheses`	数组 - 在数组维度括号内 (VB.NET)
`resharper_vb_space_within_attribute_angles`	属性 - 在属性尖括号内 (VB.NET)
`resharper_vb_space_within_empty_invocation_parentheses`	附近的括号 - 在空调用括号内 (VB.NET)
`resharper_vb_space_within_empty_method_parentheses`	附近的括号 - 在空方法声明括号内 (VB.NET)
`resharper_vb_space_within_expression_parentheses`	附近的括号 - 表达式括号内 (VB.NET)
`resharper_vb_space_within_invocation_parentheses`	附近的括号 - 调用括号内 (VB.NET)
`resharper_vb_space_within_method_parentheses`	附近的括号 - 方法声明括号内 (VB.NET)
`resharper_vb_space_within_tuple_parentheses`	附近的括号 - 元组括号内 (VB.NET)
`resharper_vb_space_within_type_parameter_parentheses`	附近括号 - 类型参数括号内 (VB.NET)
`resharper_vb_stick_comment`	其他 - 不缩进从第一列开始的注释 (VB.NET)
`resharper_vb_string_compare_is_culture_specific_1_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string) 是特定于文化的）
`resharper_vb_string_compare_is_culture_specific_2_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string, bool) 是特定于文化的）
`resharper_vb_string_compare_is_culture_specific_3_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, string, bool) 是特定于文化的）
`resharper_vb_string_compare_is_culture_specific_4_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int) 是特定于文化的）
`resharper_vb_string_compare_is_culture_specific_5_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的）
`resharper_vb_string_compare_is_culture_specific_6_highlighting`	代码检查： String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的）
`resharper_vb_string_compare_to_is_culture_specific_highlighting`	代码检查： String.CompareTo 是特定于文化的
`resharper_vb_string_ends_with_is_culture_specific_highlighting`	代码检查： String.EndsWith 是特定于文化的（string.EndsWith(string) 是特定于文化的）
`resharper_vb_string_index_of_is_culture_specific_1_highlighting`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string) 是特定于文化的）
`resharper_vb_string_index_of_is_culture_specific_2_highlighting`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string, int) 是特定于文化的）
`resharper_vb_string_index_of_is_culture_specific_3_highlighting`	代码检查： String.IndexOf 是特定于文化的（string.IndexOf(string, int) 是特定于文化的）
`resharper_vb_string_last_index_of_is_culture_specific_1_highlighting`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string) 是特定于文化的）
`resharper_vb_string_last_index_of_is_culture_specific_2_highlighting`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string, int) 是特定于文化的）
`resharper_vb_string_last_index_of_is_culture_specific_3_highlighting`	代码检查： String.LastIndexOf 是特定于文化的（string.LastIndexOf(string, int) 是特定于文化的）
`resharper_vb_string_starts_with_is_culture_specific_highlighting`	代码检查： String.StartsWith 是特定于文化的（string.StartsWith(string) 是特定于文化的）
`resharper_vb_tab_width`	制表符和缩进 - 制表符宽度 (VB.NET)
`resharper_vb_unreachable_code_highlighting`	代码检查：不可达代码
`resharper_vb_use_array_creation_expression_1_highlighting`	代码检查：使用数组创建表达式
`resharper_vb_use_array_creation_expression_2_highlighting`	代码检查：使用数组创建表达式
`resharper_vb_use_first_instead_highlighting`	代码检查：请改用 First()
`resharper_vb_use_method_any_1_highlighting`	代码检查：请改用方法 Any()
`resharper_vb_use_method_any_2_highlighting`	代码检查：请改用方法 Any()
`resharper_vb_use_method_any_3_highlighting`	代码检查：请改用方法 Any()
`resharper_vb_use_method_any_4_highlighting`	代码检查：请改用方法 Any()
`resharper_vb_use_method_any_5_highlighting`	代码检查：请改用方法 Any()
`resharper_vb_use_method_is_instance_of_type_highlighting`	代码检查：请改用方法 IsInstanceOfType(..)
`resharper_vb_use_type_of_is_operator_1_highlighting`	代码检查：请改用 'TypeOf .. Is ..' 运算符
`resharper_vb_use_type_of_is_operator_2_highlighting`	代码检查：请改用 'TypeOf .. Is ..' 运算符
`resharper_vb_warnings_bc40000_highlighting`	代码检查：请改用已过时的成员
`resharper_vb_warnings_bc400005_highlighting`	代码检查：成员遮蔽了可重写的成员
`resharper_vb_warnings_bc40008_highlighting`	代码检查：请改用已过时的成员（无消息）
`resharper_vb_warnings_bc40056_highlighting`	代码检查： Imports 'name' 中指定的命名空间或类型不包含任何公共成员或无法找到
`resharper_vb_warnings_bc42016_highlighting`	代码检查：将 X 转换为 Y 时可能会发生运行时错误
`resharper_vb_warnings_bc42025_highlighting`	代码检查：通过实例访问共享成员
`resharper_vb_warnings_bc42104_highlighting`	代码检查：变量在赋值前被使用
`resharper_vb_warnings_bc42105_bc42106_bc42107_highlighting`	代码检查：函数在所有代码路径上未返回引用类型值
`resharper_vb_warnings_bc42304_highlighting`	代码检查： XML 注释中存在语法错误
`resharper_vb_warnings_bc42309_highlighting`	代码检查： XML 注释中包含无法解析的带有 'cref' 属性的标签
`resharper_vb_warnings_bc42322_highlighting`	代码检查：将 X 转换为 Y 时可能会发生运行时错误
`resharper_vb_warnings_bc42349_highlighting`	代码检查：对等值类型的冗余 DirectCast
`resharper_vb_warnings_bc42353_bc42354_bc42355_highlighting`	代码检查：函数在所有代码路径上未返回结构值
`resharper_vb_warnings_bc42356_highlighting`	代码检查：异步方法缺少 'Await' 运算符
`resharper_vb_warnings_bc42358_highlighting`	代码检查：由于此调用未等待，当前方法的执行在调用完成之前继续。请考虑对调用结果应用 'Await' 运算符。
`resharper_vb_warnings_bc42504_highlighting`	代码检查：应用于参数的 CallerArgumentExpressionAttribute 无效，因为它是自引用的
`resharper_vb_warnings_bc42505_highlighting`	代码检查：应用于参数的 CallerArgumentExpressionAttribute 无效。它使用了无效的参数名称。
`resharper_vb_warnings_wme006_highlighting`	代码检查：命名空间应为此项目的默认命名空间
`resharper_vb_wrap_arguments_style`	换行 - 换行调用参数 (VB.NET)
`resharper_vb_wrap_before_binary_opsign`	换行 - 优先在二元表达式中的运算符前换行 (VB.NET)
`resharper_vb_wrap_before_declaration_lpar`	换行 - 优先在方法声明中的 '(' 前换行 (VB.NET)
`resharper_vb_wrap_before_invocation_lpar`	换行 - 优先在调用中的 '(' 前换行 (VB.NET)
`resharper_vb_wrap_extends_list_style`	换行 - 换行扩展/实现/处理列表 (VB.NET)
`resharper_vb_wrap_multiple_declaration_style`	换行 - 包装多个声明列表 (VB.NET)
`resharper_vb_wrap_parameters_style`	换行 - 包装形式参数 (VB.NET)
`resharper_virtual_member_call_in_constructor_highlighting`	代码检查：构造函数中的虚成员调用
`resharper_virtual_member_never_overridden_global_highlighting`	代码检查：虚（可重写）成员从未被重写（非私有访问权限）
`resharper_virtual_member_never_overridden_local_highlighting`	代码检查：虚（可重写）成员从未被重写（私有访问权限）
`resharper_void_method_with_must_dispose_resource_attribute_highlighting`	代码检查： 'void' 方法带有 [MustDisposeResource] 属性
`resharper_void_method_with_must_use_return_value_attribute_highlighting`	代码检查： 'void' 方法带有 [MustUseReturnValue] 属性
`resharper_vulnerable_api_highlighting`	代码检查：存在易受攻击的 API 用法
`resharper_vulnerable_package_highlighting`	代码检查： NuGet 包存在漏洞
`resharper_web_config_module_not_resolved_highlighting`	代码检查：无法解析模块
`resharper_web_config_module_qualification_resolve_highlighting`	代码检查：需要模块限定
`resharper_web_config_redundant_add_namespace_tag_highlighting`	代码检查：冗余的 add namespace 元素
`resharper_web_config_redundant_location_tag_highlighting`	代码检查：冗余的 location 元素
`resharper_web_config_tag_prefix_redundand_highlighting`	代码检查：冗余的 tagPrefix 声明
`resharper_web_config_type_not_resolved_highlighting`	代码检查：无法解析符号
`resharper_web_config_unused_add_tag_highlighting`	代码检查：冗余的添加元素
`resharper_web_config_unused_element_due_to_config_source_attribute_highlighting`	代码检查：由于 'configSource' 属性导致的冗余元素或属性
`resharper_web_config_unused_remove_or_clear_tag_highlighting`	代码检查：冗余的移除或清除元素
`resharper_web_config_web_config_path_warning_highlighting`	代码检查：在网站中找不到引用的路径
`resharper_web_config_wrong_module_highlighting`	代码检查：错误的模块
`resharper_web_ignored_path_highlighting`	代码检查：忽略的路径
`resharper_web_mapped_path_highlighting`	代码检查：映射路径
`resharper_with_expression_instead_of_initializer_highlighting`	代码检查：使用 'with' 表达式代替对象初始化器
`resharper_with_expression_modifies_all_members_highlighting`	代码检查： 'with' 表达式修改了所有可访问的实例成员
`resharper_with_statement_using_error_highlighting`	代码检查：在 'strict mode' 中使用 'with' 语句
`resharper_wrap_after_declaration_lpar`	方法签名排列 - 优先在声明中的 '(' 后换行，可用于： C#
`resharper_wrap_after_dot_in_method_calls`	成员访问表达式排列 - 优先在 '.' 后换行 (C#)
`resharper_wrap_after_invocation_lpar`	调用排列 - 优先在调用中的 '(' 后换行，可用于： C#
`resharper_wrap_after_primary_constructor_declaration_lpar`	主构造函数签名排列 - 优先在声明中的 '(' 后换行 (C#)
`resharper_wrap_after_property_in_chained_method_calls`	成员访问表达式排列 - 优先在链式方法调用中的属性和字段后换行 (C#)
`resharper_wrap_arguments_style`	调用排列 - 换行调用参数，可用于： C#， VB.NET
`resharper_wrap_around_elements`	标签内容 - 在元素前后换行，可用于：
`resharper_wrap_array_initializer_style`	初始化器排列 - 换行数组初始化器 (C#)
`resharper_wrap_before_arrow_with_expressions`	表达式主体成员排列 - 优先在 '=>' 前换行并跟随表达式 (C#)
`resharper_wrap_before_binary_opsign`	二元表达式排列 - 优先在二元表达式中的运算符前换行，可用于： C#， VB.NET
`resharper_wrap_before_binary_pattern_op`	二元表达式排列 - 优先在二元模式中的运算符前换行 (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)
`space_within_array_rank_parentheses`	数组 - 在数组维度括号内 (VB.NET)
`space_within_attribute_angles`	属性 - 在属性尖括号内 (VB.NET)
`space_within_attribute_brackets`	属性 - 属性括号内（C#）
`space_within_catch_parentheses`	语句中括号内 - 'catch' 括号（C#）
`space_within_checked_parentheses`	其他括号内 - 'checked' 和 'unchecked' 括号（C#）
`space_within_default_parentheses`	其他括号内 - 'default' 括号（C#）
`space_within_empty_braces`	大括号周围 - 空大括号之间的空格（C#）
`space_within_empty_invocation_parentheses`	附近的括号 - 在空调用括号内 (VB.NET)
`space_within_empty_method_parentheses`	附近的括号 - 在空方法声明括号内 (VB.NET)
`space_within_expression_parentheses`	表达式 - 在括号内，可用于：， VB.NET
`space_within_fixed_parentheses`	语句中括号内 - 'fixed' 括号（C#）
`space_within_for_parentheses`	语句中括号内 - 'for' 括号（C#）
`space_within_foreach_parentheses`	语句中括号内 - 'foreach' 括号（C#）
`space_within_if_parentheses`	语句中的括号 - 'if' 括号 (C#)
`space_within_invocation_parentheses`	附近的括号 - 调用括号内 (VB.NET)
`space_within_list_pattern_brackets`	数组括号周围 - 列表模式和集合表达式括号内（C#）
`space_within_lock_parentheses`	语句中的括号 - 'lock' 括号 (C#)
`space_within_method_parentheses`	附近的括号 - 方法声明括号内 (VB.NET)
`space_within_nameof_parentheses`	其他括号内 - 'nameof' 括号（C#）
`space_within_new_parentheses`	其他括号内 - 'new' 括号（C#）
`space_within_parentheses`	其他括号内 - 括号，适用于： C#
`space_within_single_line_array_initializer_braces`	大括号周围 - 单行表达式大括号内（C#）
`space_within_sizeof_parentheses`	其他括号内 - 'sizeof' 括号（C#）
`space_within_slice_pattern`	其他 - 切片模式中 '..' 之后（C#）
`space_within_switch_parentheses`	语句中括号内 - 'switch' 括号（C#）
`space_within_tuple_parentheses`	附近的括号 - 元组括号内 (VB.NET)
`space_within_type_argument_angles`	尖括号周围 - 类型参数尖括号（C#）
`space_within_type_parameter_angles`	尖括号周围 - 类型形参尖括号（C#）
`space_within_type_parameter_parentheses`	附近括号 - 类型参数括号内 (VB.NET)
`space_within_typeof_parentheses`	其他括号内 - 'typeof' 括号（C#）
`space_within_using_parentheses`	语句中括号内 - 'using' 括号（C#）
`space_within_while_parentheses`	语句中括号内 - 'while' 括号（C#）
`spaces_around_eq_in_attribute`	标签头部内部 - 属性中 '=' 周围的空格，适用于：
`spaces_around_eq_in_pi_attribute`	处理指令 - 属性中 '=' 周围的空格，适用于：
`spaces_inside_tags`	标签内容 - 起始标签后和结束标签前的空格，适用于：
`special_else_if_treatment`	通用 - 特殊 'else if' 处理，适用于： C#
`static_members_qualify_members`	静态成员限定 - 需要限定的成员（C#）
`static_members_qualify_with`	静态成员限定 - 使用名称限定（C#）
`stick_comment`	其他缩进 - 不缩进从第一列开始的注释，适用于： C#， VB.NET
`tab_width`	通用 - 制表符宽度，适用于： C#， ShaderLab， VB.NET
`trailing_comma_in_multiline_lists`	尾随逗号 - 多行列表中新行前 (C#)
`trailing_comma_in_singleline_lists`	尾随逗号 - 当最后一个元素后没有新行时 (C#)
`type_declaration_braces`	大括号布局 - 类型和命名空间声明，适用于： C#
`use_continuous_indent_inside_initializer_braces`	大括号布局 - 在表达式大括号内使用连续行缩进（C#）
`use_continuous_indent_inside_parens`	括号 - 在括号内使用连续行缩进（C#）
`use_heuristics_for_body_style`	代码主体 - 应用样式启发式规则（C#）
`use_indent_from_previous_element`	其他缩进 - 在部分格式中使用前一个元素的缩进 (C#)
`use_old_engine`	为 Razor 格式化使用旧引擎 (Razor CSharp)
`use_roslyn_logic_for_evident_types`	声明中 'var' 的使用 - 偏好 Roslyn (Visual Studio) 的类型推断逻辑 (C#)
`vb_align_multiline_argument`	对齐多行结构 - 调用参数 (VB.NET)
`vb_align_multiline_array_initializer`	对齐多行结构 - 数组初始化器（VB.NET）
`vb_align_multiline_expression`	对齐多行结构 - 表达式 (VB.NET)
`vb_align_multiline_implements_list`	对齐多行结构 - Implements/handles 列表 (VB.NET)
`vb_align_multiline_parameter`	对齐多行结构 - 方法参数 (VB.NET)
`vb_align_multiple_declaration`	对齐多行结构 - 多声明列表 (VB.NET)
`vb_alignment_tab_fill_style`	制表符和缩进 - 使用制表符缩进时的对齐方式 (VB.NET)
`vb_allow_alias`	引用限定 - 允许 'Imports' 别名指令 (VB.NET)
`vb_blank_lines_after_imports`	空行 - 在 Imports 部分之后 (VB.NET)
`vb_blank_lines_after_options`	空行 - 在文件选项部分之后（VB.NET）
`vb_blank_lines_around_field`	空行 - 在多行字段周围 (VB.NET)
`vb_blank_lines_around_global_attribute`	空行 - 全局属性之后 (VB.NET)
`vb_blank_lines_around_invocable`	空行 - 在多行方法周围 (VB.NET)
`vb_blank_lines_around_namespace`	空行 - 在命名空间周围 (VB.NET)
`vb_blank_lines_around_region`	空行 - 区域周围 (VB.NET)
`vb_blank_lines_around_single_line_field`	空行 - 单行字段周围 (VB.NET)
`vb_blank_lines_around_single_line_invocable`	空行 - 单行方法周围 (VB.NET)
`vb_blank_lines_around_type`	空行 - 类型周围 (VB.NET)
`vb_blank_lines_inside_region`	空行 - 区域内部 (VB.NET)
`vb_indent_case_from_select`	其他 - 将“case”缩进到“select”（VB.NET）
`vb_indent_size`	制表符和缩进 - 缩进大小 (VB.NET)
`vb_indent_style`	制表符和缩进 - 缩进样式（VB.NET）
`vb_keep_blank_lines_in_code`	保留现有格式 - 保留代码中的最大空行数 (VB.NET)
`vb_keep_blank_lines_in_declarations`	保留现有格式 - 保留声明中的最大空行数 (VB.NET)
`vb_keep_user_linebreaks`	保留现有格式 - 保留现有换行符 (VB.NET)
`vb_max_line_length`	换行 - 硬换行位置 (VB.NET)
`vb_place_event_attribute_on_same_line`	属性 - 将事件属性放在同一行 (VB.NET)
`vb_place_field_attribute_on_same_line`	属性 - 将字段属性放在同一行 (VB.NET)
`vb_place_method_attribute_on_same_line`	属性 - 将方法属性放在同一行（VB.NET）
`vb_place_property_attribute_on_same_line`	属性 - 将属性的属性放在同一行 (VB.NET)
`vb_place_type_attribute_on_same_line`	属性 - 将类型属性放在同一行（VB.NET）
`vb_prefer_qualified_reference`	引用限定 - 优先使用完全限定的引用（VB.NET）
`vb_space_after_attribute_target_colon`	属性 - 属性目标冒号后（VB.NET）
`vb_space_after_comma`	其他 - 逗号后（VB.NET）
`vb_space_after_unary_op`	操作周围 - 一元运算符之后 (VB.NET)
`vb_space_after_unary_operator`	操作周围 - 一元运算符之后 (VB.NET)
`vb_space_around_additive_op`	操作周围 - 加法运算符（+，-） (VB.NET)
`vb_space_around_assignment_op`	操作周围 - 赋值运算符（例如 '=' 和 '+=') (VB.NET)
`vb_space_around_binary_operator`	在二元运算符周围的空格（+，\|\|，=，...）（通用）
`vb_space_around_dot`	其他 - '.' 周围 (VB.NET)
`vb_space_around_member_access_operator`	其他 - '.' 周围 (VB.NET)
`vb_space_around_multiplicative_op`	操作周围 - 乘法运算符（例如 '*' 和 '/'） (VB.NET)
`vb_space_around_relational_op`	操作周围 - 关系运算符（<，>，<=，>=） (VB.NET)
`vb_space_around_shift_op`	操作周围 - 移位运算符（<<，>>） (VB.NET)
`vb_space_around_stmt_colon`	其他 - 在语句 ':' 周围（VB.NET）
`vb_space_before_array_rank_parentheses`	数组 - 数组维度括号前 (VB.NET)
`vb_space_before_attribute_target_colon`	属性 - 属性目标冒号前 (VB.NET)
`vb_space_before_comma`	其他 - ',' 之前 (VB.NET)
`vb_space_before_empty_invocation_parentheses`	附近的括号 - 空调用括号前 (VB.NET)
`vb_space_before_empty_method_parentheses`	附近的括号 - 空方法声明括号前 (VB.NET)
`vb_space_before_invocation_parentheses`	附近的括号 - 调用括号前 (VB.NET)
`vb_space_before_label_colon`	其他 - 标签中的 ':' 前 (VB.NET)
`vb_space_before_method_parentheses`	附近的括号 - 方法声明括号前 (VB.NET)
`vb_space_before_type_parameter_parentheses`	附近的括号 - 类型参数括号前 (VB.NET)
`vb_space_within_array_initialization_braces`	数组 - 在数组初始化大括号内 (VB.NET)
`vb_space_within_array_rank_empty_parentheses`	数组 - 在空数组维度括号内 (VB.NET)
`vb_space_within_array_rank_parentheses`	数组 - 在数组维度括号内 (VB.NET)
`vb_space_within_attribute_angles`	属性 - 在属性尖括号内 (VB.NET)
`vb_space_within_empty_invocation_parentheses`	附近的括号 - 在空调用括号内 (VB.NET)
`vb_space_within_empty_method_parentheses`	附近的括号 - 在空方法声明括号内 (VB.NET)
`vb_space_within_expression_parentheses`	附近的括号 - 表达式括号内 (VB.NET)
`vb_space_within_invocation_parentheses`	附近的括号 - 调用括号内 (VB.NET)
`vb_space_within_method_parentheses`	附近的括号 - 方法声明括号内 (VB.NET)
`vb_space_within_tuple_parentheses`	附近的括号 - 元组括号内 (VB.NET)
`vb_space_within_type_parameter_parentheses`	附近括号 - 类型参数括号内 (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年 6月 25日