C# 中的代码检查

在 C# 中，JetBrains Rider 2025.2 提供了两种代码检查：1241 项用于检测错误的检查，例如语法错误、未解析的符号、编译器错误等（这些检查无法配置或禁用），以及 1064 项专有代码检查，您可以禁用或更改其严重性级别。
这些代码检查帮助您在所有打开的文件中设计时检测代码问题，并且还允许您在特定范围内查找代码问题。

可配置的 C# 检查列在下方，并按其类别分组。

代码通知（2 项检查）

此类别包含轻微严重性级别的代码检查。

检查 ID EditorConfig 属性	默认严重性
方法调用被跳过 `InvocationIsSkipped` `resharper_invocation_is_skipped_highlighting`	提示
部分代码无法解析 `无法解析的元素` `Resharper 不可解析元素高亮`	警告

常见实践和代码改进（174 项检查）

此类别包含主要影响代码可读性的中等严重性问题的检查。

检查 ID EditorConfig 属性	默认严重性
通过派生类型访问类型的静态成员 `AccessToStaticMemberViaDerivedType` `resharper_access_to_static_member_via_derived_type_highlighting`	警告
忽略了 'Stream.Read()' 实际读取的字节数 `StreamReadReturnValueIgnored` `resharper_stream_read_return_value_ignored_highlighting`	警告
在局部函数之前添加显式的 'return' 或 'continue' `SeparateLocalFunctionsWithJumpStatement` `resharper_separate_local_functions_with_jump_statement_highlighting`	提示
层次结构中的注解重复 `AnnotationRedundancyInHierarchy` `resharper_annotation_redundancy_in_hierarchy_highlighting`	警告
自动属性可以设置为仅 get（非私有访问权限） `AutoPropertyCanBeMadeGetOnly.Global` `resharper_auto_property_can_be_made_get_only_global_highlighting`	建议
自动属性可以设置为仅 get（私有访问权限） `AutoPropertyCanBeMadeGetOnly.Local` `resharper_auto_property_can_be_made_get_only_local_highlighting`	建议
基类成员有 'params' 参数，但重写者没有 `BaseMemberHasParams` `resharper_base_member_has_params_highlighting`	警告
可以在 'Add' 之前简化 'Contains' `CanSimplifySetAddingWithSingleCall` `resharper_can_simplify_set_adding_with_single_call_highlighting`	建议
强制转换表达式可以替换为显式类型参数 `CanReplaceCastWithTypeArgument` `resharper_can_replace_cast_with_type_argument_highlighting`	提示
强制转换表达式可以替换为显式变量类型 `CanReplaceCastWithVariableType` `resharper_can_replace_cast_with_variable_type_highlighting`	提示
强制转换表达式可以替换为 lambda 返回类型 `CanReplaceCastWithLambdaReturnType` `resharper_can_replace_cast_with_lambda_return_type_highlighting`	提示
强制转换表达式可以替换为简化的类型参数 `CanReplaceCastWithShorterTypeArgument` `resharper_can_replace_cast_with_shorter_type_argument_highlighting`	建议
将锁字段类型更改为 'System.Threading.Lock' `ChangeFieldTypeToSystemThreadingLock` `resharper_change_field_type_to_system_threading_lock_highlighting`	建议
改为检查引用相等性 `CheckForReferenceEqualityInstead.1` `resharper_check_for_reference_equality_instead_1_highlighting`	建议
改为检查引用相等性 `CheckForReferenceEqualityInstead.3` `resharper_check_for_reference_equality_instead_3_highlighting`	建议
改为检查引用相等性 `CheckForReferenceEqualityInstead.2` `resharper_check_for_reference_equality_instead_2_highlighting`	建议
改为检查引用相等性 `CheckForReferenceEqualityInstead.4` `resharper_check_for_reference_equality_instead_4_highlighting`	建议
类可以设为密封（不可继承）（非私有可访问性） `ClassCanBeSealed.Global` `resharper_class_can_be_sealed_global_highlighting`	已禁用
类可以设为密封（不可继承）（私有可访问性） `ClassCanBeSealed.Local` `resharper_class_can_be_sealed_local_highlighting`	已禁用
令人困惑的类似主体的语句 `MisleadingBodyLikeStatement` `resharper_misleading_body_like_statement_highlighting`	警告
容器可空性属性用于非容器类型的声明 `ContainerAnnotationRedundancy` `resharper_container_annotation_redundancy_highlighting`	警告
将 'if do while' 转换为 'while' `将 if-do 转换为 while` `ReSharper 将 if-do 转换为 while 的高亮显示`	建议
将 'if' 转换为 '\|\|' `将 If 转换为 Or 表达式` `ReSharper 将 If 转换为 Or 表达式的高亮显示`	建议
将局部变量或字段转换为常量（非私有可访问性） `将变量转换为全局常量` `ReSharper 将变量转换为全局常量的高亮显示`	提示
将局部变量或字段转换为常量（私有可访问性） `将变量转换为局部常量` `ReSharper 将变量转换为局部常量的高亮显示`	提示
声明的可空性已推断（参数被推断为非空） `添加 NotNull 参数注解` `ReSharper 添加 NotNull 参数注解的高亮显示`	已禁用
声明的可空性已推断（参数被推断为可空） `标注可为 null 的参数` `Resharper 标注可为 null 的参数高亮`	已禁用
声明的可空性已推断（类型成员被推断为非空） `标注不可为 null 的类型成员` `Resharper 标注不可为 null 的类型成员高亮`	已禁用
声明的可空性已推断（类型成员被推断为可空） `标注可为 null 的类型成员` `Resharper 标注可为 null 的类型成员高亮`	已禁用
字典项移除可以简化为单个 'Remove' `调用移除 Dictionary 的简化形式` `Resharper Dictionary 单次调用移除简化高亮`	建议
字典查找可以简化为 'GetValueOrDefault' `Dictionary.TryGetValue 可用 GetValueOrDefault 简化` `Resharper Dictionary.TryGetValue 可简化为 GetValueOrDefault 高亮`	建议
字典查找可以简化为 'TryAdd' `可使用 TryAdd 简化 Dictionary 查找` `可使用 TryAdd 简化 Dictionary 查找突出显示`	建议
字典查找可以简化为 'TryGetValue' `可使用 TryGetValue 简化 Dictionary 查找` `可使用 TryGetValue 简化 Dictionary 查找突出显示`	建议
空语句是多余的 `空语句` `空语句突出显示`	警告
提取公共属性模式 `提取公共属性模式` `提取公共属性模式突出显示`	提示
字段可以设为只读（非私有访问权限） `字段可以声明为只读（全局范围）` `resharper_field_can_be_made_read_only_global_highlighting`	建议
字段可以设为只读（私有访问权限） `字段可以声明为只读（局部范围）` `resharper_field_can_be_made_read_only_local_highlighting`	建议
仅可读自动属性从未被赋值 `未赋值的只读自动属性` `resharper_unassigned_get_only_auto_property_highlighting`	警告
反转条件 `反转条件` `resharper_invert_condition_1_highlighting`	提示
迭代变量可以声明为更具体的类型 `存在更具体的 foreach 变量类型可用` `resharper_more_specific_foreach_variable_type_available_highlighting`	建议
合并局部变量的声明和赋值 `合并声明和初始化` `合并声明和初始化的高亮显示`	建议
局部函数可以设为静态 `本地函数可以声明为 static` `本地函数可以声明为 static 的高亮显示`	已禁用
局部变量的声明范围过宽 `局部变量作用域过宽` `局部变量作用域过宽的高亮显示`	建议
将抽象类中的构造函数设为受保护 `抽象类中存在公共构造函数` `抽象类中存在公共构造函数的高亮显示`	建议
成员可以设为私有（非私有访问权限） `成员可以声明为 private（全局）` `成员可以声明为 private（全局）的高亮显示`	建议
成员可以设为私有（私有访问权限） `成员可以声明为 private（局部）` `成员可以声明为 private（局部）的高亮显示`	建议
成员可以设为受保护（非私有访问权限） `成员可设为 protected（全局）` `成员可设为 protected（全局）`	建议
成员可以设为受保护（私有访问权限） `成员可设为 protected（局部）` `成员可设为 protected（局部）`	建议
成员可以设为静态（共享）（非私有访问权限） `成员可设为 static（全局）` `成员可设为 static（全局）`	提示
成员可以设为静态（共享）（私有访问权限） `成员可设为 static（局部）` `成员可设为 static（局部）`	提示
成员或类型可以设为内部（友元） `成员可以为 internal` `成员可以为 internal 的高亮显示`	已禁用
方法具有异步重载 `方法具有异步重载` `方法具有异步重载的高亮显示`	建议
方法具有支持取消的异步重载 `方法具有带取消标记的异步重载` `方法具有带取消标记的异步重载的高亮显示`	建议
方法支持取消 `方法支持取消操作` `方法支持取消操作的高亮显示`	建议
私有或内部类型或成员缺少 XML 注释 `internal 或 private 成员未添加文档注释` `内部或私有成员未添加文档注释`	已禁用
多次使用可空属性 `Nullable 特性使用重复` `Nullable 特性使用重复`	警告
嵌套字符串插值可以内联 `嵌套字符串插值` `嵌套字符串插值`	建议
在 void 或值类型声明中使用可空属性 `值类型使用了多余的注解` `值类型使用了多余的注解`	警告
可空属性用于无法从其他代码直接引用的声明 `NotObservable 注解是多余的` `NotObservable 注解是多余的`	警告
参数可以声明为基类型 `参数应使用基类类型` `参数应使用基类类型`	已禁用
构造函数的参数可以声明为基类型 `构造函数中的参数应使用基类类型` `构造函数中的参数应使用基类类型`	已禁用
参数类型可以是 IEnumerable<T>（非私有可访问性） `ParameterTypeCanBeEnumerable.Global` `resharper_parameter_type_can_be_enumerable_global_highlighting`	已禁用
参数类型可以是 IEnumerable<T>（私有可访问性） `ParameterTypeCanBeEnumerable.Local` `resharper_parameter_type_can_be_enumerable_local_highlighting`	已禁用
建议使用具体值代替 'default' 或 'new()' `优先使用具体值而非默认值` `resharper_prefer_concrete_value_over_default_highlighting`	建议
属性可以设置为仅初始化（非私有可访问性） `属性可设置为仅初始化（全局）` `resharper_property_can_be_made_init_only_global_highlighting`	建议
属性可以设置为仅初始化（私有可访问性） `属性可设置为仅初始化（局部）` `resharper_property_can_be_made_init_only_local_highlighting`	建议
将局部函数放在 'return' 或 'continue' 之后 `将局部函数移至跳转语句后` `resharper_move_local_function_after_jump_statement_highlighting`	提示
多余的 'is' `关系模式前的 is 运算符是冗余的` `resharper_redundant_is_before_relational_pattern_highlighting`	建议
移除构造函数调用 `移除构造函数调用` `resharper_remove_constructor_invocation_highlighting`	已禁用
移除多余的语句 `移除值为 false 的多余逻辑或语句` `resharper_remove_redundant_or_statement_false_highlighting`	建议
移除多余的语句 `移除值为 true 的多余逻辑或语句` `Resharper：冗余的 or 语句为 true 的高亮显示`	建议
移除 ToList() `移除 ToList.1` `Resharper：移除 ToList.1 高亮显示`	建议
移除 ToList() `移除 ToList.2` `Resharper：移除 ToList.2 高亮显示`	建议
将 'async' 代码替换为返回 'Task' `使用 Task return 替换 async` `Resharper：使用 Task return 替换 async 高亮显示`	已禁用
替换为 FirstOrDefault($args$) `替换为 FirstOrDefault.1` `Resharper：替换为 FirstOrDefault.1 高亮显示`	建议
替换为 FirstOrDefault($args$) `替换为 FirstOrDefault.2` `ReSharper 替换为 FirstOrDefault.2 高亮`	建议
替换为 FirstOrDefault($args$) `替换为 FirstOrDefault.3` `ReSharper 替换为 FirstOrDefault.3 高亮`	建议
替换为 FirstOrDefault($args$) `替换为 FirstOrDefault.4` `ReSharper 替换为 FirstOrDefault.4 高亮显示`	建议
替换为 LastOrDefault($args$) `替换为 LastOrDefault.1` `ReSharper 替换为 LastOrDefault.1 高亮显示`	建议
替换为 LastOrDefault($args$) `替换为 LastOrDefault.2` `ReSharper 替换为 LastOrDefault.2 高亮显示`	建议
替换为 LastOrDefault($args$) `替换为 LastOrDefault.3` `ReSharper 替换为 LastOrDefault.3 高亮显示`	建议
替换为 LastOrDefault($args$) `ReplaceWithLastOrDefault.4` `resharper_replace_with_last_or_default_4_highlighting`	建议
替换为 OfType<T>() `ReplaceWithOfType.1` `resharper_replace_with_of_type_1_highlighting`	建议
替换为 OfType<T>() `ReplaceWithOfType.2` `resharper_replace_with_of_type_2_highlighting`	建议
替换为 OfType<T>() `ReplaceWithOfType.3` `resharper_replace_with_of_type_3_highlighting`	建议
替换为 OfType<T>().Any() `ReplaceWithOfType.Any.1` `resharper_replace_with_of_type_any_1_highlighting`	建议
替换为 OfType<T>().Any()（替换为 OfType<T>().Any(..)） `替换为 OfType.Any.2` `替换为 OfType.Any.2 突出显示`	建议
替换为 OfType<T>().Count() `替换为 OfType.Count.1` `替换为 OfType.Count.1 突出显示`	建议
替换为 OfType<T>().Count()（替换为 OfType<T>().Count(..)） `替换为 OfType.Count.2` `替换为 OfType.Count.2 突出显示`	建议
替换为 OfType<T>().First() `替换为 OfType.First.1` `替换为 OfType.First.1 突出显示`	建议
替换为 OfType<T>().First()（替换为 OfType<T>().First(..)） `替换为 OfType.First.2` `使用 OfType().First() 替换`	建议
替换为 OfType<T>().FirstOrDefault() `使用 OfType().FirstOrDefault() 替换（变体 1）` `使用 OfType().FirstOrDefault() 替换（变体 1）的代码检查强调`	建议
替换为 OfType<T>().FirstOrDefault()（替换为 OfType<T>().FirstOrDefault(..)） `使用 OfType().FirstOrDefault() 替换（变体 2）` `使用 OfType().FirstOrDefault() 替换（变体 2）的代码检查强调`	建议
替换为 OfType<T>().Last() `使用 OfType().Last() 替换（变体 1）` `使用 OfType().Last() 替换（变体 1）的代码检查强调`	建议
替换为 OfType<T>().Last()（替换为 OfType<T>().Last(..)） `使用 OfType().Last() 替换（变体 2）` `使用 OfType().Last() 替换（变体 2）的代码检查强调`	建议
替换为 OfType<T>().LastOrDefault() `使用 OfType().LastOrDefault() 替换（变体 1）` `使用 OfType().LastOrDefault() 替换（变体 1）的代码检查强调`	建议
替换为 OfType<T>().LastOrDefault()（替换为 OfType<T>().LastOrDefault(..)） `使用 OfType().LastOrDefault() 替换（变体 2）` `使用 OfType().LastOrDefault() 替换（变体 2）的代码检查强调`	建议
替换为 OfType<T>().LongCount() `替换为 OfType 并使用 LongCount` `resharper_replace_with_of_type_long_count_highlighting`	建议
替换为 OfType<T>().Single() `替换为 OfType 并使用 Single（变体 1）` `resharper_replace_with_of_type_single_1_highlighting`	建议
替换为 OfType<T>().Single()（替换为 OfType<T>().Single(..)） `替换为 OfType 并使用 Single（变体 2）` `resharper_replace_with_of_type_single_2_highlighting`	建议
替换为 OfType<T>().SingleOrDefault() `替换为 OfType 并使用 SingleOrDefault（变体 1）` `resharper_replace_with_of_type_single_or_default_1_highlighting`	建议
替换为 OfType<T>().SingleOrDefault()（替换为 OfType<T>().SingleOrDefault(..)） `替换为 OfType 并使用 SingleOrDefault（变体 2）` `resharper_replace_with_of_type_single_or_default_2_highlighting`	建议
替换为 OfType<T>().Where()（替换为 OfType<T>().Where(..)） `替换为 OfType 并使用 Where` `resharper_replace_with_of_type_where_highlighting`	建议
替换为简单赋值 `替换为简单赋值：True` `resharper_replace_with_simple_assignment_true_highlighting`	建议
替换为简单赋值 `替换为简单赋值：False` `resharper_replace_with_simple_assignment_false_highlighting`	建议
替换为单一赋值 `替换为单一赋值：False` `resharper_replace_with_single_assignment_false_highlighting`	建议
替换为单一赋值 `替换为单一赋值：True` `resharper_replace_with_single_assignment_true_highlighting`	建议
替换为单次调用 Any(..) `用单个 Any 调用替换` `resharper_replace_with_single_call_to_any_highlighting`	建议
替换为单次调用 Count(..) `用单个 Count 调用替换` `resharper_replace_with_single_call_to_count_highlighting`	建议
替换为单次调用 First(..) `用单个 First 调用替换` `resharper_replace_with_single_call_to_first_highlighting`	建议
替换为对 FirstOrDefault(..) 的单次调用 `用单个 FirstOrDefault 调用替换` `resharper_replace_with_single_call_to_first_or_default_highlighting`	建议
替换为对 Last(..) 的单次调用 `用单个 Last 调用替换` `resharper_replace_with_single_call_to_last_highlighting`	建议
替换为对 LastOrDefault(..) 的单次调用 `用单个 LastOrDefault 调用替换` `resharper_replace_with_single_call_to_last_or_default_highlighting`	建议
替换为对 Single(..) 的单次调用 `用单个 Single 调用替换` `resharper_replace_with_single_call_to_single_highlighting`	建议
替换为对 SingleOrDefault(..) 的单次调用 `用单个 SingleOrDefault 调用替换` `resharper_replace_with_single_call_to_single_or_default_highlighting`	建议
替换为 SingleOrDefault($args$) `替换为 SingleOrDefault（变体 1）` `resharper_replace_with_single_or_default_1_highlighting`	建议
替换为 SingleOrDefault($args$) `替换为 SingleOrDefault（变体 2）` `resharper_replace_with_single_or_default_2_highlighting`	建议
替换为 SingleOrDefault($args$) `替换为 SingleOrDefault（变体 3）` `resharper_replace_with_single_or_default_3_highlighting`	建议
替换为 SingleOrDefault($args$) `替换为 SingleOrDefault（变体 4）` `resharper_replace_with_single_or_default_4_highlighting`	建议
返回类型可以是 IEnumerable<T>（非私有可访问性） `返回类型可为 IEnumerable（全局）` `resharper_return_type_can_be_enumerable_global_highlighting`	已禁用
返回类型可以是 IEnumerable<T>（私有可访问性） `返回类型可为 IEnumerable（局部）` `resharper_return_type_can_be_enumerable_local_highlighting`	已禁用
简化条件三元表达式 `简化条件三元表达式` `resharper_simplify_conditional_ternary_expression_highlighting`	建议
简化 'IsInstanceOfType()' 调用 `可简化 IsAssignableFrom` `resharper_can_simplify_is_assignable_from_highlighting`	建议
简化 LINQ 表达式（使用 'All'） `简化 LINQ 表达式：使用 All` `resharper_simplify_linq_expression_use_all_highlighting`	建议
简化 LINQ 表达式（使用 'Any'） `简化 LINQ 表达式：使用 Any` `resharper_simplify_linq_expression_use_any_highlighting`	建议
简化取反模式 `模式中的双重否定` `resharper_double_negation_in_pattern_highlighting`	建议
简化取反关系模式 `关系模式取反` `resharper_negation_of_relational_pattern_highlighting`	建议
简化负等式表达式 `否定的等式表达式` `resharper_negative_equality_expression_highlighting`	建议
明确指定字符串比较 `明确指定 StringComparison` `resharper_specify_string_comparison_highlighting`	提示
明确指定字符串文化 `明确指定字符串转换中的区域性` `resharper_specify_a_culture_in_string_conversion_explicitly_highlighting`	警告
字符串字面量可以内联 `字符串字面量作为插值参数` `resharper_string_literal_as_interpolation_argument_highlighting`	建议
String.Compare 是特定于文化的（string.Compare(string, int, string, int) 是特定于文化的） `String.Compare 使用特定区域性（变体 4）` `resharper_string_compare_is_culture_specific_4_highlighting`	警告
String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的） `String.Compare 使用特定区域性（变体 5）` `resharper_string_compare_is_culture_specific_5_highlighting`	警告
String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的） `String.Compare 使用特定区域性（变体 6）` `resharper_string_compare_is_culture_specific_6_highlighting`	警告
String.Compare 是特定于文化的（string.Compare(string, string) 是特定于文化的） `String.Compare 使用特定区域性（变体 1）` `resharper_string_compare_is_culture_specific_1_highlighting`	警告
String.Compare 是特定于区域性的（string.Compare(string, string, bool) 是特定于区域性的） `String.Compare 使用特定区域性（变体 2）` `resharper_string_compare_is_culture_specific_2_highlighting`	警告
String.Compare 是特定于区域性的（string.Compare(string, string, bool) 是特定于区域性的） `String.Compare 使用特定区域性（变体 3）` `resharper_string_compare_is_culture_specific_3_highlighting`	警告
String.CompareTo 是特定于区域性的 `String.CompareTo 使用特定区域性` `resharper_string_compare_to_is_culture_specific_highlighting`	警告
String.EndsWith 是特定于区域性的（string.EndsWith(string) 是特定于区域性的） `String.EndsWith 使用特定区域性` `resharper_string_ends_with_is_culture_specific_highlighting`	已禁用
String.IndexOf 是特定于区域性的（string.IndexOf(string) 是特定于区域性的） `String.IndexOf 使用特定区域性（变体 1）` `resharper_string_index_of_is_culture_specific_1_highlighting`	警告
String.IndexOf 是特定于区域性的（string.IndexOf(string, int) 是特定于区域性的） `String.IndexOf 使用特定区域性（变体 2）` `resharper_string_index_of_is_culture_specific_2_highlighting`	警告
String.IndexOf 是特定于区域性的（string.IndexOf(string, int) 是特定于区域性的） `String.IndexOf 使用特定区域性（变体 3）` `resharper_string_index_of_is_culture_specific_3_highlighting`	警告
String.LastIndexOf 是特定于区域性的（string.LastIndexOf(string) 是特定于区域性的） `String.LastIndexOf 使用特定区域性（变体 1）` `resharper_string_last_index_of_is_culture_specific_1_highlighting`	警告
String.LastIndexOf 是特定于区域性的（string.LastIndexOf(string, int) 是特定于区域性的） `StringLastIndexOf 是特定于区域性的` `resharper_string_last_index_of_is_culture_specific_2_highlighting`	警告
String.LastIndexOf 是特定于区域性的（string.LastIndexOf(string, int) 是特定于区域性的） `StringLastIndexOf 是特定于区域性的` `resharper_string_last_index_of_is_culture_specific_3_highlighting`	警告
String.StartsWith 是特定于区域性的（string.StartsWith(string) 是特定于区域性的） `StringStartsWith 是特定于区域性的` `resharper_string_starts_with_is_culture_specific_highlighting`	已禁用
结构体可以声明为 readonly `结构体可以设为 readonly` `resharper_struct_can_be_made_read_only_highlighting`	建议
结构体缺少 'IEquatable' 实现（非私有可访问性） `结构体缺少 IEquatable 实现（全局）` `resharper_struct_lacks_i_equatable_global_highlighting`	警告
结构体缺少 'IEquatable' 实现（私有可访问性） `结构体缺少 IEquatable 实现（局部）` `resharper_struct_lacks_i_equatable_local_highlighting`	警告
结构体成员可以声明为 readonly `结构体成员可以设为 readonly` `resharper_struct_member_can_be_made_read_only_highlighting`	已禁用
使用默认相等成员的结构体用于比较（非私有可访问性） `使用了默认结构体相等性（全局）` `resharper_default_struct_equality_is_used_global_highlighting`	警告
使用默认相等成员的结构体用于比较（私有可访问性） `使用了默认结构体相等性（局部）` `resharper_default_struct_equality_is_used_local_highlighting`	警告
try-catch 和 try-finally 语句可以合并 `try 语句可以合并` `resharper_try_statements_can_be_merged_highlighting`	提示
类型可以声明为文件本地 `成员可以设为 file-local` `resharper_member_can_be_file_local_highlighting`	已禁用
类型参数可以声明为协变或逆变 `类型参数可以设为协变或逆变` `resharper_type_parameter_can_be_variant_highlighting`	建议
在记录中使用了具有可疑相等性的类型（非私有可访问性） `在 record 中使用了相等性可疑的类型（全局）` `resharper_type_with_suspicious_equality_is_used_in_record_global_highlighting`	警告
在记录中使用了具有可疑相等性的类型（私有可访问性） `在 record 中使用了相等性可疑的类型（局部）` `resharper_type_with_suspicious_equality_is_used_in_record_local_highlighting`	警告
使用默认结构体相等性 `使用了默认结构体相等性` `resharper_usage_of_default_struct_equality_highlighting`	警告
使用 'ArgumentNullException.ThrowIfNull' `使用 ThrowIfNull 方法` `resharper_use_throw_if_null_method_highlighting`	已禁用
使用数组创建表达式 `使用数组创建表达式` `resharper_use_array_creation_expression_1_highlighting`	建议
使用数组创建表达式 `使用数组创建表达式` `resharper_use_array_creation_expression_2_highlighting`	建议
使用 'Array.Empty<T>()' `使用 Array.Empty 方法` `resharper_use_array_empty_method_highlighting`	建议
使用取消令牌 `为 IAsyncEnumerable 使用 CancellationToken` `resharper_use_cancellation_token_for_i_async_enumerable_highlighting`	建议
使用编译器支持的可空属性 `使用编译器支持的 Nullable 特性` `resharper_use_nullable_attributes_supported_by_compiler_highlighting`	建议
使用 'EventArgs.Empty' `使用 EventArgs.Empty 字段` `resharper_use_event_args_empty_field_highlighting`	建议
使用索引属性 `使用带索引的属性` `resharper_use_indexed_property_highlighting`	建议
使用 'is' 运算符 `可简化 IsInstanceOfType` `resharper_can_simplify_is_instance_of_type_highlighting`	建议
使用方法 Any() `使用 Any 方法` `resharper_use_method_any_0_highlighting`	建议
使用方法 Any() `使用 Any 方法` `resharper_use_method_any_1_highlighting`	建议
使用方法 Any() `使用 Any 方法` `resharper_use_method_any_2_highlighting`	建议
使用方法 Any() `使用 Any 方法` `resharper_use_method_any_3_highlighting`	建议
使用方法 Any() `使用 Any 方法` `resharper_use_method_any_4_highlighting`	建议
使用 'String.IsNullOrEmpty' `替换为 String.IsNullOrEmpty` `resharper_replace_with_string_is_null_or_empty_highlighting`	建议
使用 'Type.EmptyTypes' `使用 EmptyTypes 字段` `resharper_use_empty_types_field_highlighting`	建议

编译器警告（212 项检查）

此类别中的检查会在编译前检测到编译器警告。

检查 ID EditorConfig 属性	默认严重性
'#warning' 指令 `CSharp 警告：CS1030` `resharper_c_sharp_warnings_cs1030_highlighting`	警告
[InterpolatedStringHandlerArgument] 应用于 lambda 参数时无效，并将在调用点被忽略。 `CSharp 警告：CS8971` `resharper_c_sharp_warnings_cs8971_highlighting`	警告
为 'ref readonly' 参数指定了默认值，但 'ref readonly' 应仅用于引用。请考虑将参数声明为 'in'。 `CSharp 警告：CS9200` `resharper_c_sharp_warnings_cs9200_highlighting`	警告
局部变量通过引用返回，但被初始化为无法通过引用返回的值。 `CSharp 警告：CS9082` `resharper_c_sharp_warnings_cs9082_highlighting`	警告
变量的成员通过引用返回，但被初始化为无法通过引用返回的值 `CSharp 警告：CS9083` `resharper_c_sharp_warnings_cs9083_highlighting`	警告
标记为 [DoesNotReturn] 的方法不应返回。 `CSharp 警告：CS8763` `resharper_c_sharp_warnings_cs8763_highlighting`	警告
可能的空值不能用于标记为 [NotNull] 或 [DisallowNull] 的类型。 `CSharp 警告：CS8607` `resharper_c_sharp_warnings_cs8607_highlighting`	警告
前一个 catch 子句已捕获所有异常 `CSharp 警告：CS1058` `resharper_c_sharp_warnings_cs1058_highlighting`	警告
在此上下文中，stackalloc 表达式的结果可能会暴露在包含方法之外。 `CSharp 警告：CS9081` `resharper_c_sharp_warnings_cs9081_highlighting`	警告
日志消息中的模板在日志方法定义中没有匹配的参数 `CSharp 警告：SYSLIB1014` `resharper_c_sharp_warnings_syslib1014_highlighting`	警告
类型为 'System.Threading.Lock' 的值转换为不同类型时，在 'lock' 语句中可能会使用非预期的基于监视器的锁定 `CSharp 警告：CS9216` `resharper_c_sharp_warnings_cs9216_highlighting`	警告
通过匿名方法、lambda 表达式、查询表达式或迭代器中的 'base' 关键字访问成员会导致无法验证的代码 `CSharp 警告：CS1911` `resharper_c_sharp_warnings_cs1911_highlighting`	警告
对齐值 'value' 的大小超过了 'magnitude limit'，可能会导致生成较大的格式化字符串。 `CSharp 警告：CS8094` `resharper_c_sharp_warnings_cs8094_highlighting`	警告
XML 注释中存在模糊引用 `CSharp 警告：CS1574` `resharper_c_sharp_warnings_cs1574_highlighting`	警告
由于引用类型的可空性差异，参数无法用作输出参数 `CSharp 警告：CS8624` `resharper_c_sharp_warnings_cs8624_highlighting`	警告
由于引用类型的可空性差异，参数无法用于对应的参数 `CSharp 警告：CS8620` `resharper_c_sharp_warnings_cs8620_highlighting`	警告
参数应为变量，因为它被传递给 'ref readonly' 参数。 `CSharpWarnings::CS9193` `resharper_c_sharp_warnings_cs9193_highlighting`	警告
参数应使用 'in' 关键字传递。 `CSharpWarnings::CS9195` `resharper_c_sharp_warnings_cs9195_highlighting`	警告
条件表达式中的赋值 `CSharpWarnings::CS0665` `resharper_c_sharp_warnings_cs0665_highlighting`	警告
对同一变量的赋值 `CSharpWarnings::CS1717` `resharper_c_sharp_warnings_cs1717_highlighting`	警告
异步函数中没有 await 表达式 `CSharpWarnings::CS1998` `resharper_c_sharp_warnings_cs1998_highlighting`	警告
异步方法调用中没有 await 表达式 `CSharpWarnings::CS4014` `resharper_c_sharp_warnings_cs4014_highlighting`	警告
异步 'Main' 方法不会用作入口点，因为找到了同步入口点。 `CSharpWarnings::CS8892` `resharper_c_sharp_warnings_cs8892_highlighting`	警告
异步迭代器有一个或多个类型为 'CancellationToken' 的参数，但其中没有任何参数带有 'EnumeratorCancellation' 属性。 `CSharpWarnings::CS8425` `resharper_c_sharp_warnings_cs8425_highlighting`	警告
'attribute modifier' 不是一个被识别的属性位置。此块中的所有属性都将被忽略 `CSharpWarnings::CS0658` `resharper_c_sharp_warnings_cs0658_highlighting`	警告
'attribute modifier' 不是此声明的有效属性位置。此块中的所有属性都将被忽略 `CSharpWarnings::CS0657` `resharper_c_sharp_warnings_cs0657_highlighting`	警告
包含注释文件中的 XML 格式错误 `CSharpWarnings::CS1592` `resharper_c_sharp_warnings_cs1592_highlighting`	警告
对符号扩展操作数使用了按位或运算符。 `CSharpWarnings::CS0675` `resharper_c_sharp_warnings_cs0675_highlighting`	警告
从 'readonly' 成员调用非只读成员会导致 'this' 的隐式副本 `CSharpWarnings::CS8656` `resharper_c_sharp_warnings_cs8656_highlighting`	警告
无法将 null 字面量转换为非可空引用类型。 `CSharpWarnings::CS8625` `resharper_c_sharp_warnings_cs8625_highlighting`	警告
无法解析 XML 注释中的引用 `CSharpWarnings::CS1574、CS1584、CS1581、CS1580` `resharper_c_sharp_warnings_cs1574_cs1584_cs1581_cs1580_highlighting`	警告
类重写了 Object.Equals(object o) 但未重写 Object.GetHashCode() `CSharpWarnings::CS0659` `resharper_c_sharp_warnings_cs0659_highlighting`	警告
代码不可达 `CSharpWarnings::CS0162` `resharper_c_sharp_warnings_cs0162_highlighting`	警告
集合表达式可能会导致意外的堆分配 `CSharpWarnings::CS9208` `resharper_c_sharp_warnings_cs9208_highlighting`	警告
集合表达式可能由于使用 '..' 展开而导致意外的堆分配 `CSharpWarnings::CS9209` `resharper_c_sharp_warnings_cs9209_highlighting`	警告
与可空值类型的 null 比较总是会产生 'false' `CSharpWarnings::CS0464` `resharper_c_sharp_warnings_cs0464_highlighting`	警告
与整数常量的比较是无用的；该常量超出了类型 'type' 的范围。 `CSharpWarnings::CS0652` `resharper_c_sharp_warnings_cs0652_highlighting`	警告
将方法组转换为非委托类型 'object'。 `CSharpWarnings::CS8974` `resharper_c_sharp_warnings_cs8974_highlighting`	警告
将 null 字面值或可能的 null 值转换为非可空类型。 `CSharpWarnings::CS8600` `resharper_c_sharp_warnings_cs8600_highlighting`	警告
在密封类中声明新的受保护成员与将其声明为私有成员相同 `CSharpWarnings::CS0628` `resharper_c_sharp_warnings_cs0628_highlighting`	警告
为参数指定的默认值将不起作用，因为它适用于不允许可选参数的上下文中的成员 `CSharpWarnings::CS1066` `resharper_c_sharp_warnings_cs1066_highlighting`	警告
可能的 null 引用的解引用。 `CSharpWarnings::CS8602` `resharper_c_sharp_warnings_cs8602_highlighting`	警告
XML 注释中重复的 param 标签 `CSharpWarnings::CS1571` `resharper_c_sharp_warnings_cs1571_highlighting`	警告
XML 注释中重复的 typeparam 标签 `CSharpWarnings::CS1710` `resharper_c_sharp_warnings_cs1710_highlighting`	警告
空的 switch 块 `CSharpWarnings::CS1522` `resharper_c_sharp_warnings_cs1522_highlighting`	警告
字段从未使用过 `UnusedField.Compiler` `resharper_unused_field_compiler_highlighting`	警告
筛选表达式是一个常量，请考虑移除筛选器 `CSharpWarnings::CS7095` `resharper_c_sharp_warnings_cs7095_highlighting`	警告
给定表达式总是匹配提供的模式 `CSharpWarnings::CS8794` `resharper_c_sharp_warnings_cs8794_highlighting`	警告
给定表达式总是属于提供的类型 `CSharpWarnings::CS0183` `resharper_c_sharp_warnings_cs0183_highlighting`	警告
给定表达式从不属于提供的类型 `CSharpWarnings::CS0184` `resharper_c_sharp_warnings_cs0184_highlighting`	警告
'goto case' 值不能隐式转换为所需类型 `CSharpWarnings::CS0469` `resharper_c_sharp_warnings_cs0469_highlighting`	警告
在语言版本预览中，'field' 关键字绑定到属性的合成后备字段 `CSharpWarnings::CS9258` `resharper_c_sharp_warnings_cs9258_highlighting`	警告
XML 注释中的签名不正确 `CSharpWarnings::CS1580` `resharper_c_sharp_warnings_cs1580_highlighting`	警告
错误使用 ConstantExpected 特性 `CSharpWarnings::CA1856` `resharper_c_sharp_warnings_ca1856_highlighting`	错误
内联数组转换运算符不会用于从声明类型的表达式进行转换。 `CSharpWarnings::CS9183` `resharper_c_sharp_warnings_cs9183_highlighting`	警告
内联数组索引器不会用于元素访问表达式。 `CSharpWarnings::CS9181` `resharper_c_sharp_warnings_cs9181_highlighting`	警告
内联数组 'Slice' 方法不会用于元素访问表达式。 `CSharpWarnings::CS9182` `resharper_c_sharp_warnings_cs9182_highlighting`	警告
'内联数组' 语言功能不支持具有 'ref' 字段或类型无效作为类型参数的元素字段的内联数组类型。 `CSharpWarnings::CS9184` `resharper_c_sharp_warnings_cs9184_highlighting`	警告
引入 'Finalize' 方法可能会干扰析构函数的调用 `CSharpWarnings::CS0465` `resharper_c_sharp_warnings_cs0465_highlighting`	警告
XML 注释中的 XML 无效 `CSharpWarnings::CS1570` `resharper_c_sharp_warnings_cs1570_highlighting`	警告
无效的 XML 包含元素 `CSharpWarnings::CS1590` `resharper_c_sharp_warnings_cs1590_highlighting`	警告
关键字 'new' 是多余的 `CSharpWarnings::CS0109` `resharper_c_sharp_warnings_cs0109_highlighting`	警告
关键字 'new' 是必需的 `CSharpWarnings::CS0108,CS0114` `resharper_c_sharp_warnings_cs0108_cs0114_highlighting`	警告
成员不能在此属性中使用。 `CSharpWarnings::CS8776` `resharper_c_sharp_warnings_cs8776_highlighting`	警告
成员在退出函数时必须有条件地具有非空值。 `CSharpWarnings::CS8775` `resharper_c_sharp_warnings_cs8775_highlighting`	警告
成员在退出时必须具有非空值。 `CSharpWarnings::CS8774` `resharper_c_sharp_warnings_cs8774_highlighting`	警告
成员重写了已过时的成员 `CSharpWarnings::CS0672` `resharper_c_sharp_warnings_cs0672_highlighting`	警告
方法缺少 '[DoesNotReturn]' 注解以匹配已实现或重写的成员。 `CSharpWarnings::CS8770` `resharper_c_sharp_warnings_cs8770_highlighting`	警告
公开可见的类型或成员缺少 XML 注释 `CSharpWarnings::CS1591` `resharper_c_sharp_warnings_cs1591_highlighting`	警告
运行时存在多个重写候选项 `CSharpWarnings::CS1957` `resharper_c_sharp_warnings_cs1957_highlighting`	警告
找到多个具有相同名称的 Shader `ShaderLabShaderReferenceMultipleCandidates` `resharper_shader_lab_shader_reference_multiple_candidates_highlighting`	警告
命名空间应为此项目的默认命名空间 `CSharpWarnings::WME006` `resharper_c_sharp_warnings_wme006_highlighting`	警告
未访问的字段 `NotAccessedField.Compiler` `resharper_not_accessed_field_compiler_highlighting`	警告
未访问的局部变量 `NotAccessedVariable.Compiler` `resharper_not_accessed_variable_compiler_highlighting`	警告
不可为空的后备字段未初始化。 `CSharpWarnings::CS9264` `resharper_c_sharp_warnings_cs9264_highlighting`	警告
不可为空的成员未初始化。 `CSharpWarnings::CS8618` `resharper_c_sharp_warnings_cs8618_highlighting`	警告
类型参数的约束中存在可空性不匹配。 `CSharpWarnings::CS8633` `resharper_c_sharp_warnings_cs8633_highlighting`	警告
显式接口说明符中的引用类型可空性与类型实现的接口不匹配。 `CSharpWarnings::CS8643` `resharper_c_sharp_warnings_cs8643_highlighting`	警告
基类型实现的接口中的引用类型可空性不匹配。 `CSharpWarnings::CS8644` `resharper_c_sharp_warnings_cs8644_highlighting`	警告
返回类型中的引用类型可空性与已实现的成员不匹配。 `CSharpWarnings::CS8616` `resharper_c_sharp_warnings_cs8616_highlighting`	警告
返回类型中的引用类型可空性与隐式实现的成员不匹配。 `CSharpWarnings::CS8613` `resharper_c_sharp_warnings_cs8613_highlighting`	警告
返回类型中的引用类型可空性与重写的成员不匹配。 `CSharpWarnings::CS8609` `resharper_c_sharp_warnings_cs8609_highlighting`	警告
返回类型中的引用类型可空性与局部方法声明不匹配。 `CSharpWarnings::CS8819` `resharper_c_sharp_warnings_cs8819_highlighting`	警告
返回类型中的引用类型可空性与目标委托不匹配（可能是由于可空性属性）。 `CSharpWarnings::CS8621` `resharper_c_sharp_warnings_cs8621_highlighting`	警告
拦截器方法中的返回类型引用类型可空性与可拦截方法不匹配 `CSharpWarnings::CS9159` `resharper_c_sharp_warnings_cs9159_highlighting`	警告
源类型中的引用类型可空性与目标类型不匹配。 `CSharpWarnings::CS8619` `resharper_c_sharp_warnings_cs8619_highlighting`	警告
类型中引用类型的可空性与已实现成员不匹配。 `CSharpWarnings::CS8615` `resharper_c_sharp_warnings_cs8615_highlighting`	警告
类型中引用类型的可空性与隐式实现的成员不匹配。 `CSharpWarnings::CS8612` `resharper_c_sharp_warnings_cs8612_highlighting`	警告
类型中引用类型的可空性与重写的成员不匹配。 `CSharpWarnings::CS8608` `resharper_c_sharp_warnings_cs8608_highlighting`	警告
参数类型中引用类型的可空性与目标委托不匹配（可能是由于可空性属性导致）。 `CSharpWarnings::CS8622` `resharper_c_sharp_warnings_cs8622_highlighting`	警告
参数类型中引用类型的可空性与已实现成员不匹配。 `CSharpWarnings::CS8617` `resharper_c_sharp_warnings_cs8617_highlighting`	警告
参数类型中引用类型的可空性与隐式实现的成员不匹配。 `CSharpWarnings::CS8614` `resharper_c_sharp_warnings_cs8614_highlighting`	警告
参数类型中引用类型的可空性与可拦截方法不匹配。 `CSharpWarnings::CS9158` `resharper_c_sharp_warnings_cs9158_highlighting`	警告
参数类型中引用类型的可空性与重写的成员不匹配。 `CSharpWarnings::CS8610` `resharper_c_sharp_warnings_cs8610_highlighting`	警告
参数类型中引用类型的可空性与部分成员声明不匹配。 `CSharpWarnings::CS8611` `resharper_c_sharp_warnings_cs8611_highlighting`	警告
返回类型的可空性与已实现成员不匹配（可能是由于可空性属性导致）。 `CSharpWarnings::CS8768` `resharper_c_sharp_warnings_cs8768_highlighting`	警告
返回类型的可空性与隐式实现的成员不匹配（可能是由于可空性属性导致）。 `CSharpWarnings::CS8766` `resharper_c_sharp_warnings_cs8766_highlighting`	警告
返回类型的可空性与重写的成员不匹配（可能是由于可空性属性导致）。 `CSharpWarnings::CS8764` `resharper_c_sharp_warnings_cs8764_highlighting`	警告
类型参数的可空性与“class”约束不匹配。 `CSharpWarnings::CS8634` `resharper_c_sharp_warnings_cs8634_highlighting`	警告
类型参数的可空性与约束类型不匹配。 `CSharpWarnings::CS8631` `resharper_c_sharp_warnings_cs8631_highlighting`	警告
类型参数的可空性与“notnull”约束不匹配。 `CSharpWarnings::CS8714` `resharper_c_sharp_warnings_cs8714_highlighting`	警告
参数类型的可空性与已实现成员不匹配（可能是由于可空性属性导致）。 `CSharpWarnings::CS8769` `resharper_c_sharp_warnings_cs8769_highlighting`	警告
参数类型的可空性与隐式实现的成员不匹配（可能是由于可空性属性导致）。 `CSharpWarnings::CS8767` `resharper_c_sharp_warnings_cs8767_highlighting`	警告
参数类型的可空性与重写的成员不匹配（可能是由于可空性属性导致）。 `CSharpWarnings::CS8765` `resharper_c_sharp_warnings_cs8765_highlighting`	警告
可空值类型可能为 null。 `CSharpWarnings::CS8629` `resharper_c_sharp_warnings_cs8629_highlighting`	警告
对象或集合初始化器隐式解引用了可能为 null 的成员。 `CSharpWarnings::CS8670` `resharper_c_sharp_warnings_cs8670_highlighting`	警告
过时的成员重写了非过时的成员 `CSharpWarnings::CS0809` `resharper_c_sharp_warnings_cs0809_highlighting`	警告
不应要求使用过时的成员。 `CSharpWarnings::CS9042` `resharper_c_sharp_warnings_cs9042_highlighting`	警告
运算符“==”或运算符“!=”未重写“Object.Equals(object o)”和“Object.GetHashCode()” `CSharpWarnings::CS0660,CS0661` `resharper_c_sharp_warnings_cs0660_cs0661_highlighting`	警告
在使用预览功能之前，请先选择加入。 `CSharpWarnings::CA2252` `resharper_c_sharp_warnings_ca2252_highlighting`	错误
参数在 XML 注释中没有匹配的 param 标签 `CSharpWarnings::CS1573` `resharper_c_sharp_warnings_cs1573_highlighting`	警告
参数在 lambda 中具有 params 修饰符，但在目标委托类型中没有。 `CSharpWarnings::CS9100` `resharper_c_sharp_warnings_cs9100_highlighting`	警告
参数被捕获到封闭类型的状态中，其值也被传递到基构造函数。该值可能也会被基类捕获。 `CSharpWarnings::CS9107` `resharper_c_sharp_warnings_cs9107_highlighting`	警告
参数被捕获到封闭类型的状态中，其值也被用于初始化字段、属性或事件。 `CSharpWarnings::CS9124` `resharper_c_sharp_warnings_cs9124_highlighting`	警告
参数在退出函数时必须有条件地具有非空值。 `CSharpWarnings::CS8762` `resharper_c_sharp_warnings_cs8762_highlighting`	警告
参数在退出时必须具有非空值，因为在 [NotNullIfNotNull] 注解中提到的参数为非空。 `CSharpWarnings::CS8824` `resharper_c_sharp_warnings_cs8824_highlighting`	警告
参数在退出时必须具有非空值。 `CSharpWarnings::CS8777` `resharper_c_sharp_warnings_cs8777_highlighting`	警告
参数在参数列表中出现在插值字符串处理程序参数之后。 `CSharpWarnings::CS8947` `resharper_c_sharp_warnings_cs8947_highlighting`	警告
partial 成员声明具有不同的签名 `CSharpWarnings::CS9256` `resharper_c_sharp_warnings_cs9256_highlighting`	警告
局部方法声明的类型参数的可空性不一致。 `CSharpWarnings::CS8667` `resharper_c_sharp_warnings_cs8667_highlighting`	警告
可能是错误的空语句。 `CSharpWarnings::CS0642` `resharper_c_sharp_warnings_cs0642_highlighting`	警告
参数可能为 null 引用。 `CSharpWarnings::CS8604` `resharper_c_sharp_warnings_cs8604_highlighting`	警告
可能的 null 引用赋值。 `CSharpWarnings::CS8601` `resharper_c_sharp_warnings_cs8601_highlighting`	警告
可能的 null 引用返回值。 `CSharpWarnings::CS8603` `resharper_c_sharp_warnings_cs8603_highlighting`	警告
可能的无意引用比较。 `CSharpWarnings::CS0252,CS0253` `resharper_c_sharp_warnings_cs0252_cs0253_highlighting`	警告
可能错误地将值分配给 'using' 或 'lock' 语句的参数。 `CSharpWarnings::CS0728` `resharper_c_sharp_warnings_cs0728_highlighting`	警告
主构造函数参数被基类型的成员遮蔽。 `CSharpWarnings::CS9179` `resharper_c_sharp_warnings_cs9179_highlighting`	警告
记录定义了 'Equals' 但未定义 'GetHashCode'。 `CSharpWarnings::CS8851` `resharper_c_sharp_warnings_cs8851_highlighting`	警告
参数的引用类型修饰符与隐藏成员中对应的参数不匹配。 `CSharpWarnings::CS9197` `resharper_c_sharp_warnings_cs9197_highlighting`	警告
参数的引用类型修饰符与重写或实现的成员中对应的参数不匹配。 `CSharpWarnings::CS9196` `resharper_c_sharp_warnings_cs9196_highlighting`	警告
参数的引用类型修饰符与目标中对应的参数不匹配。 `CSharpWarnings::CS9198` `resharper_c_sharp_warnings_cs9198_highlighting`	警告
对易失性字段的引用不会被视为易失性。 `CSharpWarnings::CS0420` `resharper_c_sharp_warnings_cs0420_highlighting`	警告
返回值必须为非空，因为在 [NotNullIfNotNull] 注解中提到的参数为非空。 `CSharpWarnings::CS8825` `resharper_c_sharp_warnings_cs8825_highlighting`	警告
可拦截方法和拦截器方法的签名不匹配。 `CSharpWarnings::CS9154` `resharper_c_sharp_warnings_cs9154_highlighting`	警告
源文件已超过 PDB 可表示的 16,707,565 行限制；调试信息将不正确。 `CSharpWarnings::CS1687` `resharper_c_sharp_warnings_cs1687_highlighting`	警告
'is' 或 'as' 运算符中的静态类型。 `CSharpWarnings::CS7023` `resharper_c_sharp_warnings_cs7023_highlighting`	警告
结构体成员通过引用返回 'this' 或其他实例成员。 `CSharpWarnings::CS9084` `resharper_c_sharp_warnings_cs9084_highlighting`	警告
XML 注释中的语法错误 `CSharpWarnings::CS1584` `resharper_c_sharp_warnings_cs1584_highlighting`	警告
获取按引用封送类字段的地址 `CSharpWarnings::CS0197` `resharper_c_sharp_warnings_cs0197_highlighting`	警告
模板应为静态表达式 `CSharpWarnings::CA2254` `resharper_c_sharp_warnings_ca2254_highlighting`	提示
在异步方法中不应对参数或局部变量使用 '&' 运算符。 `CSharpWarnings::CS9123` `resharper_c_sharp_warnings_cs9123_highlighting`	警告
可空引用类型的注解应仅在 '#nullable' 注解上下文中的代码中使用。 `CSharpWarnings::CS8632` `resharper_c_sharp_warnings_cs8632_highlighting`	警告
可空引用类型的注解应仅在 '#nullable' 注解上下文中的代码中使用。自动生成的代码需要在源代码中显式使用 '#nullable' 指令。 `CSharpWarnings::CS8669` `resharper_c_sharp_warnings_cs8669_highlighting`	警告
ref 条件运算符的分支引用了声明范围不兼容的变量。 `CSharpWarnings::CS9086` `resharper_c_sharp_warnings_cs9086_highlighting`	警告
应用于参数的 CallerArgumentExpressionAttribute 将不起作用，因为它是自引用的 `CSharpWarnings::CS8965` `resharper_c_sharp_warnings_cs8965_highlighting`	警告
CallerArgumentExpressionAttribute 使用了无效的参数名称。 `CSharpWarnings::CS8963` `resharper_c_sharp_warnings_cs8963_highlighting`	警告
CallerArgumentExpressionAttribute 将不起作用，因为它应用于不允许可选参数的上下文中的成员 `CSharpWarnings::CS8966` `resharper_c_sharp_warnings_cs8966_highlighting`	警告
CallerArgumentExpressionAttribute 将不起作用；它被 CallerFilePathAttribute 覆盖 `CSharpWarnings::CS8961` `resharper_c_sharp_warnings_cs8961_highlighting`	警告
CallerArgumentExpressionAttribute 将不起作用；它被 CallerLineNumberAttribute 覆盖 `CSharpWarnings::CS8960` `resharper_c_sharp_warnings_cs8960_highlighting`	警告
CallerArgumentExpressionAttribute 将不起作用；它被 CallerMemberNameAttribute 覆盖 `CSharpWarnings::CS8962` `resharper_c_sharp_warnings_cs8962_highlighting`	警告
CallerFilePathAttribute 将无效；它被 CallerLineNumberAttribute 覆盖 `CSharpWarnings::CS7082` `resharper_c_sharp_warnings_cs7082_highlighting`	警告
CallerFilePathAttribute 将无效，因为它应用于不允许可选参数的上下文中的成员 `CSharpWarnings::CS4025` `resharper_c_sharp_warnings_cs4025_highlighting`	警告
CallerLineNumberAttribute 将无效，因为它应用于不允许可选参数的上下文中的成员 `CSharpWarnings::CS4024` `resharper_c_sharp_warnings_cs4024_highlighting`	警告
CallerMemberNameAttribute 将无效，因为它应用于不允许可选参数的上下文中的成员 `CSharpWarnings::CS4026` `resharper_c_sharp_warnings_cs4026_highlighting`	警告
CallerMemberNameAttribute 将无效；它被 CallerFilePathAttribute 覆盖 `CSharpWarnings::CS7080` `resharper_c_sharp_warnings_cs7080_highlighting`	警告
CallerMemberNameAttribute 将无效；它被 CallerLineNumberAttribute 覆盖 `CSharpWarnings::CS7081` `resharper_c_sharp_warnings_cs7081_highlighting`	警告
目标委托类型中的默认参数值不匹配。 `CSharpWarnings::CS9099` `resharper_c_sharp_warnings_cs9099_highlighting`	警告
'EnumeratorCancellation' 属性仅在返回 'IAsyncEnumerable<>' 的异步迭代器方法中对类型为 'CancellationToken' 的参数有效。 `CSharpWarnings::CS8424` `resharper_c_sharp_warnings_cs8424_highlighting`	警告
给定表达式始终匹配提供的常量。 `CSharpWarnings::CS8520` `resharper_c_sharp_warnings_cs8520_highlighting`	警告
给定表达式从不匹配提供的模式。 `CSharpWarnings::CS8519` `resharper_c_sharp_warnings_cs8519_highlighting`	警告
'l' 后缀容易与数字 '1' 混淆 `CSharpWarnings::CS0078` `resharper_c_sharp_warnings_cs0078_highlighting`	警告
由于找到包含顶级语句的编译单元，'Main' 方法将不会用作入口点。 `CSharpWarnings::CS7022` `resharper_c_sharp_warnings_cs7022_highlighting`	警告
该参数需要常量以获得最佳性能 `CSharpWarnings::CA1857` `resharper_c_sharp_warnings_ca1857_highlighting`	建议
与 'in' 参数对应的参数的 'ref' 修饰符等同于 'in'。请考虑改用 'in'。 `CSharpWarnings::CS9191` `resharper_c_sharp_warnings_cs9191_highlighting`	警告
与 'in' 参数对应的参数的 'ref' 修饰符等同于 'in'。请考虑改用 'in'。 `CSharpWarnings::CS9192` `resharper_c_sharp_warnings_cs9192_highlighting`	警告
表达式的结果始终是可空类型的 'null' `CSharpWarnings::CS0458` `resharper_c_sharp_warnings_cs0458_highlighting`	警告
表达式的结果始终是 'true' 或 'false'，因为值类型的值永远不等于 'null' `CSharpWarnings::CS0472` `resharper_c_sharp_warnings_cs0472_highlighting`	警告
表达式的结果始终是 'true' 或 'false'，因为值类型的值永远不等于 'null' `CSharpWarnings::CS8073` `resharper_c_sharp_warnings_cs8073_highlighting`	警告
参数的 'scoped' 修饰符与目标委托不匹配。 `CSharpWarnings::CS9073` `resharper_c_sharp_warnings_cs9073_highlighting`	警告
参数的 'scoped' 修饰符与重写或实现的成员不匹配。 `CSharpWarnings::CS9074` `resharper_c_sharp_warnings_cs9074_highlighting`	警告
switch 表达式未处理所有可能的输入（不完整）。 `CSharpWarnings::CS8509` `resharper_c_sharp_warnings_cs8509_highlighting`	警告
switch 表达式未处理其输入类型的所有可能值（不完整）。但是，带有 'when' 子句的模式可能会成功匹配此值。 `CSharpWarnings::CS8846` `resharper_c_sharp_warnings_cs8846_highlighting`	警告
switch 表达式未处理某些 null 输入（不完整）。 `CSharpWarnings::CS8655` `resharper_c_sharp_warnings_cs8655_highlighting`	警告
switch 表达式未处理某些 null 输入（不完整）。但是，带有 'when' 子句的模式可能会成功匹配此值。 `CSharpWarnings::CS8847` `resharper_c_sharp_warnings_cs8847_highlighting`	警告
switch 表达式未处理其输入类型的某些值（不完整），涉及未命名的枚举值。 `CSharpWarnings::CS8524` `resharper_c_sharp_warnings_cs8524_highlighting`	警告
元组元素名称被忽略，因为目标类型指定了不同的名称或未指定名称。 `CSharpWarnings::CS8123` `resharper_c_sharp_warnings_cs8123_highlighting`	警告
元组元素名称被忽略，因为元组 == 或 != 运算符另一侧指定了不同的名称或未指定名称。 `CSharpWarnings::CS8383` `resharper_c_sharp_warnings_cs8383_highlighting`	警告
类型名称仅包含小写的 ASCII 字符。此类名称可能会成为语言的保留名称 `CSharpWarnings::CS8981` `resharper_c_sharp_warnings_cs8981_highlighting`	警告
在部分结构的多个声明中，字段之间没有定义的顺序。要指定顺序，所有实例字段必须在同一声明中。 `CSharpWarnings::CS0282` `resharper_c_sharp_warnings_cs0282_highlighting`	警告
此 ref 赋值的值只能通过 return 语句从当前方法中逃逸。 `CSharpWarnings::CS9093` `resharper_c_sharp_warnings_cs9093_highlighting`	警告
此 ref 赋值的值具有比目标更宽的值逃逸范围，允许通过目标分配具有更窄逃逸范围的值。 `CSharpWarnings::CS9097` `resharper_c_sharp_warnings_cs9097_highlighting`	警告
此 ref 赋值将表达式赋值给具有更窄逃逸范围的变量。 `CSharpWarnings::CS9085` `resharper_c_sharp_warnings_cs9085_highlighting`	警告
此返回的是局部变量的成员的引用，但它不是 ref 局部变量。 `CSharpWarnings::CS9092` `resharper_c_sharp_warnings_cs9092_highlighting`	警告
此返回的是参数的引用，但它不是 ref 参数。 `CSharpWarnings::CS9087` `resharper_c_sharp_warnings_cs9087_highlighting`	警告
此返回的是参数的引用，但它的作用域限定在当前方法。 `CSharpWarnings::CS9088` `resharper_c_sharp_warnings_cs9088_highlighting`	警告
此通过 ref 参数返回参数的引用；但它只能安全地在 return 语句中返回。 `CSharpWarnings::CS9094` `resharper_c_sharp_warnings_cs9094_highlighting`	警告
此返回的是参数的成员的引用，但它不是 ref 或 out 参数。 `CSharpWarnings::CS9089` `resharper_c_sharp_warnings_cs9089_highlighting`	警告
此操作通过引用返回限定于当前方法范围的参数成员。 `CSharpWarnings::CS9090` `resharper_c_sharp_warnings_cs9090_highlighting`	警告
此操作通过 ref 参数按引用返回参数的成员；但只能在 return 语句中安全返回。 `CSharpWarnings::CS9095` `resharper_c_sharp_warnings_cs9095_highlighting`	警告
此操作按引用返回局部变量，但它不是 ref 局部变量。 `CSharpWarnings::CS9091` `resharper_c_sharp_warnings_cs9091_highlighting`	警告
此操作获取托管类型的地址、大小或声明指针。 `CSharpWarnings::CS8500` `resharper_c_sharp_warnings_cs8500_highlighting`	警告
抛出的值可能为 null。 `CSharpWarnings::CS8597` `resharper_c_sharp_warnings_cs8597_highlighting`	警告
类型已在接口列表中列出，但引用类型的可空性不同。 `CSharpWarnings::CS8645` `resharper_c_sharp_warnings_cs8645_highlighting`	警告
此类型仅用于评估目的，可能会在未来更新中更改或移除。 `CSharpWarnings::CS8305` `resharper_c_sharp_warnings_cs8305_highlighting`	警告
此类型仅用于评估目的，可能会在未来更新中更改或移除。抑制此诊断以继续。 `CSharpWarnings::CS9204` `resharper_c_sharp_warnings_cs9204_highlighting`	警告
类型参数在 XML 注释中没有匹配的 typeparam 标签 `CSharpWarnings::CS1712` `resharper_c_sharp_warnings_cs1712_highlighting`	警告
类型参数与外部类型的类型参数同名 `CSharpWarnings::CS0693` `resharper_c_sharp_warnings_cs0693_highlighting`	警告
类型和别名不应命名为 'record' `CSharpWarnings::CS8860` `resharper_c_sharp_warnings_cs8860_highlighting`	警告
无法包含 XML 片段 `CSharpWarnings::CS1589` `resharper_c_sharp_warnings_cs1589_highlighting`	警告
未赋值的字段 `UnassignedField.Compiler` `resharper_unassigned_field_compiler_highlighting`	警告
未赋值的 readonly 字段 `UnassignedReadonlyField.Compiler` `resharper_unassigned_readonly_field_compiler_highlighting`	警告
拆箱可能为 null 的值。 `CSharpWarnings::CS8605` `resharper_c_sharp_warnings_cs8605_highlighting`	警告
未解析的 Shader 名称 `ShaderLabShaderReferenceNotResolved` `resharper_shader_lab_shader_reference_not_resolved_highlighting`	警告
未使用的局部变量 `UnusedVariable.Compiler` `resharper_unused_variable_compiler_highlighting`	警告
在此上下文中使用变量可能会暴露其声明范围之外的引用变量。 `CSharpWarnings::CS9080` `resharper_c_sharp_warnings_cs9080_highlighting`	警告
使用已过时的符号 `CSharpWarnings::CS0618` `resharper_c_sharp_warnings_cs0618_highlighting`	警告
使用已过时的符号（无消息） `CSharpWarnings::CS0612` `resharper_c_sharp_warnings_cs0612_highlighting`	警告
使用 'is' 测试与 'dynamic' 的兼容性本质上与测试与 'Object' 的兼容性相同，并且对于所有非 null 值都将成功。 `CSharpWarnings::CS1981` `resharper_c_sharp_warnings_cs1981_highlighting`	警告
XML 注释中有一个 'param' 标签用于 'Parameter'，但没有该名称的参数 `CSharpWarnings::CS1572` `resharper_c_sharp_warnings_cs1572_highlighting`	警告
XML 注释中有一个 'typeparam' 标签用于 'TypeParameter'，但没有该名称的类型参数 `CSharpWarnings::CS1711` `resharper_c_sharp_warnings_cs1711_highlighting`	警告
XML 注释具有引用类型参数的 cref 属性 `CSharpWarnings::CS1723` `resharper_c_sharp_warnings_cs1723_highlighting`	警告
XML 注释未放置在有效的语言元素上 `CSharpWarnings::CS1587` `resharper_c_sharp_warnings_cs1587_highlighting`	警告

约束违规（11 项检查）

此类别包括代码检查，主要具有警告严重性级别，检测与符号属性相关的违规，包括 JetBrains Rider 的代码注解和其他类似问题。

检查 ID EditorConfig 属性	默认严重性
需要基类型 `RequiredBaseTypesIsNotInherited` `resharper_required_base_types_is_not_inherited_highlighting`	警告
BaseTypeRequired 属性仅支持类和接口 `UnsupportedRequiredBaseType` `resharper_unsupported_required_base_type_highlighting`	警告
命名不一致 `InconsistentNaming` `resharper_inconsistent_naming_highlighting`	警告
命名空间与文件位置不一致 `CheckNamespace` `resharper_check_namespace_highlighting`	警告
不可为空或必需的成员在构造函数退出时未初始化 `NotNullOrRequiredMemberIsNotInitialized` `resharper_not_null_or_required_member_is_not_initialized_highlighting`	警告
可能将 'null' 分配给不可为空的实体 `AssignNullToNotNullAttribute` `resharper_assign_null_to_not_null_attribute_highlighting`	警告
可能违反 'ValueRange'/'NonNegativeValue' 属性 `ValueRangeAttributeViolation` `resharper_value_range_attribute_violation_highlighting`	警告
契约注解定义中存在问题 `ContractAnnotationNotParsed` `resharper_contract_annotation_not_parsed_highlighting`	警告
所需基类型与另一类型冲突 `RequiredBaseTypesConflict` `resharper_required_base_types_conflict_highlighting`	警告
'[BaseTypeRequired]' 属性中指定的类型与另一类型冲突 `RequiredBaseTypesDirectConflict` `resharper_required_base_types_direct_conflict_highlighting`	警告
标记为 'CannotApplyEqualityOperatorAttribute' 的类型值应使用 'Equals()' 进行比较 `CannotApplyEqualityOperatorToType` `无法将相等运算符应用于该类型`	警告

Entity Framework（8 项检查）

此类别分组了验证 Entity Framework及其派生类中类型和成员用法的代码检查。

检查 ID EditorConfig 属性	默认严重性
数据库函数不得在非数据库上下文中调用 `Entity Framework 客户端数据库函数调用` `ReSharper Entity Framework 客户端数据库函数调用的高亮显示`	警告
函数无法转换为 SQL，且不得在数据库上下文中调用 `Entity Framework 不支持的服务器端函数调用` `ReSharper Entity Framework 不支持的服务器端函数调用的高亮显示`	警告
可能对数据库进行多次查询（N+1 问题） `Entity Framework N+1 使用` `ReSharper Entity Framework N+1 使用的高亮显示`	警告
可能对相关实体的数据库进行多次查询（N+1 问题） `Entity Framework N+1 查询` `ReSharper Entity Framework N+1 查询的高亮显示`	建议
无限字符串长度可能导致性能问题 `Entity Framework 模型验证无限字符串长度` `ReSharper Entity Framework 模型验证无限字符串长度的高亮显示`	警告
查询可能返回相关实体的不完整数据 `Entity Framework N+1 不完整数据查询` `ReSharper Entity Framework N+1 不完整数据查询的高亮显示`	建议
此属性定义的关系导致了依赖循环 `Entity Framework 模型验证循环依赖` `ReSharper Entity Framework 模型验证循环依赖的高亮显示`	提示
使用导航属性可能返回不完整数据 `Entity Framework N+1 不完整数据使用` `ReSharper Entity Framework N+1 不完整数据使用的高亮显示`	警告

格式化（41 项检查）

此类别中的检查检测代码格式问题。

检查 ID EditorConfig 属性	默认严重性
不正确的空行（其他地方缺少空行） `缺少空白行` `ReSharper 缺少空白行的高亮显示`	已禁用
不正确的空行（其他地方多余的空行） `多余的空白行` `ReSharper 多余的空白行的高亮显示`	已禁用
不正确的空行（括号附近的空行数量不正确） `大括号附近的空白行不正确` `ReSharper 大括号附近空白行不正确的高亮显示`	已禁用
缩进错误（子语句周围） `子语句缩进错误` `ReSharper 子语句缩进错误的高亮显示`	警告
不正确的缩进（声明括号周围） `声明的大括号缩进错误` `ReSharper 声明的大括号缩进错误的高亮显示`	已禁用
不正确的缩进（表达式括号周围） `表达式的大括号缩进错误` `ReSharper 表达式的大括号缩进错误的高亮显示`	已禁用
不正确的缩进（命名空间括号周围） `命名空间的大括号缩进错误` `ReSharper 命名空间的大括号缩进错误的高亮显示`	已禁用
不正确的缩进（预处理指令周围） `预处理器缩进错误` `ReSharper 预处理器缩进错误的高亮显示`	已禁用
不正确的缩进（语句括号周围） `控制结构的大括号缩进错误` `ReSharper 控制结构的大括号缩进错误的高亮显示`	建议
缩进错误（switch 语句周围） `switch 大括号缩进错误` `ReSharper switch 大括号缩进错误的高亮显示`	已禁用
缩进错误（缩进大小不正确） `缩进大小错误` `ReSharper 缩进大小错误的高亮显示`	已禁用
不正确的缩进（缩进级别未恢复） `缩进偏离上一级` `ReSharper 缩进偏离上一级的高亮显示`	已禁用
不正确的缩进（其他地方缺少缩进/取消缩进） `缺少缩进` `ReSharper 缺少缩进的高亮显示`	已禁用
不正确的缩进（其他地方多余的缩进/取消缩进） `缩进错误` `ReSharper 缩进错误的高亮显示`	已禁用
缩进错误（制表符/空格不匹配） `Tab 和空格不匹配` `ReSharper Tab 和空格不匹配的高亮显示`	已禁用
不正确的换行（列表中的逗号周围） `列表换行错误` `ReSharper 列表换行错误的高亮显示`	已禁用
不正确的换行（声明括号周围） `声明的大括号换行错误` `ReSharper 声明的大括号换行错误的高亮显示`	已禁用
不正确的换行（空括号周围） `空大括号换行错误` `ReSharper 空大括号换行错误的高亮显示`	已禁用
不正确的换行（表达式括号周围） `表达式大括号换行错误` `ReSharper 表达式大括号换行错误的高亮显示`	已禁用
不正确的换行（LINQ 查询周围） `LINQ 换行错误` `ReSharper LINQ 换行错误的高亮显示`	已禁用
不正确的换行（括号周围） `括号换行错误` `ReSharper 括号换行错误的高亮显示`	已禁用
不正确的换行（语句括号周围） `控制结构大括号换行错误` `ReSharper 控制结构大括号换行错误的高亮显示`	已禁用
换行错误（其他地方缺少换行） `缺少换行符` `ReSharper 缺少换行符的高亮显示`	已禁用
不正确的换行符（其他地方的换行符是多余的） `多余的换行符` `ReSharper 多余的换行符的高亮显示`	已禁用
不正确的换行（同一行有多个语句） `一行包含多个语句` `ReSharper 一行包含多个语句的高亮显示`	已禁用
不正确的换行（同一行有多个类型成员） `一行包含多个类型成员` `ReSharper 一行包含多个类型成员的高亮显示`	已禁用
属性周围的间距不正确 `属性方括号间距错误` `ReSharper 属性方括号间距错误的高亮显示`	已禁用
不正确的间距（大括号周围） `大括号间距错误` `ReSharper 大括号间距错误的高亮显示`	已禁用
不正确的间距（冒号周围） `冒号间距错误` `ReSharper 冒号间距错误的高亮显示`	已禁用
不正确的间距（逗号周围） `逗号间距错误` `ReSharper 逗号间距错误的高亮显示`	已禁用
泛型括号周围的间距不正确 `泛型方括号间距错误` `ReSharper 泛型方括号间距错误的高亮显示`	已禁用
不正确的间距（成员访问符号周围） `成员访问间距错误` `ReSharper 成员访问间距错误的高亮显示`	已禁用
不正确的间距（运算符号周围） `符号间距错误` `ReSharper 符号间距错误的高亮显示`	已禁用
不正确的间距（括号周围） `括号间距错误` `Resharper 括号周围空格错误高亮`	已禁用
不正确的间距（分号周围） `分号空格错误` `Resharper 分号空格错误高亮`	已禁用
不正确的间距（语句中的方括号周围） `方括号空格错误` `Resharper 方括号空格错误高亮`	已禁用
不正确的间距（关键字和括号之间） `关键字后空格错误` `Resharper 关键字后空格错误高亮`	已禁用
不正确的间距（禁止多个空格） `多余空格` `Resharper 多余空格高亮`	已禁用
不正确的间距（其他地方缺少空格） `缺少空格` `Resharper 缺少空格高亮`	已禁用
不正确的间距（其他地方的空格是多余的） `冗余空格` `Resharper 冗余空格高亮`	已禁用
此处禁止使用制表符 `缩进之外的制表符` `Resharper 缩进之外的制表符高亮`	已禁用

语法问题（4 项检查）

此类别中的检查报告字符串字面量和文档注释中的语法问题。

检查 ID EditorConfig 属性	默认严重性
注释中的语法错误 `注释中的语法错误` `Resharper 注释中的语法错误高亮`	建议
标记属性值中的语法错误 `标记属性中的语法错误` `Resharper 标记属性中的语法错误高亮`	建议
标记文本中的语法错误 `标记文本中的语法错误` `Resharper 标记文本中的语法错误高亮`	建议
字符串文字中的语法错误 `字符串文本中的语法错误` `Resharper 字符串文本中的语法错误高亮`	已禁用

语言使用机会（85 项检查）

此类别包括代码检查，主要具有建议严重性级别，当可以使用更高级的语言结构时会通知您。这些检查会检测过时语言版本的语法，并建议使用更现代语言版本的功能。对于大多数支持的语言，语言版本可以自动检测或手动设置。

检查 ID EditorConfig 属性	默认严重性
追加到集合表达式 `附加至集合表达式` `Resharper 添加至集合表达式高亮`	建议
类无法实例化 `类无法实例化` `Resharper 类无法实例化高亮`	警告
条件表达式可以重写为 null 合并运算符 `用 Null 合并运算符替换条件表达式` `Resharper 用 Null 合并运算符替换条件表达式高亮`	建议
将 'as' 表达式类型检查及后续的 null 检查转换为取反模式匹配 `使用否定模式匹配` `Resharper 使用否定模式匹配高亮`	提示
将 'as' 表达式类型检查及后续的 null 检查转换为模式匹配 `使用模式匹配` `Resharper 使用模式匹配高亮`	建议
将构造函数转换为成员初始化器 `将构造函数转换为成员初始化器` `Resharper 将构造函数转换为成员初始化器高亮`	建议
将构造函数转换为主构造函数 `转换为主构造函数` `Resharper 转换为主构造函数高亮`	建议
将委托变量转换为局部函数 `转换为局部函数` `Resharper 转换为局部函数高亮`	建议
将 'if' 语句转换为 'switch' `将 if 语句转换为 switch 语句` `Resharper 将 if 语句转换为 switch 语句高亮`	提示
转换为 'await using' 语句或声明 `使用 await using` `Resharper 使用 await using 高亮`	建议
转换为 lambda 表达式 `转换为 Lambda 表达式` `Resharper 转换为 Lambda 表达式高亮`	建议
转换为静态类 `转换为静态类` `Resharper 转换为静态类高亮`	建议
转换为 'using' 声明 `转换为 using 声明` `Resharper 转换为 using 声明高亮`	建议
将 lambda 表达式转换为方法组 `将闭包转换为方法组` `Resharper 将闭包转换为方法组高亮`	建议
将取反的 'is' 表达式转换为带取反模式的 'is' 表达式 `在 is 表达式中使用否定模式` `Resharper 在 is 表达式中使用否定模式高亮`	提示
将 'Nullable<T>' 转换为 'T?' `将 Nullable 转换为简写形式` `Resharper 将 Nullable 转换为简写形式高亮`	建议
将属性转换为自动属性 `转换为自动属性` `Resharper 转换为自动属性高亮`	建议
将属性转换为自动属性（如果可能） `若可行则转换为自动属性` `Resharper 若可行则转换为自动属性高亮`	提示
将属性转换为带私有 setter 的自动属性 `转换为带私有 setter 的自动属性` `Resharper 转换为带私有 setter 的自动属性高亮`	提示
将静态方法调用转换为扩展方法调用 `作为扩展方法调用` `Resharper 作为扩展方法调用高亮`	建议
foreach 循环可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法 `Foreach 可通过其他 GetEnumerator 转换为查询` `Resharper Foreach 可转换为查询（使用其他 GetEnumerator）高亮`	提示
for 循环可以转换为 foreach 循环 `For 可转换为 Foreach` `Resharper For 可转换为 Foreach 高亮`	建议
'if' 语句可以重写为 '?:' 表达式 `将 if 语句转换为三元条件表达式` `Resharper 将 if 语句转换为三元条件表达式高亮`	建议
'if' 语句可以重写为 '??' 表达式 `将 if 语句转换为 Null 合并表达式` `Resharper 将 if 语句转换为 Null 合并表达式高亮`	建议
'if' 语句可以重写为 '??=' 赋值 `将 if 语句转换为 Null 合并赋值` `Resharper 将 if 语句转换为 Null 合并赋值高亮`	建议
'if-return' 语句可以重写为 'return' 语句 `将 if 语句转换为 return 语句` `Resharper 将 if 语句转换为 return 语句高亮`	提示
内联 'out' 变量声明 `内联 out 变量声明` `Resharper 内联 out 变量声明高亮`	建议
内联临时变量 `内联临时变量` `Resharper 内联临时变量高亮`	提示
引入可选参数（非私有可访问性） `引入可选参数（全局）` `Resharper 引入可选参数（全局）高亮`	建议
引入可选参数（私有可访问性） `引入可选参数（局部）` `Resharper 引入可选参数（局部）高亮`	建议
反转 'if' 语句以减少嵌套 `反转 if 语句` `反转 if 语句突出显示`	提示
将 null 检查与赋值合并 `将空值检查与使用合并` `将空值检查与使用合并突出显示`	建议
Lambda 表达式/匿名方法可以设为 'static' `可将 Lambda 表达式设为 static` `可将 Lambda 表达式设为 static 突出显示`	已禁用
Lambda 表达式/匿名方法必须设为 'static' 以避免分配 `必须将 Lambda 表达式设为 static` `必须将 Lambda 表达式设为 static 突出显示`	建议
Lambda 表达式/匿名方法不得捕获包含上下文 `Lambda 不应捕获上下文` `Lambda 不应捕获上下文突出显示`	警告
通过使用逐字字符串可以减少文字长度 `使用逐字字符串` `使用逐字字符串突出显示`	提示
循环可以转换为 LINQ 表达式 `循环可转换为查询` `循环可转换为查询突出显示`	提示
合并 'and' 模式 `合并 And 模式` `合并 And 模式突出显示`	建议
将条件 ?: 表达式合并为条件访问 `合并条件表达式` `合并条件表达式突出显示`	建议
将否定的 null/模式检查合并为复杂模式 `合并为取反模式` `合并为取反模式突出显示`	提示
合并嵌套属性模式 `合并嵌套属性模式` `合并嵌套属性模式突出显示`	建议
将 null/模式检查合并为复杂模式 `合并为模式` `合并为模式突出显示`	建议
将 null/模式/值检查合并为 'or'/'and' 模式 `合并为逻辑模式` `合并为逻辑模式突出显示`	提示
将顺序检查合并为单个条件访问检查 `合并顺序检查` `合并顺序检查突出显示`	提示
移动到现有的定位解构模式 `移动到现有位置解构模式` `移动到现有位置解构模式突出显示`	提示
将变量声明移动到循环条件内 `将变量声明移到循环条件中` `将变量声明移到循环条件中突出显示`	建议
部分 foreach 循环可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法 `foreach 可部分转换为使用另一个 GetEnumerator 的查询` `foreach 可部分转换为使用另一个 GetEnumerator 的查询突出显示`	提示
部分循环体可以转换为 LINQ 表达式 `循环可部分转换为查询` `循环可部分转换为查询突出显示`	已禁用
传递字符串插值表达式 `传递字符串插值` `传递字符串插值突出显示`	提示
冗余的访问器主体 `多余的访问器主体` `多余的访问器主体突出显示`	建议
冗余的扩展元素 `多余的扩展元素` `多余的扩展元素突出显示`	建议
将自动属性替换为计算属性 `将自动属性替换为计算属性` `将自动属性替换为计算属性突出显示`	提示
将 if 语句替换为 null 传播代码 `使用 Null 传播` `使用 Null 传播突出显示`	提示
将未执行任何额外检查的对象模式替换为 'var' 模式 `将对象模式替换为 var 模式` `将对象模式替换为 var 模式突出显示`	建议
将 'SequenceEqual' 替换为常量模式 `将 SequenceEqual 替换为常量模式` `将 SequenceEqual 替换为常量模式突出显示`	建议
将 'Slice' 替换为范围索引器 `将切片替换为 Range 索引器` `将切片替换为 Range 索引器突出显示`	提示
将 'Substring' 替换为范围索引器 `将 Substring 替换为 Range 索引器` `将 Substring 替换为 Range 索引器突出显示`	提示
将 'switch' 语句替换为 'switch' 表达式 `将 switch 语句转换为 switch 表达式` `将 switch 语句转换为 switch 表达式突出显示`	提示
将三元表达式替换为 'switch' 表达式 `将三元条件表达式转换为 switch 表达式` `将三元条件表达式转换为 switch 表达式突出显示`	提示
替换为 'field' 关键字 `替换为 field 关键字` `替换为 field 关键字突出显示`	建议
替换为主构造函数参数 `替换为主构造函数参数` `替换为主构造函数参数突出显示`	建议
使用别名 `使用符号别名` `使用符号别名突出显示`	提示
使用集合表达式语法 `使用集合表达式` `使用集合表达式突出显示`	建议
使用复合赋值 `转换为复合赋值` `转换为复合赋值突出显示`	提示
使用复合赋值 `转换为 Null 合并复合赋值` `转换为 Null 合并复合赋值突出显示`	建议
使用解构 `使用解构` `使用解构突出显示`	提示
使用解构交换变量 `通过解构进行交换` `通过解构进行交换突出显示`	建议
使用丢弃赋值 `使用丢弃赋值` `使用丢弃赋值突出显示`	建议
使用从末尾索引表达式 `使用从末尾的索引表达式` `使用从末尾的索引表达式突出显示`	建议
使用 'nameof' 表达式引用枚举成员名称 `使用 nameof 替代 ToString` `使用 nameof 替代 ToString 突出显示`	建议
使用 'nameof' 表达式引用名称 `使用 nameof 表达式` `使用 nameof 表达式突出显示`	建议
使用 'nameof' 表达式引用字符串文字部分中的名称 `字符串部分使用 nameof 表达式` `字符串部分使用 nameof 表达式突出显示`	已禁用
使用 'nameof' 表达式引用类型名称 `使用 nameof 替代 typeof` `使用 nameof 替代 typeof 突出显示`	建议
在注册 DependencyProperty 时使用 'nameof' 表达式 `将 DependencyProperty 替换为 nameof 表达式` `resharper_use_nameof_for_dependency_property_highlighting`	建议
在可能的情况下使用对象或集合初始化器 `使用对象或集合初始化器` `resharper_use_object_or_collection_initializer_highlighting`	建议
使用位置解构模式 `使用位置解构模式` `resharper_use_positional_deconstruction_pattern_highlighting`	已禁用
使用原始字符串 `使用原始字符串文本` `resharper_use_raw_string_highlighting`	提示
使用字符串插值表达式 `使用字符串内插` `resharper_use_string_interpolation_highlighting`	建议
使用类型注解语法 `使用 nullable 引用类型注解语法` `resharper_use_nullable_reference_types_annotation_syntax_highlighting`	警告
使用无符号右移运算符 '>>>' `使用无符号右移运算符` `resharper_use_unsigned_right_shift_operator_highlighting`	建议
使用 UTF-8 字符串字面量 `使用 UTF-8 字符串文本` `resharper_use_utf8_string_literal_highlighting`	建议
使用 'with' 表达式复制匿名对象 `使用 with 表达式复制匿名对象` `resharper_use_with_expression_to_copy_anonymous_object_highlighting`	建议
使用 'with' 表达式复制记录 `使用 with 表达式复制记录类型` `resharper_use_with_expression_to_copy_record_highlighting`	建议
使用 'with' 表达式复制结构体 `使用 with 表达式复制结构体` `resharper_use_with_expression_to_copy_struct_highlighting`	建议
使用 'with' 表达式复制元组 `使用 with 表达式复制元组` `resharper_use_with_expression_to_copy_tuple_highlighting`	建议

NUnit（30 项检查）

这些检查会检测与 NUnit 测试相关的代码问题。

检查 ID EditorConfig 属性	默认严重性
NUnit。异步测试方法必须返回 Task 或 Task<T> `NUnit 异步方法必须为 Task` `resharper_n_unit_async_method_must_be_task_highlighting`	警告
NUnit。重复的值。 `存在重复值` `resharper_n_unit_duplicate_values_highlighting`	警告
NUnit。被忽略的参数属性。 `使用了被忽略的参数特性` `resharper_n_unit_ignored_parameter_attribute_highlighting`	警告
NUnit。隐式未指定的空值。 `隐式未指定的 null 值` `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。范围边界不正确。 'to' 必须大于或等于 'from'。 `范围的上下边界值不正确` `resharper_n_unit_incorrect_range_bounds_highlighting`	警告
NUnit。范围步长符号不匹配。 `范围步进方向与边界不匹配` `resharper_n_unit_range_step_sign_mismatch_highlighting`	警告
NUnit。 TestCase 属性中缺少参数。 `NUnit TestCase 特性缺少参数` `resharper_n_unit_missing_arguments_in_test_case_attribute_highlighting`	警告
NUnit。测试方法声明中缺少 'CancelAfter' 属性。 `缺少 CancelAfter 特性` `resharper_n_unit_missing_cancel_after_attribute_highlighting`	警告
NUnit。非 void 测试方法缺少预期结果。 `NUnit TestCase 特性需要 ExpectedResult` `resharper_n_unit_test_case_attribute_requires_expected_result_highlighting`	警告
NUnit。属性中未提供任何值。 `未提供测试值` `resharper_n_unit_no_values_provided_highlighting`	警告
NUnit。非公共测试方法。 `非公共方法标记了 Test 特性` `resharper_n_unit_non_public_method_with_test_attribute_highlighting`	警告
NUnit。范围的 'step' 参数值必须为非零。 `范围步进值不能为零` `resharper_n_unit_range_step_value_must_not_be_zero_highlighting`	警告
NUnit。 TestCase 属性中存在多余参数。 `NUnit.RedundantArgumentInTestCaseAttribute` `resharper_n_unit_redundant_argument_in_test_case_attribute_highlighting`	警告
NUnit。多余的参数代替了 ExpectedResult。 `使用参数替代了 ExpectedResult` `resharper_n_unit_redundant_argument_instead_of_expected_result_highlighting`	警告
NUnit。 void 测试方法中存在多余的预期结果。 `NUnit.RedundantExpectedResultInTestCaseAttribute` `resharper_n_unit_redundant_expected_result_in_test_case_attribute_highlighting`	警告
NUnit。指定的属性值生成了过多的测试。 `该特性生成了过多测试` `resharper_n_unit_attribute_produces_too_many_tests_highlighting`	已禁用
NUnit。指定的值与测试参数类型不兼容。 `参数类型与特性不兼容` `resharper_n_unit_parameter_type_is_not_compatible_with_attribute_highlighting`	警告
NUnit。测试用例的 Result 属性与 ExpectedResult 重复。 `TestCaseResult 属性重复了 ExpectedResult` `resharper_n_unit_test_case_result_property_duplicates_expected_result_highlighting`	警告
NUnit。测试用例的 Result 属性已过时。 `TestCaseResult 属性已废弃` `resharper_n_unit_test_case_result_property_is_obsolete_highlighting`	警告
NUnit。测试用例来源必须是字段、属性或方法。 `NUnit.TestCaseSourceMustBeFieldPropertyMethod` `resharper_n_unit_test_case_source_must_be_field_property_method_highlighting`	警告
NUnit。测试用例来源必须是非抽象的并实现 IEnumerable。 `NUnit.TestCaseSourceShouldImplementIEnumerable` `resharper_n_unit_test_case_source_should_implement_i_enumerable_highlighting`	警告
NUnit。测试用例来源必须是静态的。 `NUnit.TestCaseSourceMustBeStatic` `resharper_n_unit_test_case_source_must_be_static_highlighting`	警告
NUnit。使用该步长值无法达到最大范围值。 `范围的终值不可达` `resharper_n_unit_range_to_value_is_not_reachable_highlighting`	警告
NUnit。未为测试方法参数提供值。 `带参数的方法不能使用 Test 特性` `resharper_n_unit_method_with_parameters_and_test_attribute_highlighting`	警告
NUnit。范围内的值与测试参数的类型不匹配。 `Range 特性的边界超出范围` `resharper_n_unit_range_attribute_bounds_are_out_of_range_highlighting`	警告
NUnit.AutoFixture. 参数类型不兼容或参数值不正确。 `AutoFixture 参数类型不正确` `resharper_n_unit_auto_fixture_incorrect_argument_type_highlighting`	警告
NUnit.AutoFixture. 缺少 Test 或 TestFixture 属性。 `缺少 Test 或 TestFixture 特性` `resharper_n_unit_auto_fixture_missed_test_or_test_fixture_attribute_highlighting`	警告
NUnit.AutoFixture. InlineAutoData 属性中存在冗余参数。 `NUnit.AutoFixture.RedundantArgumentInInlineAutoDataAttribute` `resharper_n_unit_auto_fixture_redundant_argument_in_inline_auto_data_attribute_highlighting`	警告

潜在的代码质量问题（222 项检查）

此类别包括检测关键问题（代码异味）的检查，主要具有错误或警告级别。此类别还包括确保本地化支持的检查。

检查 ID EditorConfig 属性	默认严重性
'?:' 表达式的 true 和 false 分支相同 `条件三元表达式的两个分支相同` `条件三元表达式的两个分支相同的高亮显示`	警告
[MustDisposeResource] 注解未从基类构造函数继承，应显式放置 `其基类带有 MustDisposeResource 特性的构造函数未加注解` `其基类带有 MustDisposeResource 特性的构造函数未加注解的高亮显示`	警告
[ThreadStatic] 无法与实例字段一起使用 `实例字段上使用了 ThreadStatic` `实例字段上使用了 ThreadStatic 的高亮显示`	警告
被抑制的可空警告可能隐藏潜在问题 `使用了可为 null 的警告抑制` `使用了可为 null 的警告抑制的高亮显示`	已禁用
抽象或虚拟（可重写）事件从未被调用 `事件从未触发（全局）` `事件从未触发（全局）的高亮显示`	建议
访问已释放的捕获变量 `访问已释放的闭包` `访问已释放的闭包的高亮显示`	警告
在闭包中访问 foreach 变量 `在闭包中访问 foreach 变量` `在闭包中访问 foreach 变量的高亮显示`	警告
访问已修改的捕获变量 `访问被修改的闭包` `访问被修改的闭包的高亮显示`	警告
根据位掩码的值，表达式结果将始终相同 `非常量的相等性表达式具有常量结果` `非常量的相等性表达式具有常量结果的高亮显示`	警告
实际移位计数为零 `移位表达式的实际移位数为零` `移位表达式的实际移位数为零的高亮显示`	警告
文本参数中存在模糊符号 `文本中存在多个解析候选项` `文本中存在多个解析候选项的高亮显示`	警告
层次结构中的注解冲突 `层次结构中的注解冲突` `层次结构中的注解冲突的高亮显示`	警告
条件表达式中的赋值 `条件表达式中包含赋值操作` `条件表达式中包含赋值操作的高亮显示`	警告
异步迭代器调用未使用 'await foreach' `调用异步迭代器但未使用 await foreach` `调用异步迭代器但未使用 await foreach 的高亮显示`	警告
自动属性访问器从未使用（非私有访问权限） `自动属性访问器未被使用（全局）` `自动属性访问器未被使用（全局）的高亮显示`	警告
自动属性访问器从未使用（私有访问权限） `自动属性访问器未被使用（局部）` `自动属性访问器未被使用（局部）的高亮显示`	警告
避免混合使用可变长度的转义序列和文本 `字符串中使用了可变长度的十六进制转义序列` `字符串中使用了可变长度的十六进制转义序列的高亮显示`	警告
避免在返回类型为 'void' 且参数类型为 'System.EventArgs' 的方法和函数中使用 'async' `事件处理方法使用了 async void` `事件处理方法使用了 async void 的高亮显示`	建议
避免在返回类型为 'void' 且没有 'System.EventArgs' 类型参数的方法和函数中使用 'async' `使用 async void 的方法` `使用 async void 的方法的高亮显示`	建议
避免在委托类型返回 'void' 时使用 'async' lambda `使用 async void 的 Lambda` `使用 async void 的 Lambda 的高亮显示`	警告
后备字段已赋值但从未使用 `属性的字段关键字从未使用` `属性的字段关键字从未使用的高亮显示`	警告
后备字段已使用但从未赋值 `属性的字段关键字从未被赋值` `属性的字段关键字从未被赋值的高亮显示`	警告
对未标记 [Flags] 属性的枚举进行按位操作 `未带 Flags 特性的 enum 使用了按位操作符` `未带 Flags 特性的 enum 使用了按位操作符的高亮显示`	警告
调用具有隐式默认参数的基成员 `调用基础方法时使用默认参数` `调用基础方法时使用默认参数的高亮显示`	警告
调用 'base.Equals(...)' 是引用相等 `对 base.Object.Equals 的调用等同于 object.Equals` `对 base.Object.Equals 的调用等同于 object.Equals 的高亮显示`	警告
无法在文本参数中访问静态符号 `文本中存在 static 问题` `文本中存在 static 问题的高亮显示`	警告
无法在文本参数中访问符号 `文本中存在访问权限问题` `文本中存在访问权限问题的高亮显示`	警告
无法解析属性 `属性无法解析` `属性无法解析的高亮显示`	错误
无法解析资源 `资源无法解析` `资源无法解析的高亮显示`	错误
无法解析资源项 `资源项无法解析` `资源项无法解析的高亮显示`	错误
无法在文本参数中解析符号 `文本中存在无法解析的引用` `文本中存在无法解析的引用的高亮显示`	警告
捕获的按引用传递类的字段引用可能导致运行时异常 `引用了 MarshalByRefObject 的地址` `引用了 MarshalByRefObject 的地址的高亮显示`	警告
捕获的主构造函数参数是可变的 `捕获的主构造函数参数是可变的` `捕获的主构造函数参数是可变的高亮显示`	警告
捕获对 'volatile' 字段的引用不会被视为 'volatile' `ref 引用参数为 volatile 字段` `ref 引用参数为 volatile 字段的高亮显示`	警告
字符可能被无意中用作整数 `构造函数中将字符作为整数使用易产生歧义` `构造函数中将字符作为整数使用易产生歧义的高亮显示`	警告
类从未被实例化（非私有访问权限） `类从未被实例化（全局）` `类从未被实例化（全局）的高亮显示`	建议
类从未被实例化（私有访问权限） `类从未被实例化（局部）` `类从未被实例化（局部）的高亮显示`	建议
集合内容从未被查询（非私有访问权限） `集合从未被查询（全局）` `集合从未被查询（全局）的高亮显示`	警告
集合内容从未被查询（私有访问权限） `集合从未被查询（局部）` `集合从未被查询（局部）的高亮显示`	警告
集合从未更新（非私有访问权限） `集合从未被更新（全局）` `集合从未更新（全局）`	警告
集合从未更新（私有访问权限） `集合从未更新（局部）` `集合从未更新（局部）`	警告
存在冲突的 CQRS 特性 `CQRS 属性冲突` `CQRS 属性冲突`	警告
具有非零操作数的常量移位表达式结果为零值 `移位表达式结果为零` `移位表达式结果为零`	警告
协变数组转换 `协变数组转换` `协变数组转换`	警告
CQRS 上下文交叉。 Command 从 Query 上下文中调用。（显示在声明处） `命令入侵声明（全局）` `命令入侵声明（全局）`	警告
CQRS 上下文交叉。 Command 从 Query 上下文中调用。（显示在用法处） `命令入侵使用（全局）` `命令入侵使用（全局）`	警告
CQRS 上下文交叉。 Query 从 Command 上下文中调用。（显示在声明处） `查询入侵声明（全局）` `查询入侵声明（全局）`	警告
CQRS 上下文交叉。 Query 从 Command 上下文中调用。（显示在用法处） `查询入侵使用（全局）` `查询入侵使用（全局）`	警告
已被 'using' 语句捕获的变量的释放 `在 using 变量上调用 Dispose` `在 using 变量上调用 Dispose`	警告
至少一个执行路径中存在除以零 `整数除以零` `整数除以零`	警告
请勿在 'async void' 方法和函数中重新抛出异常 `async void 抛出异常` `async void 抛出异常`	建议
不要在 readonly 字段中存储 SpinLock `readonly 字段中的 SpinLock` `readonly 字段中的 SpinLock`	警告
不要对 'using' 变量使用对象初始化器 `using 语句资源初始化` `using 语句资源初始化`	警告
不要对 'using' 变量使用对象初始化器（对象初始化器表达式在初始化 'using' 变量时可能抛出异常） `using 语句资源初始化表达式` `using 语句资源初始化表达式`	提示
不要在格式字符串的格式说明符后使用右大括号 `格式说明符捕获右大括号` `格式说明符捕获右大括号`	警告
字典/集合初始化中存在重复键 `重复的键集合初始化` `重复的键集合初始化`	警告
重复的链式 'if' 分支 `重复的链式 if 语句体` `重复的链式 if 语句体`	提示
重复的顺序 'if' 分支 `重复的顺序 if 语句体` `重复的顺序 if 语句体`	提示
重复的 'switch' 分支 `重复的 switch 表达式臂` `重复的 switch 表达式臂`	提示
重复的 'switch' 分支 `重复的 switch 区段主体` `重复的 switch 区段主体`	提示
元素可本地化 `可本地化元素` `可本地化元素`	警告
空的一般 catch 子句 `空的通用 catch 子句` `空的通用 catch 子句`	警告
空的 'with' 表达式是多余的 `冗余的 with 表达式` `冗余的 with 表达式`	建议
在显式 unchecked 上下文中调用 'Enumerable.Sum' `可枚举 Sum 在显式 unchecked 上下文中` `可枚举 Sum 在显式 unchecked 上下文中`	警告
浮点数的相等性比较 `使用等值操作符比较浮点数` `使用等值操作符比较浮点数`	警告
转义序列可以简化 `可以简化字符串转义序列` `可以简化字符串转义序列`	提示
事件从未被订阅（非私有访问权限） `事件从未订阅（全局）` `事件从未订阅（全局）`	建议
事件从未被订阅（私有访问权限） `事件从未订阅（局部）` `事件从未订阅（局部）`	建议
事件从未被调用 `事件从未触发` `事件从未触发`	警告
通过匿名委托取消事件订阅 `通过匿名委托取消事件订阅` `通过匿名委托取消事件订阅`	警告
可能是有意重新抛出异常 `可能意图重新抛出异常` `可能意图重新抛出异常`	警告
显式参数传递给具有调用者信息属性的参数 `显式调用者信息参数` `显式调用者信息参数`	警告
提取公共代码 `提取公共分支代码` `提取公共分支代码`	提示
字段隐藏了接口中具有默认实现的属性 `字段隐藏具有默认实现的接口属性` `字段隐藏具有默认实现的接口属性`	警告
指定了格式，但插值字符串表达式不是 IFormattable `插值字符串表达式不是 IFormattable` `插值字符串表达式不是 IFormattable`	警告
函数体过于复杂，无法分析 `函数复杂度溢出` `函数复杂度溢出`	已禁用
函数在所有执行路径上都是递归的 `所有路径上函数递归` `所有路径上函数递归`	警告
函数从不返回 `函数从不返回值` `函数从不返回值`	警告
类型没有析构函数却调用了 'GC.SuppressFinalize' `对无析构函数类型调用 GC.SuppressFinalize` `对无析构函数类型调用 GC.SuppressFinalize`	警告
根据整数分析，启发式不可达的情况 `由于整数分析导致 switch case 不可达` `由于整数分析导致 switch case 不可达`	警告
根据整数分析，启发式不可达的 switch 分支 `由于整数分析导致 switch 分支不可达` `由于整数分析导致 switch 分支不可达`	警告
传递给 'Math.Clamp()' 方法的参数不一致 `Math.Clamp 最小值大于最大值` `Math.Clamp 最小值大于最大值`	警告
获取锁的顺序不一致 `锁获取顺序不一致` `锁顺序不一致的高亮显示`	警告
字段上的同步不一致 `字段同步不一致` `字段同步不一致的高亮显示`	警告
从末尾的索引必须大于零；使用 '^1' 引用最后一个元素 `从末尾索引为零` `从末尾索引为零的高亮显示`	警告
标记为 ServiceContract 的接口应至少声明一个 OperationContract `服务契约未包含操作` `服务契约未包含操作的高亮显示`	警告
无效的 XML 文档注释 `无效的 XML 文档注释` `无效的 XML 文档注释的高亮显示`	警告
调用了多态的类似字段的事件 `类似事件调用的多态字段` `类似事件调用的多态字段的高亮显示`	警告
IQueryable 可能被无意中用作 IEnumerable `可能为无意的 Queryable.AsEnumerable` `可能为无意的 Queryable.AsEnumerable 的高亮显示`	建议
迭代器从不返回 `迭代器未返回` `迭代器未返回的高亮显示`	警告
局部函数隐藏了方法 `本地函数隐藏方法` `本地函数隐藏方法的高亮显示`	警告
局部变量隐藏了成员 `局部变量隐藏成员` `局部变量隐藏成员的高亮显示`	警告
局部变量隐藏了主构造函数参数 `局部变量隐藏主构造函数参数` `局部变量隐藏主构造函数参数的高亮显示`	警告
循环控制变量在循环内从未更改 `循环变量在循环内从未更改` `循环变量在循环内从未更改的高亮显示`	警告
对输出参数的 [HandlesResourceDisposal] 注解无意义 `out 参数带有 HandlesResourceDisposal 特性` `out 参数带有 HandlesResourceDisposal 特性的高亮显示`	警告
对输入参数的 [MustDisposeResource] 注解无意义 `in 参数带有 MustDisposeResource 特性` `in 参数带有 MustDisposeResource 特性的高亮显示`	警告
成员隐藏了外部类的静态成员 `成员隐藏外部类的 static 成员` `成员隐藏外部类 static 成员的高亮显示`	警告
成员初始化的值被忽略 `成员初始化器值被忽略` `成员初始化器值被忽略的高亮显示`	警告
该方法同时从 CQRS 的两个上下文中被调用（显示在声明处） `BothContext 调用声明.Global` `BothContext 调用声明.Global 的高亮显示`	警告
该方法从两个 CQRS 上下文中被调用（在引用中显示） `BothContext 调用使用.Global` `BothContext 调用使用.Global 的高亮显示`	警告
方法被标记为 OperationContract，但包含的类型未标记为 ServiceContract `操作契约未包含服务契约` `操作契约未包含服务契约的高亮显示`	警告
具有可选或 'params' 参数的方法被重载隐藏 `方法重载包含可选参数` `方法重载包含可选参数的高亮显示`	警告
重写方法中可选参数值不匹配 `可选参数层级不匹配` `可选参数层级不匹配的高亮显示`	警告
库代码中异步可释放对象缺少 '.ConfigureAwait(false)' `对异步可释放对象使用 ConfigureAwait(false)` `对异步可释放对象使用 ConfigureAwait(false) 的高亮显示`	已禁用
库代码中缺少 '.ConfigureAwait(false)' `使用 ConfigureAwait(false)` `使用 ConfigureAwait(false) 的高亮显示`	建议
将 shebang 指令移动到文件开头 `Shebang 指令位置错误` `Shebang 指令位置错误的高亮显示`	警告
多次连续调用 'OrderBy' `多个 OrderBy` `多个 OrderBy 的高亮显示`	警告
未访问的字段（非私有访问权限） `未访问的字段.Global` `未访问的字段.Global 的高亮显示`	建议
未访问的字段（私有访问权限） `未访问的字段.Local` `未访问的字段.Local 的高亮显示`	警告
未访问的位置属性（非私有访问权限） `未访问的位置属性.Global` `未访问的位置属性.Global 的高亮显示`	警告
未访问的位置属性（私有访问权限） `未访问的位置属性.Local` `未访问的位置属性.Local 的高亮显示`	警告
实现类中的非公共成员隐藏了接口中的默认实现 `成员隐藏具有默认实现的接口成员` `成员隐藏具有默认实现的接口成员的高亮显示`	警告
在 'GetHashCode()' 中引用了非只读类型成员 `GetHashCode 中包含非 readonly 成员` `GetHashCode 中包含非 readonly 成员的高亮显示`	警告
可空性与层次结构中的注解冲突 `空值注解与 JetBrains.Annotations 冲突` `空值注解与 JetBrains.Annotations 冲突的高亮显示`	警告
可空警告抑制运算符可能与反转的 'is' 表达式混淆 `反转的 is 表达式抑制空值警告` `反转的 is 表达式抑制空值警告的高亮显示`	警告
'Object.ReferenceEquals' 始终为 false，因为它是用值类型调用的 `ReferenceEquals 用于值类型` `ReferenceEquals 用于值类型的高亮显示`	警告
单向操作不得返回值 `带返回类型的 OneWay 操作契约` `带返回类型的 OneWay 操作契约的高亮显示`	警告
可以使用运算符 'is'/'Type Of ... Is ...' `可以使用 is 运算符` `可以使用 is 运算符的高亮显示`	警告
运算符没有匹配的检查运算符 `运算符缺少匹配的 checked 运算符` `运算符缺少匹配的 checked 运算符的高亮显示`	警告
重写的 GetHashCode 调用了基类 'Object.GetHashCode()' `GetHashCode 中调用 base.GetHashCode` `GetHashCode 中调用 base.GetHashCode 的高亮显示`	警告
参数隐藏了成员 `参数隐藏成员` `参数隐藏成员的高亮显示`	警告
参数隐藏了主构造函数参数 `参数隐藏主构造函数参数` `参数隐藏主构造函数参数的高亮显示`	警告
参数名称在部分成员声明之间不同 `局部方法参数名称不匹配` `局部方法参数名称不匹配的高亮显示`	警告
通过接口访问成员时可能存在歧义 `可能的接口成员歧义` `可能的接口成员歧义的高亮显示`	警告
值类型与 'null' 的比较可能存在问题 `带 null 值的非约束泛型进行比较` `与 null 进行比较的泛型参数未受约束`	已禁用
可能的循环构造函数调用 `构造函数初始值设定项中存在循环依赖` `构造函数初始值设定项中存在循环依赖`	警告
可能不正确的双重检查锁定模式实现。可能对检查字段进行多次写入访问。 `双重检查锁中可能存在多次写入权限访问` `双重检查锁中可能存在多次写入权限访问`	警告
可能不正确的双重检查锁定模式实现。读取检查字段的访问。 `双重检查锁中存在读取权限访问` `双重检查锁中存在读取权限访问`	警告
可能的无限继承 `可能存在无限继承` `可能存在无限继承`	警告
可能的分数丢失 `可能丢失小数部分` `可能丢失小数部分`	警告
可能的类型为 'System.Type' 的错误参数 `可能错误地传递了 System 类型参数` `可能错误地传递了 System 类型参数`	警告
可能的错误 'GetType()' 调用 `可能误调用 GetType` `可能误调用 GetType`	警告
可能的多次枚举 `可能存在多次枚举` `可能存在多次枚举`	警告
可能的溢出 `整数变量溢出` `整数变量溢出`	警告
检查上下文中的可能溢出 `受 checked 上下文影响的整数变量溢出` `受 checked 上下文影响的整数变量溢出`	警告
未检查上下文中的可能溢出 `不受 checked 上下文影响的整数变量溢出` `不受 checked 上下文影响的整数变量溢出`	警告
可能的 'System.ArgumentOutOfRangeException'。索引必须是非负整数。 `负索引使用` `负索引使用`	警告
可能的 'System.ArgumentOutOfRangeException'。起始索引必须小于或等于结束索引。 `使用无效范围作为索引` `使用无效范围作为索引`	警告
可能的 'System.InvalidCastException' `可能发生无效强制类型转换异常` `可能发生无效强制类型转换异常`	警告
foreach 循环中可能的 'System.InvalidCastException' `foreach 循环中可能发生无效强制类型转换异常` `foreach 循环中可能发生无效强制类型转换异常`	警告
可能的 'System.InvalidOperationException' `可能发生无效操作异常` `可能发生无效操作异常`	警告
可能的 'System.InvalidOperationException: 集合已被修改' `集合被修改后可能发生无效操作异常` `集合被修改后可能发生无效操作异常`	警告
可能的 'System.NullReferenceException' `可能发生空引用异常` `可能发生空引用异常`	警告
可能由 'new' 表达式创建的未分配对象 `未使用的对象创建语句` `未使用的对象创建语句`	警告
可能的无意引用比较。 `可能是无意的引用比较` `可能是无意的引用比较`	警告
可能在 readonly 变量上调用了非纯结构体方法：在调用之前结构体值始终会被复制 `在 readonly 变量上调用可能具有副作用的方法` `在 readonly 变量上调用可能具有副作用的方法`	警告
可能误导的 'DefaultValueAttribute' 用法以定义可选参数值 `可选参数不当使用 DefaultValue 特性` `可选参数不当使用 DefaultValue 特性`	警告
索引器初始化器前可能缺少逗号 `索引初始值设定项可能漏写逗号` `索引初始值设定项可能漏写逗号`	警告
可能错误使用了 'CancellationToken' `可能错误地使用了 CancellationToken` `可能错误地使用了 CancellationToken`	警告
集合中可能的无意线性搜索 `集合中可能无意执行线性搜索` `集合中可能无意执行线性搜索`	警告
条件调用中可能的无意修改 `条件调用中可能出现无意副作用` `条件调用中可能出现无意副作用`	警告
可能的无意字符串插值而非格式字符串模板 `字符串插值中可能错误使用了插入操作` `字符串插值中可能错误使用了插入操作`	警告
可能的字符串比较错误：只有在指向相同内存位置时，跨度才相等 `字符串与 Span 比较` `字符串与 Span 比较`	警告
Lambda 或局部函数中可能具有误导性的参数名称 `局部参数名称仅包含下划线` `局部参数名称仅包含下划线`	警告
建议显式提供元组组件名称 `应明确提供元组组件名称` `应明确提供元组组件名称`	提示
不允许捕获主构造函数参数 `主构造函数参数捕获不被允许` `主构造函数参数捕获不被允许`	已禁用
带有 [Optional] 属性的 'ref' 或 'out' 参数 `可选参数不能是 ref 或 out` `可选参数不能是 ref 或 out`	警告
返回由 'using' 捕获的对象生成的任务 `返回使用 using 变量创建的 Task` `返回使用 using 变量创建的 Task`	警告
返回由 'using' 语句捕获的变量 `返回 using 变量` `返回 using 变量`	警告
函数的返回类型可以设为非可空 `返回类型可以设为非可空` `返回类型可以设为非可空`	警告
未使用带有 [MustUseReturnValue] 注解的方法的返回值 `必须使用返回值` `必须使用返回值`	警告
带有 [MustDisposeResource] 注解的方法的返回值从未被释放 `未释放资源` `未释放资源`	警告
属性的返回值必须由调用方释放 `资源未释放并由属性返回` `资源未释放并由属性返回`	警告
'GetEnumerator' 方法调用的返回值从未被释放 `泛型枚举器未被释放` `泛型枚举器未被释放`	警告
未使用迭代器的返回值 `迭代器方法的结果被忽略` `迭代器方法的结果被忽略`	警告
未使用纯方法的返回值 `纯方法的返回值未使用` `纯方法的返回值未使用`	警告
返回值应被释放，但方法或函数未带有 [MustDisposeResource] 注解 `资源未释放但被返回` `返回了未释放的资源`	建议
安全类型转换表达式始终成功 `转换始终成功` `始终成功的类型转换`	建议
左操作数为零的移位表达式等于零 `左操作数为零的移位表达式` `左操作数为零的移位表达式`	警告
附近检测到相似的匿名类型 `附近存在相似的匿名类型` `附近存在相似的匿名类型`	提示
相似表达式比较 `相等表达式的比较` `相等表达式的比较`	警告
枚举的一些值未在 'switch' 表达式中处理，而是通过默认分支中的异常处理 `SwitchExpressionHandlesSomeKnownEnumValuesWithExceptionInDefault` `resharper_switch_expression_handles_some_known_enum_values_with_exception_in_default_highlighting`	提示
枚举的一些值未在 'switch' 语句中处理 `SwitchStatementMissingSomeEnumCasesNoDefault` `resharper_switch_statement_missing_some_enum_cases_no_default_highlighting`	提示
枚举的一些值未在 'switch' 语句中处理，而是通过默认分支处理 `SwitchStatementHandlesSomeKnownEnumValuesWithDefault` `resharper_switch_statement_handles_some_known_enum_values_with_default_highlighting`	提示
泛型类型中的静态字段或自动属性 `泛型类型中的静态成员` `泛型类型中的静态成员`	警告
静态成员初始化器引用了下面或其他部分的静态成员 `静态成员初始化器引用了下面定义的成员` `静态成员初始化器引用了下面定义的成员`	警告
字符串格式化方法问题 `格式字符串存在问题` `格式字符串存在问题`	警告
结构化日志消息项重复或仅大小写不同 `日志模板中存在重复项` `日志模板中存在重复项`	警告
结构化消息模板问题 `结构化消息模板存在问题` `结构化消息模板存在问题`	警告
同步原语上的可疑锁定 `对同步基元加锁存在可疑操作` `对同步基元加锁存在可疑操作`	警告
ArgumentNullException 中的可疑参数名称 `SuspiciousParameterNameInArgumentNullException` `resharper_suspicious_parameter_name_in_argument_null_exception_highlighting`	警告
此类型左操作数的可疑移位计数 `移位表达式的右操作数与实际位数不符` `移位表达式的右操作数与实际位数不符`	警告
可疑的类型转换或检查 `可疑的类型转换（全局）` `可疑的类型转换（全局）`	警告
使用具有丢弃样式名称的变量的可疑用法 `AssignmentInsteadOfDiscard` `resharper_assignment_instead_of_discard_highlighting`	警告
可疑的 'volatile' 字段使用：复合操作不是原子的。 'Interlocked' 类可以代替使用。 `非原子的复合操作符` `非原子的复合操作符`	警告
模块中的符号可能在运行时丢失 `使用了未在本地复制的引用中的符号` `使用了未在本地复制的引用中的符号`	警告
尾递归调用可以替换为循环 `尾递归调用` `尾递归调用`	提示
'is' 运算符的表达式永远不是提供的类型 `IsExpressionAlwaysFalse` `resharper_is_expression_always_false_highlighting`	警告
'is' 运算符的给定表达式始终是提供的类型 `IsExpressionAlwaysTrue` `resharper_is_expression_always_true_highlighting`	警告
模式是多余的，不会产生任何运行时检查 `模式冗余` `模式冗余`	警告
源表达式始终匹配提供的模式 `模式始终匹配` `模式始终匹配`	警告
源表达式从不匹配提供的模式 `模式永不匹配` `模式永不匹配`	警告
线程静态字段具有初始化器 `ThreadStaticFieldHasInitializer` `resharper_thread_static_field_has_initializer_highlighting`	警告
尝试转换并检查 null 可以替换为类型检查 `使用安全转换进行类型检查` `使用安全转换进行类型检查`	建议
类型检查和转换可以合并 `将类型检查与转换合并` `将类型检查与转换合并`	建议
类型模式和转换可以合并 `UseSwitchCasePatternVariable` `resharper_use_switch_case_pattern_variable_highlighting`	建议
未赋值的字段（非私有访问权限） `字段未赋值（全局）` `字段未赋值（全局）`	建议
未赋值的字段（私有访问权限） `字段未赋值（局部）` `字段未赋值（局部）`	警告
未赋值的 readonly 字段 `UnassignedReadonlyField` `resharper_unassigned_readonly_field_highlighting`	警告
未识别的 CQRS 实体 `存在多个 CQRS 实体` `存在多个 CQRS 实体`	警告
未知的 Razor 布局 `无法解析 Razor 布局` `无法解析 Razor 布局`	错误
未知的 Razor 部分 `无法解析 Razor 分节` `无法解析 Razor 分节`	错误
<inheritdoc /> 的使用无效 `InheritdocInvalidUsage` `resharper_inheritdoc_invalid_usage_highlighting`	警告
在根级别使用 <inheritdoc /> 从基候选项继承文档 `InheritdocConsiderUsage` `resharper_inheritdoc_consider_usage_highlighting`	已禁用
使用集合的 count 属性 `建议使用集合的 Count 属性` `建议使用集合的 Count 属性`	建议
在格式字符串中使用格式说明符 `应在格式字符串中使用格式说明符` `应在格式字符串中使用格式说明符`	建议
在插值字符串中使用格式说明符 `简化字符串插值` `简化字符串插值`	建议
使用空值检查代替对任何非空值成功的类型检查 `将类型检查转换为 null 检查` `将类型检查转换为 null 检查`	警告
使用空值检查模式代替对任何非空值成功的类型检查 `将模式类型检查转换为 null 检查` `将模式类型检查转换为 null 检查`	警告
使用可空注解代替属性 `使用可空性注解代替特性` `resharper_use_nullable_annotation_instead_of_attribute_highlighting`	建议
无用的算术运算 `无用的二元操作` `resharper_useless_binary_operation_highlighting`	警告
在循环中使用 stackalloc `循环中的 StackAlloc 调用` `resharper_stack_alloc_inside_loop_highlighting`	警告
分配给非变量限定符表达式的属性的值可能会丢失 `非变量结构的结构成员可能被修改` `resharper_possible_struct_member_modification_of_non_variable_struct_highlighting`	警告
'value' 参数未被使用 `未使用的值参数` `resharper_value_parameter_not_used_highlighting`	警告
变量可以声明为非可空 `变量可以为非可空类型` `resharper_variable_can_be_not_nullable_highlighting`	警告
局部函数中的变量隐藏了外部作用域中的变量 `变量隐藏了外部变量` `resharper_variable_hides_outer_variable_highlighting`	警告
在构造函数中调用虚成员 `构造函数中调用虚成员` `resharper_virtual_member_call_in_constructor_highlighting`	警告
'void' 方法带有 [MustDisposeResource] 属性注解 `具有 MustDisposeResource 特性的 void 方法` `resharper_void_method_with_must_dispose_resource_attribute_highlighting`	警告
'void' 方法带有 [MustUseReturnValue] 属性注解 `具有 MustUseReturnValue 特性的 void 方法` `resharper_void_method_with_must_use_return_value_attribute_highlighting`	警告
'void' 方法带有 [Pure] 属性注解 `void 方法上出现 Pure 特性` `resharper_pure_attribute_on_void_method_highlighting`	警告
'with' 表达式被用来代替对象初始化器 `使用 with 表达式而非初始化器` `resharper_with_expression_instead_of_initializer_highlighting`	建议
'with' 表达式修改了所有可访问的实例成员 `with 表达式修改全部成员` `resharper_with_expression_modifies_all_members_highlighting`	警告

代码中的冗余（101 项检查）

此类别中的代码检查查找冗余和无用代码，这些代码会影响代码的可读性和样式，可以安全地删除。某些代码冗余无法自动修复，针对这些冗余的快速修复将在交互模式下执行，需要用户输入。但大多数冗余可以在无需用户交互的情况下修复，使用范围内修复或代码清理。

检查 ID EditorConfig 属性	默认严重性
'??' 条件已知为 null 或非 null `常量空合并条件` `resharper_constant_null_coalescing_condition_highlighting`	警告
根据可空引用类型的注解，'??' 条件永远不会为 null `根据 API 合约，空合并条件始终为非空` `resharper_null_coalescing_condition_is_always_not_null_according_to_api_contract_highlighting`	警告
[NotNull] 或 [CanBeNull] 属性应用于已具有相同可空引用类型注解的类型 `可空引用类型使用了冗余的 Nullness 特性` `resharper_redundant_nullness_attribute_with_nullable_reference_types_highlighting`	警告
匿名方法签名不是必需的 `未使用的匿名方法签名` `resharper_unused_anonymous_method_signature_highlighting`	警告
数组创建可以替换为数组初始化器 `冗余的数组创建表达式` `resharper_redundant_array_creation_expression_highlighting`	提示
赋值未被使用 `冗余的赋值` `resharper_redundant_assignment_highlighting`	警告
赋值结果被完全丢弃 `赋值被完全丢弃` `resharper_assignment_is_fully_discarded_highlighting`	警告
与整型常量的比较是无用的 `对整数常量的无效比较` `resharper_useless_comparison_to_integral_constant_highlighting`	警告
条件访问限定符表达式已知为 null 或非 null `恒定的条件访问限定符` `resharper_constant_conditional_access_qualifier_highlighting`	警告
根据可空引用类型的注解，条件访问限定符表达式不是 null `根据 API 合约，条件访问限定符为非可空` `resharper_conditional_access_qualifier_is_non_nullable_according_to_api_contract_highlighting`	警告
在将项添加到字典之前调用 'ContainsKey' 是多余的 `添加前检查 Dictionary 的 ContainsKey 是多余的` `resharper_redundant_dictionary_contains_key_before_adding_highlighting`	警告
多余的 CQRS 特性，可移除 `冗余的 Cqrs 特性` `resharper_redundant_cqrs_attribute_highlighting`	警告
双重否定运算符 `双重取反运算符` `resharper_double_negation_operator_highlighting`	建议
重复的语句 `重复的语句` `resharper_duplicated_statements_highlighting`	警告
空的 'for' 循环是多余的 `空的 for 语句` `resharper_empty_for_statement_highlighting`	警告
空区域 `空的 #region` `resharper_empty_region_highlighting`	建议
显式委托创建表达式是多余的 `冗余的委托创建` `resharper_redundant_delegate_creation_highlighting`	警告
表达式始终为 'null' `表达式始终为 null` `resharper_expression_is_always_null_highlighting`	警告
表达式始终为 'true' 或始终为 'false' `条件始终为 true 或 false` `resharper_condition_is_always_true_or_false_highlighting`	警告
根据可空引用类型的注解，表达式始终为 'true' 或 'false' `根据可空 API 合约，条件始终为 true 或 false` `resharper_condition_is_always_true_or_false_according_to_nullable_api_contract_highlighting`	警告
启发式不可达代码 `推测的不可达代码` `resharper_heuristic_unreachable_code_highlighting`	警告
立即委托调用 `冗余的立即委托调用` `resharper_redundant_immediate_delegate_invocation_highlighting`	建议
Math.Abs() 参数始终为非负数 `Math.Abs 方法是多余的` `resharper_math_abs_method_is_redundant_highlighting`	警告
Math.Sign() 方法始终返回相同的结果 `可疑的 Math.Sign 方法` `resharper_suspicious_math_sign_method_highlighting`	警告
如果属性没有参数，则括号是多余的 `冗余的特性括号` `resharper_redundant_attribute_parentheses_highlighting`	提示
模式始终为 'true' 或始终为 'false' `模式始终为 true 或 false` `resharper_pattern_is_always_true_or_false_highlighting`	警告
私有字段可以转换为局部变量 `私有字段可转换为局部变量` `resharper_private_field_can_be_converted_to_local_variable_highlighting`	警告
原始字符串可以简化 `原始字符串可以简化` `resharper_raw_string_can_be_simplified_highlighting`	提示
冗余的 [AttributeUsage] 属性属性赋值 `多余的 AttributeUsage 属性` `resharper_redundant_attribute_usage_property_highlighting`	建议
多余的 'abstract' 修饰符 `多余的 abstract 修饰符` `resharper_redundant_abstract_modifier_highlighting`	警告
多余的匿名类型属性显式名称 `匿名类型属性名称多余` `resharper_redundant_anonymous_type_property_name_highlighting`	警告
传递给调用者参数表达式参数的冗余参数 `多余的 CallerArgumentExpression 默认值` `resharper_redundant_caller_argument_expression_default_value_highlighting`	警告
具有默认值的多余参数 `多余的参数默认值` `resharper_redundant_argument_default_value_highlighting`	警告
多余的算术溢出检查上下文 `多余的溢出检查上下文` `resharper_redundant_overflow_checking_context_highlighting`	警告
多余的 'Attribute' 后缀 `多余的 Attribute 后缀` `resharper_redundant_attribute_suffix_highlighting`	警告
多余的 'base.' 限定符 `多余的 base 限定符` `resharper_redundant_base_qualifier_highlighting`	警告
多余的布尔比较 `多余的布尔比较` `resharper_redundant_bool_compare_highlighting`	警告
集合初始化器中的多余大括号 `集合初始值设定项元素的大括号多余` `resharper_redundant_collection_initializer_element_braces_highlighting`	提示
多余的 'case' 标签 `多余的 case 标签` `resharper_redundant_case_label_highlighting`	警告
默认部分之前的多余 'case' 标签 `default 部分中多余的枚举 case 标签` `resharper_redundant_enum_case_label_for_default_section_highlighting`	已禁用
冗余的强制转换 `多余的强制转换` `resharper_redundant_cast_highlighting`	警告
多余的 catch 子句 `多余的 catch 子句` `resharper_redundant_catch_clause_highlighting`	警告
记录声明中多余的 'class' 关键字 `多余的 record class 关键字` `resharper_redundant_record_class_keyword_highlighting`	警告
多余的集合复制 `多余的集合 Copy 调用` `resharper_redundant_collection_copy_call_highlighting`	警告
赋值前的多余条件检查 `赋值前多余的检查` `resharper_redundant_check_before_assignment_highlighting`	警告
多余的条件三元表达式使用 `多余的三元表达式` `resharper_redundant_ternary_expression_highlighting`	警告
使用 'ConfigureAwait' 捕获上下文的多余操作 `多余的 ConfigureAwait` `resharper_redundant_configure_await_highlighting`	建议
冗余的控制流跳转语句 `多余的跳转语句` `resharper_redundant_jump_statement_highlighting`	警告
多余的丢弃符号指定 `多余的丢弃标识符` `resharper_redundant_discard_designation_highlighting`	建议
冗余的 'else' 关键字 `多余的 if-else 代码块` `resharper_redundant_if_else_block_highlighting`	提示
对象创建表达式中多余的空参数列表 `对象创建中多余的空参数列表` `resharper_redundant_empty_object_creation_argument_list_highlighting`	提示
多余的空 finally 块 `多余的空 finally 块` `resharper_redundant_empty_finally_block_highlighting`	警告
多余的空对象或集合初始化器 `多余的空对象或集合初始值设定项` `Resharper：冗余的空对象或集合初始化高亮显示`	警告
多余的空 switch 部分 `冗余的空 switch 区段` `Resharper：冗余的空 switch 区段高亮显示`	警告
在 'params' 参数的参数中冗余的显式集合创建 `冗余的显式 params 数组创建` `Resharper：冗余的显式 params 数组创建高亮显示`	建议
冗余的显式可空类型创建 `冗余的显式 Nullable 类型创建` `Resharper：冗余的显式 Nullable 类型创建高亮显示`	警告
冗余的显式位置属性声明 `冗余的显式位置属性声明` `Resharper：冗余的显式位置属性声明高亮显示`	警告
冗余的显式数组大小指定 `冗余的显式数组大小` `Resharper：冗余的显式数组大小高亮显示`	警告
冗余的显式元组组件名称 `冗余的显式元组组件名称` `Resharper：冗余的显式元组组件名称高亮显示`	警告
在数组创建中冗余的显式类型 `冗余的显式数组创建` `Resharper：冗余的显式数组创建高亮显示`	警告
冗余的固定指针声明 `冗余的 fixed 指针声明` `Resharper：冗余的 fixed 指针声明高亮显示`	建议
冗余的全局 using 指令 `冗余的全局 using 指令` `Resharper：冗余的全局 using 指令高亮显示`	警告
冗余的 'IEnumerable.Cast<T>' 或 'IEnumerable.OfType<T>' 调用 `冗余的 Enumerable.Cast 调用` `Resharper：冗余的 Enumerable.Cast 调用高亮显示`	警告
冗余的 lambda 表达式参数类型指定 `冗余的 Lambda 参数类型` `Resharper：冗余的 Lambda 参数类型高亮显示`	警告
冗余的 lambda 签名括号 `冗余的 Lambda 括号` `Resharper：冗余的 Lambda 括号高亮显示`	提示
冗余的名称限定符 `冗余的名称修饰符` `Resharper：冗余的名称修饰符高亮显示`	警告
在由非可空基类型约束的类型参数上冗余的 'notnull' 约束 `冗余的 NotNull 约束` `Resharper：冗余的 NotNull 约束高亮显示`	警告
在由另一个非可空基类型约束的类型参数的基类型约束上冗余的可空注解 `类型约束具有非 Nullable 基类型时的冗余 Nullable 注解` `Resharper：类型约束具有非 Nullable 基类型时的冗余 Nullable 注解高亮显示`	警告
在具有非可空类型种类的类型参数的基类型约束上冗余的可空注解 `类型约束具有非 Nullable 类型种类时的冗余 Nullable 注解` `Resharper：类型约束具有非 Nullable 类型种类时的冗余 Nullable 注解高亮显示`	警告
在由非可空基类型约束的类型参数的 'class?' 约束上冗余的可空注解 `引用类型约束中的冗余 Nullable 注解` `Resharper：引用类型约束中的冗余 Nullable 注解高亮显示`	警告
冗余的可空属性 `冗余的 NullableFlow 属性` `Resharper：冗余的 NullableFlow 属性高亮显示`	警告
冗余的可空指令 `冗余的 Nullable 指令` `Resharper：冗余的 Nullable 指令高亮显示`	警告
冗余的可空警告抑制表达式 `冗余的取消 Nullable 警告表达式` `Resharper：冗余的取消 Nullable 警告表达式高亮显示`	警告
冗余的 'object.ToString()' 调用 `冗余的 ToString 调用` `Resharper：冗余的 ToString 调用高亮显示`	警告
对于值类型的 'object.ToString()' 调用冗余 `值类型上的冗余 ToString 调用` `Resharper：值类型上的冗余 ToString 调用高亮显示`	提示
逻辑条件表达式中的冗余操作数 `逻辑条件表达式中冗余的操作数` `Resharper：逻辑条件表达式中冗余的操作数高亮显示`	警告
在 'orderby' 子句中的 'ascending' 关键字冗余 `查询中的冗余升序排序关键字` `Resharper：查询中的冗余升序排序关键字高亮显示`	提示
冗余的属性模式子句 `冗余的属性模式子句` `Resharper：冗余的属性模式子句高亮显示`	建议
冗余的范围边界 `冗余的范围边界` `Resharper：冗余的范围边界高亮显示`	建议
多余的 'readonly' 修饰符 `冗余的 readonly 修饰符` `Resharper：冗余的 readonly 修饰符高亮显示`	建议
多余的 'scoped' 参数修饰符 `冗余的 scoped 参数修饰符` `Resharper：冗余的 scoped 参数修饰符高亮显示`	警告
类型或命名空间声明后的多余分号 `冗余的声明分号` `Resharper：冗余的声明分号高亮显示`	提示
多余的字符串插值 `冗余的字符串插值` `Resharper：冗余的字符串插值高亮显示`	建议
多余的 'string.Format()' 调用 `冗余的 String.Format 调用` `Resharper：冗余的 String.Format 调用高亮显示`	警告
多余的 'string.ToCharArray()' 调用 `冗余的 ToCharArray 调用` `Resharper：冗余的 ToCharArray 调用高亮显示`	警告
多余的 'switch' 表达式分支 `冗余的 switch 表达式分支` `Resharper：冗余的 switch 表达式分支高亮显示`	警告
'nameof' 中的多余类型参数 `nameof 表达式中的冗余类型参数` `Resharper：nameof 表达式中的冗余类型参数高亮显示`	建议
方法的多余类型参数 `方法的冗余类型参数` `Resharper：方法的冗余类型参数高亮显示`	警告
模式中的多余类型检查 `模式中的冗余类型检查` `Resharper：模式中的冗余类型检查高亮显示`	警告
多余的类型声明体 `冗余的类型声明体` `Resharper：冗余的类型声明体高亮显示`	建议
冗余的 using 指令 `冗余的 using 指令` `Resharper：冗余的 using 指令高亮显示`	警告
多余的逐字前缀 `冗余的逐字前缀` `Resharper：冗余的逐字前缀高亮显示`	建议
多余的逐字字符串前缀 `冗余的逐字字符串前缀` `Resharper：冗余的逐字字符串前缀高亮显示`	建议
多余的 'virtual' 修饰符 `冗余的 virtual 修饰符` `ReSharper 冗余 virtual 修饰符高亮`	警告
多余的 'WithCancellation()' 调用 `带取消标记的冗余实现` `ReSharper 带取消标记的冗余实现高亮`	警告
移除多余的模式匹配括号 `冗余的模式括号` `ReSharper 冗余的模式括号高亮`	提示
总是匹配的子模式是多余的 `始终匹配的子模式是冗余的` `ReSharper 始终匹配的子模式冗余高亮`	建议
'true' 作为 'for' 语句条件是多余的 `for 语句条件恒为 true` `ReSharper for 语句条件恒为 true 高亮`	警告
对可空类型的类型检查等同于对基础类型的检查 `冗余的可为 null 类型标记` `ReSharper 冗余的可为 null 类型标记高亮`	警告
不安全上下文声明是多余的 `冗余的 unsafe 上下文` `ReSharper 冗余的 unsafe 上下文高亮`	警告
未使用的可空指令 `未使用的可空性指令` `ReSharper 未使用的可空性指令高亮`	警告

符号声明中的冗余（51 项检查）

此类别包括代码检查，主要是警告严重级别，用于检测空的和未使用的符号声明。

检查 ID EditorConfig 属性	默认严重性
具有虚拟（可重写）成员的类从未被继承（非私有访问权限） `包含 virtual 成员但从未被继承的类（全局）` `ReSharper 包含 virtual 成员但从未被继承的类（全局）高亮`	建议
具有虚拟（可重写）成员的类从未被继承（私有访问权限） `包含 virtual 成员但从未被继承的类（局部）` `ReSharper 包含 virtual 成员但从未被继承的类（局部）高亮`	建议
元组的组件从未使用 `返回值中的元组组件未使用` `ReSharper 返回值中的未使用元组组件高亮`	警告
'DefaultParameterValueAttribute' 必须与 'OptionalAttribute' 一起使用 `无意义的默认参数值` `ReSharper 无意义的默认参数值高亮`	警告
空构造函数 `空构造函数` `ReSharper 空构造函数高亮`	警告
空析构函数 `空析构函数` `ReSharper 空析构函数高亮`	警告
'partial void' 方法的空实现是多余的 `冗余的 partial 方法空实现` `ReSharper 冗余的 partial 方法空实现高亮`	警告
空命名空间声明 `空命名空间` `ReSharper 空命名空间高亮`	警告
实体仅用于捕获其名称（非私有访问权限） `仅在捕获上下文中使用的实体名称（全局）` `ReSharper 仅在捕获上下文中使用的实体名称（全局）高亮`	警告
实体仅用于捕获其名称（私有访问权限） `仅在本地捕获的实体名称` `ReSharper 本地实体名称捕获高亮显示`	警告
局部函数从未使用 `未使用的本地函数` `ReSharper 未使用的本地函数高亮显示`	警告
局部函数从未使用 `未使用的本地函数（编译器）` `ReSharper 未使用的本地函数（编译器）高亮显示`	警告
局部函数的返回值从未使用 `未使用的本地函数返回值` `ReSharper 未使用的本地函数返回值高亮显示`	警告
方法返回值从未被使用（非私有访问权限） `未使用的方法返回值（全局）` `ReSharper 未使用的方法返回值（全局）高亮显示`	建议
方法返回值从未被使用（私有访问权限） `未使用的方法返回值（本地）` `ReSharper 未使用的方法返回值（本地）高亮显示`	警告
未访问的局部变量 `未访问的变量` `ReSharper 未访问的变量高亮显示`	警告
未访问的局部变量仅用于丢弃 'out' 参数值 `未访问的 out 参数变量` `ReSharper 未访问的 out 参数变量高亮显示`	警告
未访问的主构造函数参数 `未访问的主构造函数参数（编译器）` `ReSharper 未访问的主构造函数参数（编译器）高亮显示`	警告
参数仅用于前置条件检查（非私有访问权限） `只用于前置条件检查的参数（全局）` `ReSharper 仅用于前置条件检查的参数（全局）高亮显示`	建议
参数仅用于前置条件检查（私有访问权限） `只用于前置条件检查的参数（本地）` `ReSharper 仅用于前置条件检查的参数（本地）高亮显示`	警告
参数输出值始终被丢弃（非私有访问权限） `out 参数值始终被丢弃（全局）` `ReSharper out 参数值始终被丢弃（全局）高亮显示`	建议
参数输出值始终被丢弃（私有访问权限） `out 参数值始终被丢弃（本地）` `ReSharper out 参数值始终被丢弃（本地）高亮显示`	警告
'params' 修饰符在重写中始终被忽略 `冗余的 params` `ReSharper 冗余的 params 高亮显示`	警告
多余的特性 [SetsRequiredMembers] `冗余的 SetsRequiredMembers 特性` `ReSharper 冗余的 SetsRequiredMembers 特性高亮显示`	警告
多余的基构造函数调用 `冗余的基构造函数调用` `ReSharper 冗余的基构造函数调用高亮显示`	警告
基类型列表中多余的类或接口规范 `冗余的扩展列表项` `ReSharper 冗余的扩展列表项高亮显示`	警告
多余的成员初始化器 `冗余的默认成员初始化` `ReSharper 冗余的默认成员初始化高亮显示`	警告
多余的成员重写 `冗余的重写成员` `ReSharper 冗余的重写成员高亮显示`	警告
冗余的方法重载（非私有可访问性） `冗余的重载（全局）` `ReSharper 冗余的重载（全局）高亮显示`	建议
冗余的方法重载（私有可访问性） `冗余的重载（本地）` `ReSharper 冗余的重载（本地）高亮显示`	建议
方法声明中的冗余 'partial' 修饰符 `仅含一个部件的局部方法` `ReSharper 仅含一个部件的局部方法高亮显示`	警告
类型声明中的冗余 'partial' 修饰符 `仅含一个部件的局部类型` `ReSharper 仅含一个部件的局部类型高亮显示`	警告
密封类中的密封成员 `密封类中的密封成员` `ReSharper 密封类中的密封成员高亮显示`	警告
类型从未使用（非私有访问权限） `未使用的类型（全局）` `ReSharper 未使用的类型（全局）高亮显示`	建议
类型从未使用（私有访问权限） `未使用的类型（本地）` `ReSharper 未使用的类型（本地）高亮显示`	警告
类型成员从未通过基类型访问（非私有访问权限） `超类中未使用的成员（全局）` `ReSharper 超类中未使用的成员（全局）高亮显示`	建议
类型成员从未通过基类型访问（私有访问权限） `超类中未使用的成员（本地）` `ReSharper 超类中未使用的成员（本地）高亮显示`	警告
类型成员从未使用（非私有访问权限） `未使用的成员（全局）` `ReSharper 未使用的成员（全局）高亮显示`	建议
类型成员从未使用（私有访问权限） `未使用的成员（本地）` `ReSharper 未使用的成员（本地）高亮显示`	警告
类型成员仅在重写中使用（非私有访问权限） `未使用的成员层级（全局）` `ReSharper 未使用的成员层级（全局）高亮显示`	建议
类型成员仅在重写中使用（私有访问权限） `未使用的成员层级（本地）` `ReSharper 未使用的成员层级（本地）高亮显示`	警告
枚举的基础类型为 'int' `枚举基础类型为 int` `ReSharper 枚举基础类型为 int 高亮显示`	警告
未使用的标签 `未使用的标签` `ReSharper 未使用的标签高亮显示`	警告
未使用的局部变量 `未使用的变量` `ReSharper 未使用的变量高亮显示`	警告
未使用的参数（非私有访问权限） `未使用的参数（全局）` `ReSharper 未使用的参数（全局）高亮显示`	建议
未使用的参数（私有访问权限） `未使用的参数（本地）` `ReSharper 未使用的参数（本地）高亮显示`	警告
部分方法中未使用的参数 `局部方法中未使用的参数` `ReSharper 局部方法中未使用的参数高亮显示`	警告
未使用的位置参数 `未使用的位置参数（编译器）` `ReSharper 未使用的位置参数（编译器）高亮显示`	警告
未使用的类型参数 `未使用的类型参数` `ReSharper 未使用的类型参数高亮显示`	警告
虚拟（可重写）成员从未被重写（非私有访问权限） `虚成员从未被重写（全局）` `ReSharper 虚成员从未被重写（全局）高亮显示`	建议
虚拟（可重写）成员从未被重写（私有访问权限） `虚成员从未被重写（本地）` `ReSharper 虚成员从未被重写（本地）高亮显示`	建议

安全性（1 项检查）

此类别中的检查会报告依据 Mend.io 显示存在漏洞的 NuGet 包。

检查 ID EditorConfig 属性	默认严重性
易受攻击的 API 使用 `存在漏洞的 API` `ReSharper 存在漏洞的 API 高亮显示`	警告

拼写问题（3 项检查）

这些检查检测各种上下文中的拼写错误。

检查 ID EditorConfig 属性	默认严重性
注释中的拼写错误 `注释拼写错误` `resharper_comment_typo_highlighting`	建议
标识符中的拼写错误 `标识符拼写错误` `resharper_identifier_typo_highlighting`	建议
字符串文字中的拼写错误 `字符串字面量拼写错误` `resharper_string_literal_typo_highlighting`	建议

语法样式（46 项检查）

此类别中的检查会检测代码语法样式的违规行为。与大多数代码检查不同，这些检查可以根据 JetBrains Rider 设置编辑器 | 代码样式 | C# | 语法样式页上配置的相应代码样式规则，检测到相同的代码结构作为代码问题，也可能不会检测到。 Ctrl+Alt+S 您还可以使用代码清理修复这些检查检测到的问题。

检查 ID EditorConfig 属性	默认严重性
添加括号以避免不明显的优先级 `添加缺失的括号` `resharper_arrange_missing_parentheses_highlighting`	已禁用
为静态成员添加/移除限定符 `整理静态成员限定符` `resharper_arrange_static_member_qualifier_highlighting`	提示
添加/移除 'this.' 限定符 `整理 this 限定符` `resharper_arrange_this_qualifier_highlighting`	提示
调整修饰符声明顺序 `整理修饰符顺序` `resharper_arrange_modifiers_order_highlighting`	建议
调整空值检查模式 `整理空检查模式` `resharper_arrange_null_checking_pattern_highlighting`	提示
在部分中合并或分离属性 `整理特性` `resharper_arrange_attributes_highlighting`	已禁用
在解构声明中合并或分离 'var' `在解构声明中整理 var 关键字` `resharper_arrange_var_keywords_in_deconstructing_declaration_highlighting`	建议
将赋值表达式放入代码块中 `将赋值表达式放入代码块中` `resharper_place_assignment_expression_into_block_highlighting`	已禁用
移除冗余的括号 `整理冗余括号` `resharper_arrange_redundant_parentheses_highlighting`	提示
将内置类型引用替换为 CLR 类型名称或关键字 `内置类型引用样式` `resharper_built_in_type_reference_style_highlighting`	提示
在静态成员访问表达式中将内置类型引用替换为 CLR 类型名称或关键字 `成员访问中的内置类型引用样式` `resharper_built_in_type_reference_style_for_member_access_highlighting`	提示
用空行分隔控制转移语句 `分隔控制转移语句` `resharper_separate_control_transfer_statement_highlighting`	已禁用
行尾不必要的空格 `不必要的空白字符` `resharper_unnecessary_whitespace_highlighting`	已禁用
禁止使用制表符进行缩进 `不允许使用制表符` `resharper_tabs_are_disallowed_highlighting`	已禁用
为类型成员使用显式或隐式修饰符定义 `整理类型成员修饰符` `resharper_arrange_type_member_modifiers_highlighting`	提示
为类型使用显式或隐式修饰符定义 `整理类型修饰符` `resharper_arrange_type_modifiers_highlighting`	提示
使用首选参数样式 `参数样式（其他）` `resharper_arguments_style_other_highlighting`	已禁用
对匿名函数使用首选参数样式 `参数样式（匿名函数）` `resharper_arguments_style_anonymous_function_highlighting`	已禁用
对字面值使用首选参数样式 `参数样式（字面量）` `resharper_arguments_style_literal_highlighting`	已禁用
对命名表达式使用首选参数样式 `参数样式（具名表达式）` `resharper_arguments_style_named_expression_highlighting`	已禁用
对字符串字面值使用首选参数样式 `参数样式（字符串字面量）` `resharper_arguments_style_string_literal_highlighting`	已禁用
使用首选主体样式（转换为具有首选主体样式的构造函数或析构函数） `整理构造函数或析构函数体` `resharper_arrange_constructor_or_destructor_body_highlighting`	已禁用
使用首选主体样式（转换为具有首选主体样式的局部函数） `整理局部函数体` `resharper_arrange_local_function_body_highlighting`	已禁用
使用首选主体样式（转换为具有首选主体样式的方法或运算符） `整理方法或运算符体` `resharper_arrange_method_or_operator_body_highlighting`	已禁用
使用首选主体样式（转换为具有首选主体样式的属性、索引器或事件） `整理访问器所有者体` `resharper_arrange_accessor_owner_body_highlighting`	建议
使用首选的大括号样式（在 'do-while' 语句中强制使用大括号） `强制 do-while 语句使用大括号` `resharper_enforce_do_while_statement_braces_highlighting`	已禁用
使用首选大括号样式（在 'fixed' 语句中强制使用大括号） `强制 fixed 语句使用大括号` `resharper_enforce_fixed_statement_braces_highlighting`	已禁用
使用首选的大括号样式（在 'for' 语句中强制使用大括号） `强制 for 语句使用大括号` `resharper_enforce_for_statement_braces_highlighting`	已禁用
使用首选大括号样式（在 'foreach' 语句中强制使用大括号） `强制 foreach 语句使用大括号` `resharper_enforce_foreach_statement_braces_highlighting`	已禁用
使用首选的大括号样式（在 'if' 语句中强制使用大括号） `强制 if 语句使用大括号` `resharper_enforce_if_statement_braces_highlighting`	已禁用
使用首选大括号样式（在 'lock' 语句中强制使用大括号） `强制 lock 语句使用大括号` `resharper_enforce_lock_statement_braces_highlighting`	已禁用
使用首选大括号样式（在 'using' 语句中强制使用大括号） `强制 using 语句使用大括号` `resharper_enforce_using_statement_braces_highlighting`	已禁用
使用首选的大括号样式（在 'while' 语句中强制使用大括号） `强制 while 语句使用大括号` `resharper_enforce_while_statement_braces_highlighting`	已禁用
使用首选的大括号样式（移除多余的大括号） `移除冗余大括号` `resharper_remove_redundant_braces_highlighting`	已禁用
使用首选命名空间主体样式 `整理命名空间体` `resharper_arrange_namespace_body_highlighting`	提示
对丢弃声明使用首选样式 `建议舍弃声明使用 var 样式` `resharper_suggest_discard_declaration_var_style_highlighting`	提示
在多行列表中，在新行前的尾随逗号使用首选样式 `在多行列表中整理结尾逗号` `resharper_arrange_trailing_comma_in_multiline_lists_highlighting`	提示
当最后一个元素后没有新行时，对尾随逗号使用首选样式 `在单行列表中整理结尾逗号` `resharper_arrange_trailing_comma_in_singleline_lists_highlighting`	提示
当类型显而易见时，对默认值表达式使用首选样式 `当类型明显时整理默认值` `resharper_arrange_default_value_when_type_evident_highlighting`	建议
当类型不显而易见时，对默认值表达式使用首选样式 `当类型不明显时整理默认值` `当类型不明确时整理默认值突出显示`	提示
当创建的类型显而易见时，对 'new' 表达式使用首选样式 `当类型明确时整理对象创建` `当类型明确时整理对象创建突出显示`	建议
当创建的类型不显而易见时，对 'new' 表达式使用首选样式 `当类型不明确时整理对象创建` `当类型不明确时整理对象创建突出显示`	提示
使用首选的 'var' 风格（其他地方） `在其他位置建议使用 var 或类型` `在其他位置建议使用 var 或类型突出显示`	提示
使用首选的 'var' 风格（针对内置类型） `建议使用 var 或内置类型` `建议使用 var 或内置类型突出显示`	提示
使用首选的 'var' 风格（在解构声明中） `建议在解构声明中使用 var 或类型` `建议在解构声明中使用 var 或类型突出显示`	提示
使用首选的 'var' 风格（当类型简单时） `建议使用 var 或简单类型` `建议使用 var 或简单类型突出显示`	提示

Unity（48 项检查）

此类别中的检查报告特定于 Unity 项目的代码问题。

检查 ID EditorConfig 属性	默认严重性
有可用的非分配方法替代 `Unity 优先使用 NonAlloc API` `Unity 优先使用 NonAlloc API 突出显示`	警告
避免在从 'PropertyDrawer' 派生的类中使用 'base.OnGUI()' `Unity PropertyDrawer 派生类必须继承自 OnGUI 基类` `Unity PropertyDrawer 派生类必须继承自 OnGUI 基类突出显示`	警告
无法解析组件或可脚本化对象 `Unity 未解析的 Component 或 ScriptableObject` `Unity 未解析的 Component 或 ScriptableObject 突出显示`	警告
DOTS：IAspect 字段必须是以下类型之一：RefRW、RefRO、EnabledRefRW、EnabledRefRO、DynamicBuffer 或 Entity `Unity.Entities 中 Aspect 声明的字段类型不正确` `Unity.Entities 中 Aspect 声明的字段类型不正确突出显示`	错误
DOTS：类型关键字不一致 `Unity.Entities 中 Dots 继承者的修饰符不一致` `Unity.Entities 中 Dots 继承者的修饰符不一致突出显示`	错误
DOTS：指定的类型必须是结构类型 `Unity.Entities 中 Dots 继承者必须为结构体` `Unity.Entities 中 Dots 继承者必须为结构体突出显示`	错误
事件函数名称已被声明 `Unity 中存在重复的事件函数` `Unity 中存在重复的事件函数突出显示`	警告
期望类型派生自 'Component' 或 'MonoBehaviour' `Unity 中预期使用 Component` `Unity 中预期使用 Component 突出显示`	警告
期望类型派生自 'ScriptableObject' `Unity 中预期使用 ScriptableObject` `Unity 中预期使用 ScriptableObject 突出显示`	警告
'ComponentLookup' 类型的字段在使用前必须更新。 `Unity.Entities 中的组件查找未更新` `Unity.Entities 中的组件查找未更新突出显示`	警告
文件名应与程序集名称匹配 `ASMDEF 文件名不匹配` `ASMDEF 文件名不匹配突出显示`	建议
未定义组路径 `Odin 未知的分组路径` `Odin 未知的分组路径突出显示`	警告
方法签名不正确 `Unity 方法签名不正确` `Unity 方法签名不正确突出显示`	警告
Odin 的组属性类型不正确 `Odin 成员使用了错误的分组属性` `Odin 成员使用了错误的分组属性突出显示`	警告
成员同时出现在多个 UI 组中 `Odin 成员出现在多个分组中` `Odin 成员出现在多个分组中突出显示`	警告
字符串文字中引用的方法不具有预期的签名 `Unity 字符串字面量中方法签名不正确` `Unity 字符串字面量中方法签名不正确突出显示`	警告
'MonoBehaviour' 实例必须使用 'GameObject.AddComponent<T>()' 而不是 'new' 进行实例化 `Unity 中错误的 MonoBehaviour 实例化方式` `Unity 中错误的 MonoBehaviour 实例化方式突出显示`	警告
参数应派生自 'Component' `Unity 参数未从 Component 派生` `Unity 参数未从 Component 派生突出显示`	警告
可能错误地将属性应用于多个字段 `Unity 属性可能错误地应用于多个字段` `Unity 属性可能错误地应用于多个字段突出显示`	警告
可能无意中绕过了底层 Unity 引擎对象的生命周期检查（对派生自 'UnityEngine.Object' 的类型进行空合并操作会绕过底层 Unity 引擎对象的生命周期检查） `Unity 禁止使用 null 合并运算符` `Unity 禁止使用 null 合并运算符突出显示`	已禁用
可能无意中绕过了底层 Unity 引擎对象的生命周期检查（对派生自 'UnityEngine.Object' 的类型进行空传播操作会绕过底层 Unity 引擎对象的生命周期检查） `Unity 禁止使用 null 传播运算符` `Unity 禁止使用 null 传播运算符突出显示`	已禁用
可能无意中绕过了底层 Unity 引擎对象的生命周期检查（对派生自 'UnityEngine.Object' 的类型进行模式匹配空检查会绕过底层 Unity 引擎对象的生命周期检查） `Unity 禁止使用 null 模式匹配` `Unity 禁止使用 null 模式匹配突出显示`	已禁用
优先使用基于 GUID 的程序集引用 `Unity 优先使用 Guid 引用` `Unity 优先使用 Guid 引用突出显示`	提示
冗余的属性使用（将属性应用于此声明类型时是多余的） `Unity 中目标上的属性冗余` `Unity 中目标上的属性冗余突出显示`	警告
冗余的属性使用（冗余的 'FormerlySerializedAs' 属性） `Unity 中冗余的 FormerlySerializedAs 属性` `Unity 中冗余的 FormerlySerializedAs 属性突出显示`	警告
冗余的属性使用（冗余的 'HideInInspector' 属性） `Unity 中冗余的 HideInInspector 属性` `Unity 中冗余的 HideInInspector 属性突出显示`	警告
冗余的属性使用（冗余的 'InitializeOnLoad' 属性） `Unity 中冗余的 InitializeOnLoad 属性` `Unity 中冗余的 InitializeOnLoad 属性突出显示`	警告
冗余的属性使用（冗余的 'SerializeField' 属性） `Unity 中冗余的 SerializeField 属性` `Unity 中冗余的 SerializeField 属性突出显示`	警告
冗余的 Unity 事件函数 `Unity 中冗余的事件函数` `Unity 中冗余的事件函数突出显示`	警告
对内置组件的属性重复访问效率低下 `Unity 中属性访问效率低下` `Unity 中属性访问效率低下突出显示`	已禁用
场景不存在 `Unity 尝试加载不存在的场景` `Unity 尝试加载不存在的场景突出显示`	警告
场景在构建设置中被禁用 `Unity 尝试加载被禁用场景的名称` `Unity 尝试加载被禁用场景的名称突出显示`	警告
'ScriptableObject' 实例必须使用 'ScriptableObject.CreateInstance<T>()' 而不是 'new' 进行实例化 `Unity 中错误的 ScriptableObject 实例化` `Unity 中错误的 ScriptableObject 实例化突出显示`	警告
在对象实例化后立即设置 'parent' 属性效率低下 `Unity 实例化对象时未设置父级` `Unity 实例化对象时未设置父级突出显示`	警告
简短的场景名称不唯一 `模糊的场景名称传递给 Unity.LoadScene()` `模糊场景名称传递给 Unity.LoadScene 的代码检查强调`	警告
基于字符串的图形属性查找效率低下 `Unity 建议使用 Address ID 而非图形参数` `建议使用 ID 地址代替图形参数的代码检查强调`	警告
基于字符串的组件类型查找效率低下 `Unity 建议使用泛型方法重载` `建议使用泛型方法重载的代码检查强调`	警告
SystemApi.Query<...> 类型参数必须是 Aspect、RefRO 或 RefRW `Unity.Entities 要求必须使用 RefRW 或 RefRO 包裹` `必须使用 RefRW 或 RefRO 包裹的代码检查强调`	警告
索引在构建设置中缺失 `Unity.LoadScene() 中使用了错误的场景索引` `Unity.LoadScene 中使用错误场景索引的代码检查强调`	警告
输入名称未在输入管理器中定义 `Unity 中存在未知输入轴` `未知输入轴的代码检查强调`	警告
图层未在 'Tags & Layers' 中定义 `Unity 中引用了未知图层` `未知图层的代码检查强调`	警告
资源未在项目中定义 `Unity 中引用了未知资源` `未知资源的代码检查强调`	警告
相同的快捷键已为另一个菜单项定义 `Unity 中检测到重复的快捷键` `重复快捷键的代码检查强调`	警告
标签未在 'Tags & Layers' 中定义 `Unity 中使用了未知标签` `未知标签的代码检查强调`	警告
项目中没有具有相同名称的动画器状态。 `Unity.Animator 中存在未知状态名称` `Animator 状态名称未知的代码检查强调`	警告
构建设置中没有具有相同名称的场景 `Unity.LoadScene() 中使用了未知场景名称` `未知场景名称的代码检查强调`	警告
要在函数中使用 'GetSingleton' 调用的结果，'OnCreate' 必须包含 'RequireForUpdate' 调用 `Unity.Entities 的 Singletons 必须显式请求` `Singleton 实体必须请求的代码检查强调`	警告
使用 'CompareTag' 替代显式字符串比较 `Unity 中进行了显式标签比较` `显式标签比较的代码检查强调`	警告

Unity Burst 编译器警告（17 项检查）

此类别中的检查会报告 Unity Burst Compiler 在代码实际编译之前的警告。

检查 ID EditorConfig 属性	默认严重性
不支持访问托管索引器 `Unity.Burst 中访问了托管索引器` `访问托管索引器的代码检查强调`	警告
不支持访问托管方法 `Unity.Burst 中调用了托管方法` `调用托管方法的代码检查强调`	警告
不支持装箱操作 `Unity.Burst 不支持装箱操作` `不支持装箱操作的代码检查强调`	警告
Burst：String.Format(format, ...) 参数类型无效 `Unity.Burst 中字符串格式化参数无效` `字符串格式化参数无效的代码检查强调`	警告
Burst：变量解析为 System.String，这可能导致在 Burst 编译的调用堆栈中调用无效的托管方法 `Unity.Burst 中声明了本地字符串变量` `声明本地字符串变量的代码检查强调`	建议
不支持创建托管类型 `Unity.Burst 中创建了托管类型` `创建托管类型的代码检查强调`	警告
调试日志函数仅接受字符串 `Unity.Burst.Debug 调用中参数无效` `DebugLog 参数无效的代码检查强调`	警告
函数签名不能包含托管类型 `Unity.Burst 函数签名包含托管类型` `函数签名包含托管类型的代码检查强调`	警告
从非只读静态字段加载是不支持的 `Unity.Burst 中加载了非 readonly 的静态字段` `加载非 readonly 静态字段的代码检查强调`	警告
加载托管类型是不支持的 `Unity.Burst 中加载了托管类型` `加载托管类型的代码检查强调`	警告
共享静态类型参数需要非托管约束 `Unity.SharedStatic 需要为非托管类型` `SharedStatic 使用非托管类型的代码检查强调`	警告
某些 SharedStatic`1.GetOrCreate 重载会导致编译器错误 `Unity.Burst 中使用了 SharedStatic.Create()` `SharedStatic.Create 的代码检查强调`	警告
String.Format(format, ...) 仅接受字符串字面量和常量字符串 `Unity.Burst 字符串格式化格式无效` `字符串格式格式无效的代码检查强调`	警告
'foreach' 结构是不支持的 `Unity.Burst 不支持 foreach 循环` `不支持 foreach 的代码检查强调`	警告
Try 语句是不支持的 `Unity.Burst 不支持 try 语句` `不支持 try 语句的代码检查强调`	警告
在 Burst 中禁止使用 typeof `Unity.Burst 中包含 typeof 表达式` `typeof 表达式的代码检查强调`	警告
写入静态字段是不支持的 `Unity.Burst 中向静态字段赋值` `写入静态字段的代码检查强调`	警告

Unity 性能检查（5 项检查）

此类别中的检查报告 Unity 项目中的计算效率低下的模式。

检查 ID EditorConfig 属性	默认严重性
'Camera.main' 开销较大 `Unity 性能关键代码中访问 Camera.main` `性能关键代码访问 Camera.main 的代码检查强调`	提示
高成本的方法调用 `Unity 性能关键代码中调用了函数` `性能关键代码函数调用的代码检查强调`	提示
高成本的空值比较 `Unity 性能关键代码中存在空值比较` `性能关键代码空值比较的代码检查强调`	提示
乘法操作的顺序效率低下 `Unity 检测到低效的乘法顺序` `低效乘法顺序的代码检查强调`	警告
请使用锯齿数组或一维数组代替多维数组 `Unity 检测到低效的多维数组使用` `低效多维数组使用的代码检查强调`	警告

Unreal Build System（2 项检查）

此类别中的检查特定于 Unreal Engine 项目。

检查 ID EditorConfig 属性	默认严重性
项目文件中缺少插件的依赖项 `缺少插件依赖项` `缺少插件依赖的代码检查强调`	警告
不存在具有此名称的模块 `C# Build.cs 中模块名称无效` `Build.cs 模块名称无效的代码检查强调`	警告

Xunit（1 项检查）

这些检查会检测与 xUnit.Net 测试相关的代码问题。

检查 ID EditorConfig 属性	默认严重性
Xunit 测试中的控制台输出 `xUnit 测试包含控制台输出` `xUnit 控制台输出的代码检查强调`	警告

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