C# 代码检查

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

可配置的 C# 检查项如下所示，按其类别分组。

代码通知（2 项检查）

此类别分组了严重性级别较低的代码检查。

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

常见实践和代码改进（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（非私有可访问性） `AutoProperty 可设为仅具有 get 访问器（全局）` `resharper_auto_property_can_be_made_get_only_global_highlighting`	建议
自动属性可以设为仅 get（私有可访问性） `AutoProperty 可设为仅具有 get 访问器（本地）` `resharper_auto_property_can_be_made_get_only_local_highlighting`	建议
基类成员有 'params' 参数，但重写方法没有 `基类成员具有 params 参数` `resharper_base_member_has_params_highlighting`	警告
可在 'Add' 前简化 'Contains' `可用单个调用简化集合添加操作` `resharper_can_simplify_set_adding_with_single_call_highlighting`	建议
类型转换表达式可替换为显式类型参数 `可将强制转换替换为类型参数` `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' `ConvertIfDoToWhile` `resharper_convert_if_do_to_while_highlighting`	建议
将 'if' 转换为 '\|\|' `ConvertIfToOrExpression` `resharper_convert_if_to_or_expression_highlighting`	建议
将局部变量或字段转换为常量（非私有可访问性） `转换为常量（全局）` `ReSharper 转换为常量（全局）`	提示
将局部变量或字段转换为常量（私有可访问性） `转换为常量（局部）` `ReSharper 转换为常量（局部）`	提示
声明可空性已推断（参数被推断为非 null） `为不可为 null 的参数添加注解` `ReSharper 为不可为 null 的参数添加注解`	已禁用
声明可空性已推断（参数被推断为可空） `为可为 null 的参数添加注解` `ReSharper 为可为 null 的参数添加注解`	已禁用
声明可空性已推断（类型成员被推断为非 null） `为不可为 null 的类型成员添加注解` `ReSharper 为不可为 null 的类型成员添加注解`	已禁用
声明可空性已推断（类型成员被推断为可空） `为可为 null 的类型成员添加注解` `resharper_annotate_can_be_null_type_member_highlighting`	已禁用
字典项移除可简化为单次 'Remove' `可以通过单个调用简化 Dictionary 的删除操作` `resharper_can_simplify_dictionary_removing_with_single_call_highlighting`	建议
字典查找可简化为 'GetValueOrDefault' `可以使用 GetValueOrDefault 简化 Dictionary 的 TryGetValue` `resharper_can_simplify_dictionary_try_get_value_with_get_value_or_default_highlighting`	建议
字典查找可简化为 'TryAdd' `可以使用 TryAdd 简化 Dictionary 查询` `resharper_can_simplify_dictionary_lookup_with_try_add_highlighting`	建议
字典查找可简化为 'TryGetValue' `可以使用 TryGetValue 简化 Dictionary 查找` `可使用 TryGetValue 简化 Dictionary 查找的高亮显示`	建议
空语句是多余的 `空语句` `空语句的高亮显示`	警告
提取通用属性模式 `提取公共属性模式` `提取公共属性模式的高亮显示`	提示
字段可以设为 readonly（非私有可访问性） `字段可设为只读（全局）` `字段可设为只读（全局）的高亮显示`	建议
字段可以设为 readonly（私有可访问性） `字段可设为只读（局部）` `字段可设为只读（局部）的高亮显示`	建议
仅 get 的自动属性从未被赋值 `UnassignedGetOnlyAutoProperty` `resharper_unassigned_get_only_auto_property_highlighting`	警告
取反条件 `InvertCondition.1` `resharper_invert_condition_1_highlighting`	提示
迭代变量可声明为更具体的类型 `MoreSpecificForeachVariableTypeAvailable` `resharper_more_specific_foreach_variable_type_available_highlighting`	建议
合并局部变量声明和赋值 `JoinDeclarationAndInitializer` `resharper_join_declaration_and_initializer_highlighting`	建议
本地函数可设为 static `LocalFunctionCanBeMadeStatic` `resharper_local_function_can_be_made_static_highlighting`	已禁用
局部变量声明范围过宽 `TooWideLocalVariableScope` `resharper_too_wide_local_variable_scope_highlighting`	建议
将抽象类中的构造函数设为 protected `抽象类中存在公开构造函数` `ReSharper：抽象类中存在公开构造函数（高亮显示）`	建议
成员可以设为私有（非私有可访问性） `成员可设为私有（全局）` `ReSharper：成员可设为私有（全局，高亮显示）`	建议
成员可以设为私有（私有可访问性） `成员可设为私有（局部）` `ReSharper：成员可设为私有（局部，高亮显示）`	建议
成员可以设为受保护（非私有可访问性） `成员可设为 protected（全局）` `ReSharper：成员可设为 protected（全局，高亮显示）`	建议
成员可以设为受保护（私有可访问性） `成员可设为 protected（局部）` `ReSharper：成员可设为 protected（局部，高亮显示）`	建议
成员可以设为静态（共享）（非私有可访问性） `MemberCanBeMadeStatic.Global` `resharper_member_can_be_made_static_global_highlighting`	提示
成员可以设为静态（共享）（私有可访问性） `MemberCanBeMadeStatic.Local` `resharper_member_can_be_made_static_local_highlighting`	提示
成员或类型可以设为内部（友元） `MemberCanBeInternal` `resharper_member_can_be_internal_highlighting`	已禁用
方法有异步重载 `MethodHasAsyncOverload` `resharper_method_has_async_overload_highlighting`	建议
方法有支持取消的异步重载 `具有取消参数的异步重载方法可用` `对具有取消参数的异步重载方法可用的高亮显示`	建议
方法支持取消操作 `方法支持取消` `对方法支持取消的高亮显示`	建议
缺少 private 或 internal 类型或成员的 XML 注释 `未记录的 internal 或 private 成员` `对未记录的 internal 或 private 成员的高亮显示`	已禁用
多重可空属性的使用 `多次使用 Nullable 特性` `对多次使用 Nullable 特性的高亮显示`	警告
嵌套字符串插值可内联 `嵌套的字符串插值` `resharper_nested_string_interpolation_highlighting`	建议
可空性属性用于 void 或值类型的声明 `值类型上的标注冗余` `resharper_annotation_redundancy_at_value_type_highlighting`	警告
可空性属性用于无法被其他代码直接引用的声明 `NotObservable 标注冗余` `resharper_not_observable_annotation_redundancy_highlighting`	警告
参数可以声明为基类型 `建议参数使用基类型` `resharper_suggest_base_type_for_parameter_highlighting`	已禁用
构造函数的参数可以声明为基类型 `建议在构造函数中使用基类型参数` `resharper_suggest_base_type_for_parameter_in_constructor_highlighting`	已禁用
参数类型可以是 IEnumerable<T>（非私有可访问性） `参数类型可为 IEnumerable（作用域：全局）` `参数类型可为 IEnumerable（作用域：全局）`	已禁用
参数类型可以是 IEnumerable<T>（私有可访问性） `参数类型可为 IEnumerable（作用域：局部）` `参数类型可为 IEnumerable（作用域：局部）`	已禁用
建议优先使用具体值而非 'default' 或 'new()' `偏好具体值而非 default` `偏好具体值而非 default`	建议
属性可以设为仅 init（非私有可访问性） `属性可设为 init-only（作用域：全局）` `属性可设为 init-only（作用域：全局）`	建议
属性可以设为仅 init（私有可访问性） `属性可设为 init-only（作用域：局部）` `属性可设为 init-only（作用域：局部）`	建议
将本地函数放在 'return' 或 'continue' 之后 `在跳转语句之后移动本地函数` `ReSharper 在跳转语句之后移动本地函数高亮`	提示
多余的 'is' `冗余的 is 前关系模式` `ReSharper 冗余的 is 前关系模式高亮`	建议
移除构造函数调用 `移除构造函数调用` `ReSharper 移除构造函数调用高亮`	已禁用
移除多余语句 `移除冗余的 or 表达式（false）` `ReSharper 移除冗余的 or 表达式（false）高亮`	建议
移除多余语句 `移除冗余的 or 表达式（true）` `移除恒为 true 的多余 OR 子句高亮显示`	建议
移除 ToList() `移除 ToList.1` `移除 ToList.1 高亮显示`	建议
移除 ToList() `移除 ToList.2` `移除 ToList.2 高亮显示`	建议
将 'async' 代码替换为返回 'Task' `用 Task 返回替换 async` `用 Task 返回替换 async 高亮显示`	已禁用
替换为 FirstOrDefault($args$) `用 FirstOrDefault.1 替换` `替换为 FirstOrDefault 的高亮显示（第 1 项）`	建议
替换为 FirstOrDefault($args$) `替换为 FirstOrDefault（第 2 项）` `替换为 FirstOrDefault 的高亮显示（第 2 项）`	建议
替换为 FirstOrDefault($args$) `替换为 FirstOrDefault（第 3 项）` `使用 FirstOrDefault 替换`	建议
替换为 FirstOrDefault($args$) `使用 FirstOrDefault 替换` `使用 FirstOrDefault 替换`	建议
替换为 LastOrDefault($args$) `使用 LastOrDefault 替换` `使用 LastOrDefault 替换`	建议
替换为 LastOrDefault($args$) `使用 LastOrDefault 替换` `使用 LastOrDefault 替换`	建议
替换为 LastOrDefault($args$) `使用 LastOrDefault 替换` `使用 LastOrDefault 替换`	建议
替换为 LastOrDefault($args$) `替换为 LastOrDefault.4` `替换为 LastOrDefault.4 突出显示`	建议
替换为 OfType<T>() `替换为 OfType.1` `替换为 OfType.1 突出显示`	建议
替换为 OfType<T>() `替换为 OfType.2` `替换为 OfType.2 突出显示`	建议
替换为 OfType<T>() `替换为 OfType.3` `替换为 OfType.3 突出显示`	建议
替换为 OfType<T>().Any() `替换为 OfType.Any.1` `替换为 OfType.Any.1 突出显示`	建议
替换为 OfType<T>().Any()（替换为 OfType<T>().Any(..)） `替换为 OfType 和 Any 的组合（2 参数）` `resharper_replace_with_of_type_any_2_highlighting`	建议
替换为 OfType<T>().Count() `替换为 OfType 和 Count 的组合（1 参数）` `resharper_replace_with_of_type_count_1_highlighting`	建议
替换为 OfType<T>().Count()（替换为 OfType<T>().Count(..)） `替换为 OfType 和 Count 的组合（2 参数）` `resharper_replace_with_of_type_count_2_highlighting`	建议
替换为 OfType<T>().First() `替换为 OfType 和 First 的组合（1 参数）` `resharper_replace_with_of_type_first_1_highlighting`	建议
替换为 OfType<T>().First()（替换为 OfType<T>().First(..)） `替换为 OfType().First() 的使用` `替换为 OfType().First() 的使用的代码检查高亮`	建议
替换为 OfType<T>().FirstOrDefault() `替换为 OfType().FirstOrDefault() 的使用` `替换为 OfType().FirstOrDefault() 的使用的代码检查高亮`	建议
替换为 OfType<T>().FirstOrDefault()（替换为 OfType<T>().FirstOrDefault(..)） `替换为 OfType().FirstOrDefault() 的使用` `替换为 OfType().FirstOrDefault() 的使用的代码检查高亮`	建议
替换为 OfType<T>().Last() `替换为 OfType().Last() 的使用` `替换为 OfType().Last() 的使用的代码检查高亮`	建议
替换为 OfType<T>().Last()（替换为 OfType<T>().Last(..)） `替换为 OfType().Last() 的使用` `替换为 OfType().Last() 的使用的代码检查高亮`	建议
替换为 OfType<T>().LastOrDefault() `替换为 OfType().LastOrDefault() 的使用` `替换为 OfType().LastOrDefault() 的使用的代码检查高亮`	建议
替换为 OfType<T>().LastOrDefault()（替换为 OfType<T>().LastOrDefault(..)） `替换为 OfType().LastOrDefault() 的使用` `替换为 OfType().LastOrDefault() 的使用的代码检查高亮`	建议
替换为 OfType<T>().LongCount() `替换为 OfType().LongCount() 的使用` `resharper_replace_with_of_type_long_count_highlighting`	建议
替换为 OfType<T>().Single() `ReplaceWithOfType.Single.1` `resharper_replace_with_of_type_single_1_highlighting`	建议
替换为 OfType<T>().Single()（替换为 OfType<T>().Single(..)） `ReplaceWithOfType.Single.2` `resharper_replace_with_of_type_single_2_highlighting`	建议
替换为 OfType<T>().SingleOrDefault() `ReplaceWithOfType.SingleOrDefault.1` `resharper_replace_with_of_type_single_or_default_1_highlighting`	建议
替换为 OfType<T>().SingleOrDefault()（替换为 OfType<T>().SingleOrDefault(..)） `ReplaceWithOfType.SingleOrDefault.2` `resharper_replace_with_of_type_single_or_default_2_highlighting`	建议
替换为 OfType<T>().Where()（替换为 OfType<T>().Where(..)） `ReplaceWithOfType.Where` `resharper_replace_with_of_type_where_highlighting`	建议
替换为简单赋值 `ReplaceWithSimpleAssignment.True` `resharper_replace_with_simple_assignment_true_highlighting`	建议
替换为简单赋值 `ReplaceWithSimpleAssignment.False` `resharper_replace_with_simple_assignment_false_highlighting`	建议
替换为单次赋值 `ReplaceWithSingleAssignment.False` `resharper_replace_with_single_assignment_false_highlighting`	建议
替换为单次赋值 `ReplaceWithSingleAssignment.True` `resharper_replace_with_single_assignment_true_highlighting`	建议
替换为单次调用 Any(..) `ReplaceWithSingleCallToAny` `resharper_replace_with_single_call_to_any_highlighting`	建议
替换为单次调用 Count(..) `ReplaceWithSingleCallToCount` `resharper_replace_with_single_call_to_count_highlighting`	建议
替换为单次调用 First(..) `ReplaceWithSingleCallToFirst` `resharper_replace_with_single_call_to_first_highlighting`	建议
替换为单次调用 FirstOrDefault(..) `ReplaceWithSingleCallToFirstOrDefault` `resharper_replace_with_single_call_to_first_or_default_highlighting`	建议
替换为单次调用 Last(..) `ReplaceWithSingleCallToLast` `resharper_replace_with_single_call_to_last_highlighting`	建议
替换为单次调用 LastOrDefault(..) `ReplaceWithSingleCallToLastOrDefault` `resharper_replace_with_single_call_to_last_or_default_highlighting`	建议
替换为单次调用 Single(..) `ReplaceWithSingleCallToSingle` `resharper_replace_with_single_call_to_single_highlighting`	建议
替换为单次调用 SingleOrDefault(..) `ReplaceWithSingleCallToSingleOrDefault` `resharper_replace_with_single_call_to_single_or_default_highlighting`	建议
替换为 SingleOrDefault($args$) `ReplaceWithSingleOrDefault.1` `resharper_replace_with_single_or_default_1_highlighting`	建议
替换为 SingleOrDefault($args$) `ReplaceWithSingleOrDefault.2` `resharper_replace_with_single_or_default_2_highlighting`	建议
替换为 SingleOrDefault($args$) `ReplaceWithSingleOrDefault.3` `resharper_replace_with_single_or_default_3_highlighting`	建议
替换为 SingleOrDefault($args$) `ReplaceWithSingleOrDefault.4` `resharper_replace_with_single_or_default_4_highlighting`	建议
返回类型可以是 IEnumerable<T>（非私有可访问性） `ReturnTypeCanBeEnumerable.Global` `resharper_return_type_can_be_enumerable_global_highlighting`	已禁用
返回类型可以是 IEnumerable<T>（私有可访问性） `ReturnTypeCanBeEnumerable.Local` `resharper_return_type_can_be_enumerable_local_highlighting`	已禁用
简化条件三元表达式 `SimplifyConditionalTernaryExpression` `resharper_simplify_conditional_ternary_expression_highlighting`	建议
简化 'IsInstanceOfType()' 调用 `CanSimplifyIsAssignableFrom` `resharper_can_simplify_is_assignable_from_highlighting`	建议
简化 LINQ 表达式（使用 'All'） `SimplifyLinqExpressionUseAll` `resharper_simplify_linq_expression_use_all_highlighting`	建议
简化 LINQ 表达式（使用 'Any'） `SimplifyLinqExpressionUseAny` `resharper_simplify_linq_expression_use_any_highlighting`	建议
简化取反模式 `DoubleNegationInPattern` `resharper_double_negation_in_pattern_highlighting`	建议
简化取反关系模式 `NegationOfRelationalPattern` `resharper_negation_of_relational_pattern_highlighting`	建议
简化负等式表达式 `NegativeEqualityExpression` `resharper_negative_equality_expression_highlighting`	建议
显式指定字符串比较 `SpecifyStringComparison` `resharper_specify_string_comparison_highlighting`	提示
显式指定字符串区域性 `SpecifyACultureInStringConversionExplicitly` `resharper_specify_a_culture_in_string_conversion_explicitly_highlighting`	警告
字符串字面量可内联 `StringLiteralAsInterpolationArgument` `resharper_string_literal_as_interpolation_argument_highlighting`	建议
String.Compare 是与文化相关的（string.Compare(string, int, string, int) 是与文化相关的） `StringCompareIsCultureSpecific.4` `resharper_string_compare_is_culture_specific_4_highlighting`	警告
String.Compare 是与文化相关的（string.Compare(string, int, string, int, bool) 是与文化相关的） `StringCompareIsCultureSpecific.5` `resharper_string_compare_is_culture_specific_5_highlighting`	警告
String.Compare 是与文化相关的（string.Compare(string, int, string, int, bool) 是与文化相关的） `StringCompareIsCultureSpecific.6` `resharper_string_compare_is_culture_specific_6_highlighting`	警告
String.Compare 是与文化相关的（string.Compare(string, string) 是与文化相关的） `StringCompareIsCultureSpecific.1` `resharper_string_compare_is_culture_specific_1_highlighting`	警告
String.Compare 是与文化相关的（string.Compare(string, string, bool) 是与文化相关的） `StringCompareIsCultureSpecific.2` `resharper_string_compare_is_culture_specific_2_highlighting`	警告
String.Compare 是与文化相关的（string.Compare(string, string, bool) 是与文化相关的） `StringCompareIsCultureSpecific.3` `resharper_string_compare_is_culture_specific_3_highlighting`	警告
String.CompareTo 是与文化相关的 `StringCompareToIsCultureSpecific` `resharper_string_compare_to_is_culture_specific_highlighting`	警告
String.EndsWith 是与文化相关的（string.EndsWith(string) 是与文化相关的） `StringEndsWithIsCultureSpecific` `resharper_string_ends_with_is_culture_specific_highlighting`	已禁用
String.IndexOf 是与文化相关的（string.IndexOf(string) 是与文化相关的） `StringIndexOfIsCultureSpecific.1` `resharper_string_index_of_is_culture_specific_1_highlighting`	警告
String.IndexOf 是与文化相关的（string.IndexOf(string, int) 是与文化相关的） `StringIndexOfIsCultureSpecific.2` `resharper_string_index_of_is_culture_specific_2_highlighting`	警告
String.IndexOf 是与文化相关的（string.IndexOf(string, int) 是与文化相关的） `StringIndexOfIsCultureSpecific.3` `resharper_string_index_of_is_culture_specific_3_highlighting`	警告
String.LastIndexOf 是与文化相关的（string.LastIndexOf(string) 是与文化相关的） `StringLastIndexOfIsCultureSpecific.1` `resharper_string_last_index_of_is_culture_specific_1_highlighting`	警告
String.LastIndexOf 是与文化相关的（string.LastIndexOf(string, int) 是与文化相关的） `StringLastIndexOfIsCultureSpecific.2` `resharper_string_last_index_of_is_culture_specific_2_highlighting`	警告
String.LastIndexOf 是与文化相关的（string.LastIndexOf(string, int) 是与文化相关的） `StringLastIndexOfIsCultureSpecific.3` `resharper_string_last_index_of_is_culture_specific_3_highlighting`	警告
String.StartsWith 是与文化相关的（string.StartsWith(string) 是与文化相关的） `StringStartsWithIsCultureSpecific` `resharper_string_starts_with_is_culture_specific_highlighting`	已禁用
结构体可以设为 readonly `可将 struct 标记为 readonly，以提高性能并明确其不可变性。` `可将 struct 标记为 readonly，以提高性能并明确其不可变性。`	建议
结构体缺少 'IEquatable' 实现（非私有可访问性） `StructLacksIEquatable.Global` `resharper_struct_lacks_i_equatable_global_highlighting`	警告
结构体缺少 'IEquatable' 实现（私有可访问性） `StructLacksIEquatable.Local` `resharper_struct_lacks_i_equatable_local_highlighting`	警告
结构体成员可以设为 readonly `struct 成员可以标记为 readonly，以提高代码的可维护性与可读性。` `struct 成员可以标记为 readonly，以提高代码的可维护性与可读性。`	已禁用
具有默认相等成员的结构体用于比较（非私有可访问性） `DefaultStructEqualityIsUsed.Global` `resharper_default_struct_equality_is_used_global_highlighting`	警告
具有默认相等成员的结构体用于比较（私有可访问性） `DefaultStructEqualityIsUsed.Local` `resharper_default_struct_equality_is_used_local_highlighting`	警告
try-catch 和 try-finally 语句可以合并 `可以合并连续的 try 语句，从而简化代码结构。` `可以合并连续的 try 语句，从而简化代码结构。`	提示
类型可设为文件级本地类型 `可以使用 file 修饰符将成员限定为文件作用域，以提高封装性和可维护性。` `可以使用 file 修饰符将成员限定为文件作用域，以提高封装性和可维护性。`	已禁用
类型参数可声明为协变或逆变 `泛型类型参数可以标记为变型（out 或 in），以提高泛型接口的灵活性。` `泛型类型参数可以标记为变型（out 或 in），以提高泛型接口的灵活性。`	建议
具有可疑相等性的类型用于记录（非私有可访问性） `记录类型使用了具有可疑相等实现的类型成员，可能导致意外行为。请验证其 Equals 方法的正确性。` `记录类型使用了具有可疑相等实现的类型成员，可能导致意外行为。请验证其 Equals 方法的正确性。`	警告
具有可疑相等性的类型用于记录（私有可访问性） `记录类型使用了具有可疑相等实现的类型成员，可能导致意外行为。请验证其 Equals 方法的正确性。` `记录类型使用了具有可疑相等实现的类型成员，可能导致意外行为。请验证其 Equals 方法的正确性。`	警告
使用默认结构体相等性 `UsageOfDefaultStructEquality` `resharper_usage_of_default_struct_equality_highlighting`	警告
使用 'ArgumentNullException.ThrowIfNull' `可以使用 ArgumentNullException.ThrowIfNull 方法，替代传统的 null 检查来提高可读性。` `可以使用 ArgumentNullException.ThrowIfNull 方法，替代传统的 null 检查来提高可读性。`	已禁用
使用数组创建表达式 `可以使用数组创建表达式来简化数组初始化。` `可以使用数组创建表达式来简化数组初始化。`	建议
使用数组创建表达式 `可以使用数组创建表达式来简化数组初始化。` `可以使用数组创建表达式来简化数组初始化。`	建议
使用 'Array.Empty<T>()' `UseArrayEmptyMethod` `resharper_use_array_empty_method_highlighting`	建议
使用取消令牌 `建议为 IAsyncEnumerable 添加 CancellationToken 参数以支持取消操作。` `建议为 IAsyncEnumerable 添加 CancellationToken 参数以支持取消操作。`	建议
使用编译器支持的可空属性 `建议使用编译器支持的 Nullable 属性，以提高空引用分析的准确性。` `建议使用编译器支持的 Nullable 属性，以提高空引用分析的准确性。`	建议
使用 'EventArgs.Empty' `可以使用 EventArgs.Empty 字段来避免不必要的对象分配。` `可以使用 EventArgs.Empty 字段来避免不必要的对象分配。`	建议
使用索引属性 `可以将属性调用替换为索引器以提高代码可读性与一致性。` `可以将属性调用替换为索引器以提高代码可读性与一致性。`	建议
使用 'is' 运算符 `表达式可简化为使用 is 运算符，以提高代码可读性与简洁性。` `表达式可简化为使用 is 运算符，以提高代码可读性与简洁性。`	建议
使用方法 Any() `可以使用 Enumerable.Any 方法替代冗长的 Count 比较逻辑。` `可以使用 Enumerable.Any 方法替代冗长的 Count 比较逻辑。`	建议
使用方法 Any() `可以使用 Enumerable.Any 方法替代冗长的 Count 比较逻辑。` `可以使用 Enumerable.Any 方法替代冗长的 Count 比较逻辑。`	建议
使用方法 Any() `可以使用 Enumerable.Any 方法替代冗长的 Count 比较逻辑。` `可以使用 Enumerable.Any 方法替代冗长的 Count 比较逻辑。`	建议
使用方法 Any() `可以使用 Enumerable.Any 方法替代冗长的 Count 比较逻辑。` `可以使用 Enumerable.Any 方法替代冗长的 Count 比较逻辑。`	建议
使用方法 Any() `可以用 string.IsNullOrEmpty 替换冗长的 null 或空字符串检查。` `可以用 string.IsNullOrEmpty 替换冗长的 null 或空字符串检查。`	建议
使用 'String.IsNullOrEmpty' `可以用 string.IsNullOrEmpty 替换冗长的 null 或空字符串检查。` `可以用 string.IsNullOrEmpty 替换冗长的 null 或空字符串检查。`	建议
使用 'Type.EmptyTypes' `可以使用 Type.EmptyTypes 字段替代显式创建空类型数组。` `可以使用 Type.EmptyTypes 字段替代显式创建空类型数组。`	建议

编译器警告（212 项检查）

此类别中的检查可在编译之前检测到 compiler warnings。

检查 ID EditorConfig 属性	默认严重性
'#warning' 指令 `C# 编译器警告 CS1030：#warning 指令。` `C# 编译器警告 CS1030：#warning 指令。`	警告
[InterpolatedStringHandlerArgument] 应用于 lambda 参数时无效，将在调用处被忽略。 `C# 编译器警告 CS8971：提供的语言构造不受当前语言版本支持。` `C# 编译器警告 CS8971：提供的语言构造不受当前语言版本支持。`	警告
为 'ref readonly' 参数指定了默认值，但 'ref readonly' 仅应用于引用类型。建议将参数声明为 'in'。 `C# 编译器警告 CS9200：属性分组上的命名冲突。` `C# 编译器警告 CS9200：属性分组上的命名冲突。`	警告
局部变量以引用方式返回，但其初始化值无法以引用方式返回。 `C# 编译器警告 CS9082：使用路径模式匹配时参数名重复。` `C# 编译器警告 CS9082：使用路径模式匹配时参数名重复。`	警告
变量的成员以引用方式返回，但其初始化值无法以引用方式返回 `C# 编译器警告 CS9083：未提供所需的参数。` `C# 编译器警告 CS9083：未提供所需的参数。`	警告
标记为 [DoesNotReturn] 的方法不应有返回值。 `C# 编译器警告 CS8763：未实现接口成员的注解不匹配。` `C# 编译器警告 CS8763：未实现接口成员的注解不匹配。`	警告
可能的 null 值不应用于带有 [NotNull] 或 [DisallowNull] 标记的类型。 `C# 编译器警告 CS8607：分析器无法确定 null 状态，结果可能不准确。` `C# 编译器警告 CS8607：分析器无法确定 null 状态，结果可能不准确。`	警告
前面的 catch 子句已捕获所有异常 `C# 编译器警告 CS1058：#endregion 没有对应的 #region。` `C# 编译器警告 CS1058：#endregion 没有对应的 #region。`	警告
在此上下文中 stackalloc 表达式的结果可能会暴露到包含方法之外。 `C# 编译器警告 CS9081：方法或属性在 HTTP 映射中名称冲突。` `C# 编译器警告 CS9081：方法或属性在 HTTP 映射中名称冲突。`	警告
日志消息中的模板在日志方法定义中没有对应的参数 `CSharp 警告：SYSLIB1014` `ReSharper：CSharp 警告 SYSLIB1014 突出显示`	警告
类型为 'System.Threading.Lock' 的值被转换为其他类型时，在 'lock' 语句中将使用可能非预期的基于监视器的锁定机制 `C# 编译器警告 CS9216：HttpRoute 属性组合无效。` `C# 编译器警告 CS9216：HttpRoute 属性组合无效。`	警告
通过 'base' 关键字从匿名方法、lambda 表达式、查询表达式或迭代器访问成员会导致代码无法验证 `C# 编译器警告 CS1911：字段重写或隐藏了继承成员。` `C# 编译器警告 CS1911：字段重写或隐藏了继承成员。`	警告
对齐值 'value' 的数量级大于 'magnitude limit'，可能导致格式化字符串过大。 `C# 编译器警告 CS8094：文档注释格式无效。` `C# 编译器警告 CS8094：文档注释格式无效。`	警告
XML 注释中存在歧义引用 `C# 编译器警告 CS1574：注释中提到的符号无法解析。` `C# 编译器警告 CS1574：注释中提到的符号无法解析。`	警告
由于引用类型的可空性不同，参数无法作为输出用于该参数。 `C# 编译器警告 CS8624：在调用中为非可为 null 的参数传递了 null。` `C# 编译器警告 CS8624：在调用中为非可为 null 的参数传递了 null。`	警告
由于引用类型的可空性不同，参数无法用于对应的参数。 `C# 编译器警告 CS8620：方法参数与委托签名不兼容。` `C# 编译器警告 CS8620：方法参数与委托签名不兼容。`	警告
参数应为变量，因为其被传递给 'ref readonly' 参数。 `C# 编译器警告 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' 成员调用非 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`	警告
在 sealed 类中声明新的 protected 成员等同于声明为 private `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 属性 `CSharp 警告：CA1856` `ReSharper：CSharp 警告 CA1856 突出显示`	错误
内联数组转换运算符不会用于从声明类型的表达式进行转换。 `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' 字段或类型不适合作为类型参数的内联数组类型，不支持 'Inline arrays' 语言特性。 `CSharpWarnings::CS9184` `resharper_c_sharp_warnings_cs9184_highlighting`	警告
引入 'Finalize' 方法可能会干扰析构函数的调用 `CSharpWarnings::CS0465` `resharper_c_sharp_warnings_cs0465_highlighting`	警告
XML 注释中包含无效的 XML `CSharp 警告：CS1570` `resharper_c_sharp_warnings_cs1570_highlighting`	警告
XML 注释中包含无效的 include 元素 `CSharp 警告：CS1590` `resharper_c_sharp_warnings_cs1590_highlighting`	警告
'new' 关键字是多余的 `CSharp 警告：CS0109` `resharper_c_sharp_warnings_cs0109_highlighting`	警告
需要 'new' 关键字 `CSharp 警告：CS0108、CS0114` `resharper_c_sharp_warnings_cs0108_cs0114_highlighting`	警告
成员不能在此属性中使用。 `CSharp 警告：CS8776` `resharper_c_sharp_warnings_cs8776_highlighting`	警告
成员在函数退出时必须有条件地为非 null 值。 `CSharp 警告：CS8775` `resharper_c_sharp_warnings_cs8775_highlighting`	警告
成员在退出时必须为非 null 值。 `CSharp 警告：CS8774` `resharper_c_sharp_warnings_cs8774_highlighting`	警告
成员重写了已过时的成员 `CSharp 警告：CS0672` `resharper_c_sharp_warnings_cs0672_highlighting`	警告
方法缺少 '[DoesNotReturn]' 注解，无法与实现或重写的成员匹配。 `CSharp 警告：CS8770` `resharper_c_sharp_warnings_cs8770_highlighting`	警告
公开可见类型或成员缺少 XML 注释 `CSharp 警告：CS1591` `resharper_c_sharp_warnings_cs1591_highlighting`	警告
运行时存在多个重写候选项 `CSharp 警告：CS1957` `resharper_c_sharp_warnings_cs1957_highlighting`	警告
发现多个同名 Shader `ShaderLab 着色器引用多个候选项` `resharper_shader_lab_shader_reference_multiple_candidates_highlighting`	警告
命名空间应为此项目的默认命名空间 `CSharp 警告：WME006` `resharper_c_sharp_warnings_wme006_highlighting`	警告
未访问的字段 `未访问字段（编译器）` `resharper_not_accessed_field_compiler_highlighting`	警告
未访问的局部变量 `未访问变量（编译器）` `resharper_not_accessed_variable_compiler_highlighting`	警告
非可空后备字段未初始化。 `CSharp 警告：CS9264` `resharper_c_sharp_warnings_cs9264_highlighting`	警告
非可空成员未初始化。 `CSharp 警告：CS8618` `resharper_c_sharp_warnings_cs8618_highlighting`	警告
类型参数约束中的可空性不匹配。 `CSharp 警告：CS8633` `resharper_c_sharp_warnings_cs8633_highlighting`	警告
显式接口说明符中的引用类型可空性与类型实现的接口不匹配。 `CSharp 警告：CS8643` `resharper_c_sharp_warnings_cs8643_highlighting`	警告
基类实现的接口中的引用类型可空性不匹配。 `CSharp 警告：CS8644` `resharper_c_sharp_warnings_cs8644_highlighting`	警告
返回类型中的引用类型可空性与实现的成员不匹配。 `CSharp 警告：CS8616` `resharper_c_sharp_warnings_cs8616_highlighting`	警告
返回类型中的引用类型可空性与隐式实现的成员不匹配。 `CSharp 警告：CS8613` `resharper_c_sharp_warnings_cs8613_highlighting`	警告
返回类型中的引用类型可空性与重写的成员不匹配。 `CSharp 警告：CS8609` `resharper_c_sharp_warnings_cs8609_highlighting`	警告
返回类型中的引用类型可空性与 partial 方法声明不匹配。 `CSharp 警告：CS8819` `resharper_c_sharp_warnings_cs8819_highlighting`	警告
返回类型中的引用类型可空性与目标委托不匹配（可能由于可空性属性所致）。 `CSharp 警告：CS8621` `resharper_c_sharp_warnings_cs8621_highlighting`	警告
拦截器方法中返回类型的引用类型可空性与可拦截方法不匹配 `CSharp 警告：CS9159` `resharper_c_sharp_warnings_cs9159_highlighting`	警告
源类型中的引用类型可空性与目标类型不匹配。 `CSharp 警告：CS8619` `resharper_c_sharp_warnings_cs8619_highlighting`	警告
类型中的引用类型可空性与实现的成员不匹配。 `CSharp 警告：CS8615` `resharper_c_sharp_warnings_cs8615_highlighting`	警告
类型中的引用类型可空性与隐式实现的成员不匹配。 `CSharp 警告：CS8612` `resharper_c_sharp_warnings_cs8612_highlighting`	警告
类型中的引用类型可空性与重写的成员不匹配。 `CSharp 警告：CS8608` `resharper_c_sharp_warnings_cs8608_highlighting`	警告
参数类型中的引用类型可空性与目标委托不匹配（可能由于可空性属性所致）。 `CSharp 警告：CS8622` `resharper_c_sharp_warnings_cs8622_highlighting`	警告
参数类型中的引用类型可空性与实现的成员不匹配。 `CSharp 警告：CS8617` `resharper_c_sharp_warnings_cs8617_highlighting`	警告
参数类型中的引用类型可空性与隐式实现的成员不匹配。 `CSharp 警告：CS8614` `resharper_c_sharp_warnings_cs8614_highlighting`	警告
参数类型中的引用类型可空性与可拦截方法不匹配 `CSharp 警告：CS9158` `resharper_c_sharp_warnings_cs9158_highlighting`	警告
参数类型中的引用类型可空性与重写的成员不匹配。 `CSharp 警告：CS8610` `resharper_c_sharp_warnings_cs8610_highlighting`	警告
参数类型中的引用类型可空性与 partial 成员声明不匹配。 `CSharp 警告：CS8611` `resharper_c_sharp_warnings_cs8611_highlighting`	警告
返回类型的可空性与实现的成员不匹配（可能由于可空性属性所致）。 `CSharp 警告：CS8768` `resharper_c_sharp_warnings_cs8768_highlighting`	警告
返回类型的可空性与隐式实现的成员不匹配（可能由于可空性属性所致）。 `CSharp 警告：CS8766` `resharper_c_sharp_warnings_cs8766_highlighting`	警告
返回类型的可空性与重写的成员不匹配（可能由于可空性属性所致）。 `CSharp 警告：CS8764` `resharper_c_sharp_warnings_cs8764_highlighting`	警告
类型参数的可空性与 'class' 约束不匹配。 `CSharp 警告：CS8634` `resharper_c_sharp_warnings_cs8634_highlighting`	警告
类型参数的可空性与约束类型不匹配。 `CSharp 警告：CS8631` `resharper_c_sharp_warnings_cs8631_highlighting`	警告
类型参数的可空性与 'notnull' 约束不匹配。 `CSharp 警告：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`	警告
函数退出时参数必须有条件地为非 null 值。 `CSharpWarnings::CS8762` `resharper_c_sharp_warnings_cs8762_highlighting`	警告
由于 [NotNullIfNotNull] 注解中提及的参数为非 null，函数退出时参数必须为非 null 值。 `CSharpWarnings::CS8824` `resharper_c_sharp_warnings_cs8824_highlighting`	警告
函数退出时参数必须为非 null 值。 `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`	警告
partial 方法声明的类型参数可空性不一致。 `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`	警告
record 定义了 '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`	警告
对 volatile 字段的引用不会被视为 volatile `CSharpWarnings::CS0420` `resharper_c_sharp_warnings_cs0420_highlighting`	警告
由于 [NotNullIfNotNull] 注解中提及的参数为非 null，返回值必须为非 null。 `CSharpWarnings::CS8825` `resharper_c_sharp_warnings_cs8825_highlighting`	警告
Signatures of interceptable and interceptor methods do not match `CSharpWarnings::CS9154` `resharper_c_sharp_warnings_cs9154_highlighting`	警告
Source file has exceeded the limit of 16,707,565 lines representable in the PDB; debug information will be incorrect `CSharpWarnings::CS1687` `resharper_c_sharp_warnings_cs1687_highlighting`	警告
Static type in 'is' or 'as' operator. `CSharpWarnings::CS7023` `resharper_c_sharp_warnings_cs7023_highlighting`	警告
Struct member returns 'this' or other instance members by reference. `CSharpWarnings::CS9084` `resharper_c_sharp_warnings_cs9084_highlighting`	警告
XML 注释中的语法错误 `CSharpWarnings::CS1584` `resharper_c_sharp_warnings_cs1584_highlighting`	警告
Taking address of marshal-by-reference class field `CSharpWarnings::CS0197` `resharper_c_sharp_warnings_cs0197_highlighting`	警告
模板应是静态表达式 `CSharp 警告：CA2254` `ReSharper：CSharp 警告 CA2254 突出显示`	提示
The '&' operator should not be used on parameters or local variables in async methods. `CSharpWarnings::CS9123` `resharper_c_sharp_warnings_cs9123_highlighting`	警告
The annotation for nullable reference types should only be used in code within a '#nullable' annotations context. `CSharpWarnings::CS8632` `resharper_c_sharp_warnings_cs8632_highlighting`	警告
可空引用类型的注解应仅在 '#nullable' 注解上下文中的代码中使用。自动生成的代码需要在源文件中显式添加 '#nullable' 指令。 `CSharpWarnings::CS8669` `resharper_c_sharp_warnings_cs8669_highlighting`	警告
The branches of the ref conditional operator refer to variables with incompatible declaration scopes. `CSharpWarnings::CS9086` `resharper_c_sharp_warnings_cs9086_highlighting`	警告
应用于参数的 CallerArgumentExpressionAttribute 无效，因为它是自引用的 `CSharpWarnings::CS8965` `resharper_c_sharp_warnings_cs8965_highlighting`	警告
The CallerArgumentExpressionAttribute is applied with an invalid parameter name. `CSharpWarnings::CS8963` `resharper_c_sharp_warnings_cs8963_highlighting`	警告
The CallerArgumentExpressionAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments `CSharpWarnings::CS8966` `resharper_c_sharp_warnings_cs8966_highlighting`	警告
The CallerArgumentExpressionAttribute will have no effect; it is overridden by the CallerFilePathAttribute `CSharpWarnings::CS8961` `resharper_c_sharp_warnings_cs8961_highlighting`	警告
The CallerArgumentExpressionAttribute will have no effect; it is overridden by the CallerLineNumberAttribute `CSharpWarnings::CS8960` `resharper_c_sharp_warnings_cs8960_highlighting`	警告
The CallerArgumentExpressionAttribute will have no effect; it is overridden by the CallerMemberNameAttribute `CSharpWarnings::CS8962` `resharper_c_sharp_warnings_cs8962_highlighting`	警告
CallerFilePathAttribute 将无效；其被 CallerLineNumberAttribute 覆盖 `CSharp 警告：CS7082` `ReSharper：CSharp 警告 CS7082 突出显示`	警告
CallerFilePathAttribute 将无效，因为其应用于不允许可选参数的上下文中使用的成员 `CSharp 警告：CS4025` `ReSharper：CSharp 警告 CS4025 突出显示`	警告
CallerLineNumberAttribute 将无效，因为其应用于不允许可选参数的上下文中使用的成员 `CSharp 警告：CS4024` `ReSharper：CSharp 警告 CS4024 突出显示`	警告
CallerMemberNameAttribute 将无效，因为其应用于不允许可选参数的上下文中使用的成员 `CSharp 警告：CS4026` `ReSharper：CSharp 警告 CS4026 突出显示`	警告
CallerMemberNameAttribute 将无效；其被 CallerFilePathAttribute 覆盖 `CSharp 警告：CS7080` `ReSharper：CSharp 警告 CS7080 突出显示`	警告
CallerMemberNameAttribute 将无效；其被 CallerLineNumberAttribute 覆盖 `CSharp 警告：CS7081` `ReSharper：CSharp 警告 CS7081 突出显示`	警告
The default parameter value does not match in the target delegate type. `CSharpWarnings::CS9099` `resharper_c_sharp_warnings_cs9099_highlighting`	警告
The 'EnumeratorCancellation' attribute is only effective on a parameter of type 'CancellationToken' in an async-iterator method returning 'IAsyncEnumerable<>'. `CSharpWarnings::CS8424` `resharper_c_sharp_warnings_cs8424_highlighting`	警告
The given expression always matches the provided constant. `CSharpWarnings::CS8520` `resharper_c_sharp_warnings_cs8520_highlighting`	警告
The given expression never matches the provided pattern. `CSharpWarnings::CS8519` `resharper_c_sharp_warnings_cs8519_highlighting`	警告
'l' 后缀容易与数字 '1' 混淆 `CSharpWarnings::CS0078` `resharper_c_sharp_warnings_cs0078_highlighting`	警告
The 'Main' method will not be used as an entry point because compilation unit with top-level statements was found. `CSharpWarnings::CS7022` `resharper_c_sharp_warnings_cs7022_highlighting`	警告
该参数期望为常量，以获得最佳性能 `CSharp 警告：CA1857` `ReSharper：CSharp 警告 CA1857 突出显示`	建议
与 '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`	警告
partial 结构体的多次声明之间字段没有定义顺序。如需指定顺序，所有实例字段必须在同一声明中。 `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 注释中存在 'Parameter' 的 param 标签，但没有该名称的参数 `CSharpWarnings::CS1572` `resharper_c_sharp_warnings_cs1572_highlighting`	警告
XML 注释中存在 'TypeParameter' 的 typeparam 标签，但没有该名称的类型参数 `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 项检查）

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

检查 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` `resharper_cannot_apply_equality_operator_to_type_highlighting`	警告

Entity Framework（8 项检查）

本类别分组的代码检查用于校验 Entity Framework 及其派生类型的类型和成员的用法。

检查 ID EditorConfig 属性	默认严重性
数据库函数不得在非数据库上下文中调用 `EntityFramework.ClientSideDbFunctionCall` `resharper_entity_framework_client_side_db_function_call_highlighting`	警告
函数无法转换为 SQL，且不得在数据库上下文中调用 `EntityFramework.UnsupportedServerSideFunctionCall` `resharper_entity_framework_unsupported_server_side_function_call_highlighting`	警告
可能对数据库发起多次查询（N+1 问题） `EntityFramework.NPlusOne.Usage` `resharper_entity_framework_n_plus_one_usage_highlighting`	警告
对相关实体可能发起多次数据库查询（N+1 问题） `EntityFramework.NPlusOne.Query` `resharper_entity_framework_n_plus_one_query_highlighting`	建议
字符串长度无限制可能导致性能问题 `EntityFramework.ModelValidation.UnlimitedStringLength` `resharper_entity_framework_model_validation_unlimited_string_length_highlighting`	警告
查询可能返回相关实体的不完整数据 `EntityFramework.NPlusOne.IncompleteDataQuery` `resharper_entity_framework_n_plus_one_incomplete_data_query_highlighting`	建议
此属性定义的关系导致依赖循环 `EntityFramework.ModelValidation.CircularDependency` `resharper_entity_framework_model_validation_circular_dependency_highlighting`	提示
导航属性的使用可能返回不完整数据 `EntityFramework.NPlusOne.IncompleteDataUsage` `resharper_entity_framework_n_plus_one_incomplete_data_usage_highlighting`	警告

格式化（41 项检查）

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

检查 ID EditorConfig 属性	默认严重性
空行不正确（其他位置缺少空行） `MissingBlankLines` `resharper_missing_blank_lines_highlighting`	已禁用
空行不正确（其他位置空行多余） `RedundantBlankLines` `resharper_redundant_blank_lines_highlighting`	已禁用
空行不正确（大括号附近空行数不正确） `IncorrectBlankLinesNearBraces` `resharper_incorrect_blank_lines_near_braces_highlighting`	已禁用
缩进不正确（子语句周围） `BadChildStatementIndent` `resharper_bad_child_statement_indent_highlighting`	警告
缩进不正确（声明大括号周围） `BadDeclarationBracesIndent` `ReSharper 声明大括号缩进不规范`	已禁用
缩进不正确（表达式大括号周围） `表达式大括号缩进不规范` `ReSharper 表达式大括号缩进不规范`	已禁用
缩进不正确（命名空间大括号周围） `命名空间大括号缩进不规范` `ReSharper 命名空间大括号缩进不规范`	已禁用
缩进不正确（预处理指令周围） `预处理指令缩进不规范` `ReSharper 预处理指令缩进不规范`	已禁用
缩进不正确（语句大括号周围） `控制结构大括号缩进不规范` `ReSharper 控制结构大括号缩进不规范`	建议
缩进不正确（switch 语句周围） `switch 结构大括号缩进不规范` `ReSharper switch 结构大括号缩进不规范`	已禁用
缩进不正确（缩进大小不正确） `缩进宽度错误` `ReSharper 缩进宽度错误`	已禁用
缩进不正确（缩进级别未恢复） `反缩进与上一级不一致` `ReSharper 反缩进与上一级不一致`	已禁用
缩进不正确（其他位置缺少缩进/取消缩进） `缺少缩进` `ReSharper 缺少缩进`	已禁用
缩进不正确（其他位置缩进/取消缩进多余） `缩进不规范` `ReSharper 缩进不规范`	已禁用
缩进不正确（制表符/空格不匹配） `制表符与空格混用不一致` `ReSharper 制表符与空格混用不一致`	已禁用
换行不正确（列表中逗号周围） `列表换行格式不规范` `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_replace_conditional_expression_with_null_coalescing_highlighting`	建议
将 'as' 表达式类型检查及后续 null 检查转换为取反模式匹配 `使用取反的模式匹配` `resharper_use_negated_pattern_matching_highlighting`	提示
将 'as' 表达式类型检查及后续 null 检查转换为模式匹配 `使用模式匹配` `resharper_use_pattern_matching_highlighting`	建议
将构造函数转换为成员初始化器 `将构造函数转换为成员初始化器` `resharper_convert_constructor_to_member_initializers_highlighting`	建议
将构造函数转换为主构造函数 `转换为主构造函数` `resharper_convert_to_primary_constructor_highlighting`	建议
将委托变量转换为局部函数 `转换为本地函数` `resharper_convert_to_local_function_highlighting`	建议
将 'if' 语句转换为 'switch' `将 if 语句转换为 switch 语句` `resharper_convert_if_statement_to_switch_statement_highlighting`	提示
转换为 'await using' 语句或声明 `使用 await using` `resharper_use_await_using_highlighting`	建议
转换为 lambda 表达式 `转换为 Lambda 表达式` `resharper_convert_to_lambda_expression_highlighting`	建议
转换为静态类 `转换为静态类` `resharper_convert_to_static_class_highlighting`	建议
转换为 'using' 声明 `转换为 using 声明` `resharper_convert_to_using_declaration_highlighting`	建议
将 lambda 表达式转换为方法组 `将闭包转换为方法组` `resharper_convert_closure_to_method_group_highlighting`	建议
将取反的 'is' 表达式转换为带取反模式的 'is' 表达式 `在 is 表达式中使用取反的模式` `resharper_use_negated_pattern_in_is_expression_highlighting`	提示
将 'Nullable<T>' 转换为 'T?' `将可空类型转换为简写形式` `resharper_convert_nullable_to_short_form_highlighting`	建议
将属性转换为自动属性 `转换为自动属性` `resharper_convert_to_auto_property_highlighting`	建议
将属性转换为自动属性（如可行） `在可能的情况下，转换为自动属性` `resharper_convert_to_auto_property_when_possible_highlighting`	提示
将属性转换为带 private setter 的自动属性 `转换为带私有 setter 的自动属性` `resharper_convert_to_auto_property_with_private_setter_highlighting`	提示
将静态方法调用转换为扩展方法调用 `作为扩展方法调用` `resharper_invoke_as_extension_method_highlighting`	建议
Foreach 循环可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法 `foreach 可使用其他 GetEnumerator 转换为查询` `resharper_foreach_can_be_converted_to_query_using_another_get_enumerator_highlighting`	提示
For 循环可转换为 foreach 循环 `for 可转换为 foreach` `resharper_for_can_be_converted_to_foreach_highlighting`	建议
'if' 语句可重写为 '?:' 表达式 `将 if 语句转换为三元条件表达式` `resharper_convert_if_statement_to_conditional_ternary_expression_highlighting`	建议
'if' 语句可重写为 '??' 表达式 `将 if 语句转换为 null 合并表达式` `resharper_convert_if_statement_to_null_coalescing_expression_highlighting`	建议
'if' 语句可重写为 '??=' 赋值 `将 if 语句转换为 null 合并赋值` `resharper_convert_if_statement_to_null_coalescing_assignment_highlighting`	建议
'if-return' 语句可重写为 'return' 语句 `将 if 语句转换为 return 语句` `resharper_convert_if_statement_to_return_statement_highlighting`	提示
内联 'out' 变量声明 `将 out 变量声明内联` `resharper_inline_out_variable_declaration_highlighting`	建议
内联临时变量 `内联临时变量` `resharper_inline_temporary_variable_highlighting`	提示
引入可选参数（非 private 可访问性） `引入可选参数（全局）` `resharper_introduce_optional_parameters_global_highlighting`	建议
引入可选参数（private 可访问性） `引入可选参数（局部）` `resharper_introduce_optional_parameters_local_highlighting`	建议
反转 'if' 语句以减少嵌套 `反转 if` `resharper_invert_if_highlighting`	提示
合并 null 检查与赋值 `将 null 检查与使用合并` `resharper_join_null_check_with_usage_highlighting`	建议
Lambda 表达式/匿名方法可设为 'static' `Lambda 表达式可以设为 static` `resharper_lambda_expression_can_be_made_static_highlighting`	已禁用
Lambda 表达式/匿名方法必须为 'static' 以避免分配 `Lambda 表达式必须为 static` `resharper_lambda_expression_must_be_static_highlighting`	建议
Lambda 表达式/匿名方法不得捕获包含上下文 `Lambda 不应捕获上下文` `resharper_lambda_should_not_capture_context_highlighting`	警告
可通过使用逐字字符串减少字面量长度 `使用逐字字符串` `resharper_use_verbatim_string_highlighting`	提示
循环可以转换为 LINQ 表达式 `循环可以转换为查询` `resharper_loop_can_be_converted_to_query_highlighting`	提示
合并 'and' 模式 `合并 And 模式` `resharper_merge_and_pattern_highlighting`	建议
将条件 ?: 表达式合并为条件访问 `合并条件表达式` `resharper_merge_conditional_expression_highlighting`	建议
将取反的 null/模式检查合并为复杂模式 `合并为取反的模式` `resharper_merge_into_negated_pattern_highlighting`	提示
合并嵌套属性模式 `合并嵌套属性模式` `resharper_merge_nested_property_patterns_highlighting`	建议
将 null/模式检查合并为复杂模式 `合并为模式` `resharper_merge_into_pattern_highlighting`	建议
将 null/模式/值检查合并为 'or'/'and' 模式 `合并为逻辑模式` `resharper_merge_into_logical_pattern_highlighting`	提示
将顺序检查合并为单个条件访问检查 `合并连续检查` `resharper_merge_sequential_checks_highlighting`	提示
移至现有的位置解构模式 `移动到已存在的位置解构模式` `将变量移至现有的位置解构模式中进行高亮显示`	提示
将变量声明移至循环条件内 `将变量声明移入循环条件中` `在循环条件中移动变量声明的高亮显示`	建议
Foreach 循环的一部分可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法 `可以使用另一个 GetEnumerator 将 foreach 部分转换为查询` `通过另一个 GetEnumerator 部分转换为查询的 foreach 高亮显示`	提示
循环体的一部分可以转换为 LINQ 表达式 `循环可部分转换为查询` `循环可被部分转换为查询的高亮显示`	已禁用
传递字符串插值表达式 `传递字符串插值` `传递字符串插值的高亮显示`	提示
多余的访问器主体 `冗余访问器主体` `冗余访问器主体的高亮显示`	建议
多余的展开元素 `冗余展开元素` `冗余展开元素的高亮显示`	建议
用计算属性替换自动属性 `用计算属性替换自动属性` `用计算属性替换自动属性的高亮显示`	提示
用 null 传播代码替换 if 语句 `使用 null 传播` `使用 null 传播的高亮显示`	提示
将未执行额外检查的对象模式替换为 'var' 模式 `用 var 模式替换对象模式` `用 var 模式替换对象模式的高亮显示`	建议
用常量模式替换 'SequenceEqual' `使用常量模式替换 SequenceEqual` `用常量模式替换 SequenceEqual 的高亮显示`	建议
用区间索引器替换 'Slice' `用范围索引器替换切片` `用范围索引器替换切片的高亮显示`	提示
用区间索引器替换 'Substring' `用范围索引器替换 Substring` `用范围索引器替换 Substring 的高亮显示`	提示
用 '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' 表达式 `对依赖属性使用 nameof` `对依赖属性使用 nameof 的高亮显示`	建议
尽可能使用对象或集合初始化器 `使用对象或集合初始化器` `使用对象或集合初始化器的高亮显示`	建议
使用位置解构模式 `使用位置解构模式` `使用位置解构模式的高亮显示`	已禁用
使用原始字符串 `使用原始字符串` `使用原始字符串的高亮显示`	提示
使用字符串插值表达式 `使用字符串插值` `使用字符串插值的高亮显示`	建议
使用类型注解语法 `使用可空引用类型注释语法` `使用可空引用类型注释语法的高亮显示`	警告
使用无符号右移运算符 '>>> ' `使用无符号右移运算符` `使用无符号右移运算符的高亮显示`	建议
使用 UTF-8 字符串字面量 `使用 UTF-8 字符串字面量` `使用 UTF-8 字符串字面量的高亮显示`	建议
使用 'with' 表达式复制匿名对象 `使用 with 表达式复制匿名对象` `使用 with 表达式复制匿名对象的高亮显示`	建议
使用 'with' 表达式复制 record `使用 with 表达式复制记录` `使用 with 表达式复制记录的高亮显示`	建议
使用 'with' 表达式复制结构体 `使用 with 表达式复制结构体` `使用 with 表达式复制结构体的高亮显示`	建议
使用 'with' 表达式复制元组 `使用 with 表达式复制元组` `使用 with 表达式复制元组的高亮显示`	建议

NUnit（30 项检查）

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

检查 ID EditorConfig 属性	默认严重性
NUnit。 Async test method must return Task or Task<T> `NUnit 异步方法必须返回 Task` `NUnit 异步方法必须返回 Task 的高亮显示`	警告
NUnit。存在重复值。 `NUnit.DuplicateValues` `resharper_n_unit_duplicate_values_highlighting`	警告
NUnit。参数属性被忽略。 `NUnit.IgnoredParameterAttribute` `resharper_n_unit_ignored_parameter_attribute_highlighting`	警告
NUnit。隐式未指定的 null 值。 `NUnit.ImplicitUnspecifiedNullValues` `resharper_n_unit_implicit_unspecified_null_values_highlighting`	警告
NUnit。参数类型不兼容或参数值不正确。 `NUnit.IncorrectArgumentType` `resharper_n_unit_incorrect_argument_type_highlighting`	警告
NUnit。期望结果类型不兼容或值不正确。 `NUnit.IncorrectExpectedResultType` `resharper_n_unit_incorrect_expected_result_type_highlighting`	警告
NUnit。范围边界不正确。 'to' 必须大于或等于 'from'。 `NUnit.IncorrectRangeBounds` `resharper_n_unit_incorrect_range_bounds_highlighting`	警告
NUnit。区间步长符号不匹配。 `NUnit.RangeStepSignMismatch` `resharper_n_unit_range_step_sign_mismatch_highlighting`	警告
NUnit。 TestCase 属性中缺少参数。 `NUnit.MissingArgumentsInTestCaseAttribute` `resharper_n_unit_missing_arguments_in_test_case_attribute_highlighting`	警告
NUnit。测试方法声明缺少 'CancelAfter' 属性。 `NUnit.MissingCancelAfterAttribute` `resharper_n_unit_missing_cancel_after_attribute_highlighting`	警告
NUnit。非 void 测试方法缺少期望结果。 `NUnit.TestCaseAttributeRequiresExpectedResult` `resharper_n_unit_test_case_attribute_requires_expected_result_highlighting`	警告
NUnit。属性中未提供任何值。 `NUnit.NoValuesProvided` `resharper_n_unit_no_values_provided_highlighting`	警告
NUnit。测试方法非公开。 `NUnit.NonPublicMethodWithTestAttribute` `resharper_n_unit_non_public_method_with_test_attribute_highlighting`	警告
NUnit。区间 'step' 参数值必须为非零。 `NUnit.RangeStepValueMustNotBeZero` `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。 `NUnit.RedundantArgumentInsteadOfExpectedResult` `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。指定的属性值生成的测试用例过多。 `NUnit.AttributeProducesTooManyTests` `resharper_n_unit_attribute_produces_too_many_tests_highlighting`	已禁用
NUnit。指定的值与测试参数类型不兼容。 `NUnit.ParameterTypeIsNotCompatibleWithAttribute` `resharper_n_unit_parameter_type_is_not_compatible_with_attribute_highlighting`	警告
NUnit。测试用例 Result 属性与 ExpectedResult 重复。 `NUnit.TestCaseResultPropertyDuplicatesExpectedResult` `resharper_n_unit_test_case_result_property_duplicates_expected_result_highlighting`	警告
NUnit。测试用例 Result 属性已过时。 `NUnit.TestCaseResultPropertyIsObsolete` `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。以当前步长无法达到最大区间值。 `NUnit.RangeToValueIsNotReachable` `resharper_n_unit_range_to_value_is_not_reachable_highlighting`	警告
NUnit。未为测试方法参数提供值。 `NUnit.MethodWithParametersAndTestAttribute` `resharper_n_unit_method_with_parameters_and_test_attribute_highlighting`	警告
NUnit。区间内的值不适用于测试参数类型。 `NUnit.RangeAttributeBoundsAreOutOfRange` `resharper_n_unit_range_attribute_bounds_are_out_of_range_highlighting`	警告
NUnit.AutoFixture。参数类型不兼容或参数值不正确。 `NUnit.AutoFixture.IncorrectArgumentType` `resharper_n_unit_auto_fixture_incorrect_argument_type_highlighting`	警告
NUnit.AutoFixture。缺少 Test 或 TestFixture 属性。 `NUnit.AutoFixture.MissedTestOrTestFixtureAttribute` `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 分支相同 `ConditionalTernaryEqualBranch` `resharper_conditional_ternary_equal_branch_highlighting`	警告
[MustDisposeResource] 注解不会从基类构造函数继承，需显式添加 `ConstructorWithMustDisposeResourceAttributeBaseIsNotAnnotated` `resharper_constructor_with_must_dispose_resource_attribute_base_is_not_annotated_highlighting`	警告
[ThreadStatic] 不适用于实例字段 `ThreadStaticAtInstanceField` `resharper_thread_static_at_instance_field_highlighting`	警告
被抑制的可空性警告可能隐藏潜在问题 `NullableWarningSuppressionIsUsed` `resharper_nullable_warning_suppression_is_used_highlighting`	已禁用
抽象或虚拟（可重写）事件从未被调用 `EventNeverInvoked.Global` `resharper_event_never_invoked_global_highlighting`	建议
访问已释放的捕获变量 `AccessToDisposedClosure` `resharper_access_to_disposed_closure_highlighting`	警告
在闭包中访问 foreach 变量 `AccessToForEachVariableInClosure` `resharper_access_to_for_each_variable_in_closure_highlighting`	警告
访问已修改的捕获变量 `AccessToModifiedClosure` `resharper_access_to_modified_closure_highlighting`	警告
根据位掩码的值，表达式结果始终相同 `NonConstantEqualityExpressionHasConstantResult` `resharper_non_constant_equality_expression_has_constant_result_highlighting`	警告
实际移位数为零 `ShiftExpressionRealShiftCountIsZero` `resharper_shift_expression_real_shift_count_is_zero_highlighting`	警告
文本参数中存在歧义符号 `文本中存在多个解析候选项` `ReSharper：文本中存在多个解析候选项（高亮显示）`	警告
层次结构中的注解冲突 `层级中的注解存在冲突` `ReSharper：层级中的注解存在冲突（高亮显示）`	警告
条件表达式中的赋值 `条件表达式中的赋值语句` `ReSharper：条件表达式中的赋值语句（高亮显示）`	警告
异步迭代器调用未使用 'await foreach' `异步迭代器调用未使用 await foreach` `ReSharper：异步迭代器调用未使用 await foreach（高亮显示）`	警告
自动属性访问器从未使用（非私有可访问性） `未使用自动属性访问器（全局）` `ReSharper：未使用自动属性访问器（全局，高亮显示）`	警告
自动属性访问器从未使用（私有可访问性） `未使用自动属性访问器（局部）` `ReSharper：未使用自动属性访问器（局部，高亮显示）`	警告
避免混用变长转义序列与文本 `变量长度字符串十六进制转义序列` `ReSharper：变量长度字符串十六进制转义序列（高亮显示）`	警告
避免对返回类型为 'void' 且具有 'System.EventArgs' 类型参数的方法和函数使用 'async' `AsyncVoid 事件处理方法` `ReSharper：AsyncVoid 事件处理方法突出显示`	建议
避免对返回类型为 'void' 且没有 'System.EventArgs' 类型参数的方法和函数使用 'async' `异步 void 方法` `ReSharper：异步 void 方法（高亮显示）`	建议
避免在委托类型返回 'void' 时使用 'async' lambda `异步 void Lambda 表达式` `ReSharper：异步 void Lambda 表达式（高亮显示）`	警告
后备字段已赋值但从未被使用 `永远未使用的字段关键字` `ReSharper：永远未使用的字段关键字（高亮显示）`	警告
后备字段被使用但从未赋值 `字段关键字从未被赋值` `ReSharper：字段关键字从未被赋值（高亮显示）`	警告
对未标记 [Flags] 属性的枚举进行按位操作 `未标记 Flags 的枚举使用了按位运算符` `ReSharper：未标记 Flags 的枚举使用了按位运算符（高亮显示）`	警告
调用具有隐式默认参数的基成员 `带默认参数的基方法调用` `ReSharper：带默认参数的基方法调用（高亮显示）`	警告
调用 'base.Equals(...)' 是引用相等 `BaseObject.Equals 即 Object.Equals` `ReSharper：BaseObject.Equals 即 Object.Equals（高亮显示）`	警告
文本参数中无法访问静态符号 `文本中存在静态问题` `ReSharper：文本中存在静态问题（高亮显示）`	警告
文本参数中无法访问符号 `文本中存在访问权限问题` `ReSharper：文本中存在访问权限问题（高亮显示）`	警告
无法解析属性 `属性无法解析` `ReSharper：属性无法解析（高亮显示）`	错误
无法解析资源 `资源无法解析` `ReSharper：资源无法解析（高亮显示）`	错误
无法解析资源项 `资源项无法解析` `ReSharper：资源项无法解析（高亮显示）`	错误
无法解析文本参数中的符号 `文本中未能解析` `ReSharper：文本中未能解析（高亮显示）`	警告
捕获 marshal-by-reference 类的字段引用可能导致运行时异常 `MarshalByRefObject 的地址使用方式不当` `ReSharper：MarshalByRefObject 的地址使用方式不当（高亮显示）`	警告
捕获的主构造函数参数是可变的 `捕获的主构造函数参数是可变的` `ReSharper：捕获的主构造函数参数是可变的（高亮显示）`	警告
捕获的对 'volatile' 字段的引用不会被视为 'volatile' `ref 参数是 volatile 字段` `ReSharper：ref 参数是 volatile 字段（高亮显示）`	警告
Char 可能被无意中当作整数使用 `构造函数中字符作为整数使用易产生误解` `ReSharper：构造函数中字符作为整数使用易产生误解（高亮显示）`	警告
类从未被实例化（非私有可访问性） `类从未被实例化（全局）` `ReSharper：类从未被实例化（全局，高亮显示）`	建议
类从未被实例化（私有可访问性） `类从未被实例化（局部）` `ReSharper：类从未被实例化（局部，高亮显示）`	建议
集合内容从未被查询（非私有可访问性） `集合从未被查询（全局）` `ReSharper：集合从未被查询（全局，高亮显示）`	警告
集合内容从未被查询（私有可访问性） `集合从未被查询（局部）` `ReSharper：集合从未被查询（局部，高亮显示）`	警告
集合从未被更新（非私有可访问性） `集合从未被更新（全局）` `ReSharper：集合从未被更新（全局，高亮显示）`	警告
集合从未被更新（私有可访问性） `集合从未被更新（局部）` `ReSharper：集合从未被更新（局部，高亮显示）`	警告
冲突的 CQRS 属性 `冲突 CQRS 特性` `ReSharper：冲突 CQRS 特性突出显示`	警告
常量移位表达式的操作数均非零但结果为零 `移位表达式结果恒为零` `ReSharper：移位表达式结果恒为零（高亮显示）`	警告
协变数组转换 `协变数组转换` `ReSharper：协变数组转换（高亮显示）`	警告
CQRS 上下文交叉。 Command 从 Query 上下文中调用。（显示在声明中） `命令侵入声明：全局` `ReSharper：命令侵入声明（全局）突出显示`	警告
CQRS 上下文交叉。 Command 从 Query 上下文中调用。（显示在用法中） `命令侵入使用：全局` `ReSharper：命令侵入使用（全局）突出显示`	警告
CQRS 上下文交叉。 Query 从 Command 上下文中调用。（显示在声明中） `查询侵入声明：全局` `ReSharper：查询侵入声明（全局）突出显示`	警告
CQRS 上下文交叉。 Query 从 Command 上下文中调用。（显示在用法中） `查询侵入使用：全局` `ReSharper：查询侵入使用（全局）突出显示`	警告
已被 'using' 语句捕获的变量被释放 `using 变量已调用 Dispose` `ReSharper：using 变量已调用 Dispose（高亮显示）`	警告
至少有一条执行路径存在除零操作 `整数除以零` `ReSharper：整数除以零（高亮显示）`	警告
请勿在 'async void' 方法和函数中重新抛出异常 `AsyncVoid 抛出异常` `ReSharper：AsyncVoid 抛出异常突出显示`	建议
请勿将 SpinLock 存储在 readonly 字段中 `readonly 字段中使用 SpinLock` `ReSharper：readonly 字段中使用 SpinLock（高亮显示）`	警告
请勿对 'using' 变量使用对象初始化器 `using 语句中资源初始化问题` `ReSharper：using 语句中资源初始化问题（高亮显示）`	警告
请勿对 'using' 变量使用对象初始化器（对象初始化器表达式在初始化 'using' 变量时可能抛出异常） `using 表达式中资源初始化问题` `ReSharper：using 表达式中资源初始化问题（高亮显示）`	提示
在格式字符串中格式说明符后不要使用右大括号 `格式说明符捕获了右大括号` `ReSharper：格式说明符捕获了右大括号（高亮显示）`	警告
字典/集合初始化中存在重复键 `集合初始化中存在重复键` `ReSharper：集合初始化中存在重复键（高亮显示）`	警告
链式 'if' 分支重复 `链式 if 语句中存在重复代码块` `ReSharper：链式 if 语句中存在重复代码块（高亮显示）`	提示
顺序 'if' 分支重复 `连续 if 语句中存在重复代码块` `ReSharper：连续 if 语句中存在重复代码块（高亮显示）`	提示
重复的 'switch' 分支项 `重复的 switch 表达式分支` `ReSharper：重复 switch 表达式分支突出显示`	提示
重复的 'switch' 分支体 `Switch 构造中存在重复代码块` `ReSharper：Switch 构造中存在重复代码块（高亮显示）`	提示
元素是可本地化的 `可本地化的元素` `resharper_localizable_element_highlighting`	警告
空的通用 catch 子句 `EmptyGeneralCatchClause` `resharper_empty_general_catch_clause_highlighting`	警告
空的 'with' 表达式是多余的 `RedundantWithExpression` `resharper_redundant_with_expression_highlighting`	建议
在显式 unchecked 上下文中调用 'Enumerable.Sum' `EnumerableSumInExplicitUncheckedContext` `resharper_enumerable_sum_in_explicit_unchecked_context_highlighting`	警告
浮点数的相等性比较 `CompareOfFloatsByEqualityOperator` `resharper_compare_of_floats_by_equality_operator_highlighting`	警告
转义序列可简化 `CanSimplifyStringEscapeSequence` `resharper_can_simplify_string_escape_sequence_highlighting`	提示
事件从未被订阅（非私有可访问性） `EventNeverSubscribedTo.Global` `resharper_event_never_subscribed_to_global_highlighting`	建议
事件从未被订阅（私有可访问性） `EventNeverSubscribedTo.Local` `resharper_event_never_subscribed_to_local_highlighting`	建议
事件从未被调用 `EventNeverInvoked` `resharper_event_never_invoked_highlighting`	警告
通过匿名委托取消事件订阅 `EventUnsubscriptionViaAnonymousDelegate` `resharper_event_unsubscription_via_anonymous_delegate_highlighting`	警告
可能是有意的异常重新抛出 `PossibleIntendedRethrow` `resharper_possible_intended_rethrow_highlighting`	警告
显式参数传递给带有调用者信息属性的参数 `ExplicitCallerInfoArgument` `resharper_explicit_caller_info_argument_highlighting`	警告
提取通用代码 `ExtractCommonBranchingCode` `resharper_extract_common_branching_code_highlighting`	提示
字段隐藏了接口中具有默认实现的属性 `FieldHidesInterfacePropertyWithDefaultImplementation` `resharper_field_hides_interface_property_with_default_implementation_highlighting`	警告
已指定格式，但插值字符串表达式不是 IFormattable `InterpolatedStringExpressionIsNotIFormattable` `resharper_interpolated_string_expression_is_not_i_formattable_highlighting`	警告
函数体过于复杂，无法分析 `FunctionComplexityOverflow` `resharper_function_complexity_overflow_highlighting`	已禁用
所有执行路径上函数均为递归调用 `FunctionRecursiveOnAllPaths` `resharper_function_recursive_on_all_paths_highlighting`	警告
函数从未返回 `FunctionNeverReturns` `resharper_function_never_returns_highlighting`	警告
调用 'GC.SuppressFinalize' 的类型没有析构函数 `GCSuppressFinalizeForTypeWithoutDestructor` `resharper_gc_suppress_finalize_for_type_without_destructor_highlighting`	警告
根据整数分析，分支不可达 `UnreachableSwitchCaseDueToIntegerAnalysis` `resharper_unreachable_switch_case_due_to_integer_analysis_highlighting`	警告
根据整数分析，switch 分支不可达 `UnreachableSwitchArmDueToIntegerAnalysis` `resharper_unreachable_switch_arm_due_to_integer_analysis_highlighting`	警告
传递给 'Math.Clamp()' 方法的参数不一致 `MathClampMinGreaterThanMax` `resharper_math_clamp_min_greater_than_max_highlighting`	警告
加锁顺序不一致 `InconsistentOrderOfLocks` `resharper_inconsistent_order_of_locks_highlighting`	警告
字段上的同步操作不一致 `InconsistentlySynchronizedField` `resharper_inconsistently_synchronized_field_highlighting`	警告
末尾索引必须大于零；使用 '^1' 表示最后一个元素 `ZeroIndexFromEnd` `resharper_zero_index_from_end_highlighting`	警告
标记为 ServiceContract 的接口应至少声明一个 OperationContract `ServiceContractWithoutOperations` `resharper_service_contract_without_operations_highlighting`	警告
无效的 XML 文档注释 `InvalidXmlDocComment` `resharper_invalid_xml_doc_comment_highlighting`	警告
多态字段式事件的调用 `PolymorphicFieldLikeEventInvocation` `resharper_polymorphic_field_like_event_invocation_highlighting`	警告
IQueryable 可能被无意中当作 IEnumerable 使用 `PossibleUnintendedQueryableAsEnumerable` `resharper_possible_unintended_queryable_as_enumerable_highlighting`	建议
迭代器从未返回 `IteratorNeverReturns` `resharper_iterator_never_returns_highlighting`	警告
局部函数隐藏了方法 `LocalFunctionHidesMethod` `resharper_local_function_hides_method_highlighting`	警告
局部变量隐藏了成员 `LocalVariableHidesMember` `resharper_local_variable_hides_member_highlighting`	警告
局部变量隐藏了主构造函数参数 `LocalVariableHidesPrimaryConstructorParameter` `resharper_local_variable_hides_primary_constructor_parameter_highlighting`	警告
循环控制变量在循环内未被更改 `LoopVariableIsNeverChangedInsideLoop` `resharper_loop_variable_is_never_changed_inside_loop_highlighting`	警告
对输出参数使用 [HandlesResourceDisposal] 注解无意义 `OutParameterWithHandlesResourceDisposalAttribute` `resharper_out_parameter_with_handles_resource_disposal_attribute_highlighting`	警告
对输入参数使用 [MustDisposeResource] 注解无意义 `InParameterWithMustDisposeResourceAttribute` `resharper_in_parameter_with_must_dispose_resource_attribute_highlighting`	警告
成员隐藏了外部类的静态成员 `MemberHidesStaticFromOuterClass` `resharper_member_hides_static_from_outer_class_highlighting`	警告
成员初始化值被忽略 `MemberInitializerValueIgnored` `resharper_member_initializer_value_ignored_highlighting`	警告
方法从两个 CQRS 上下文中被调用（显示在声明中） `双上下文调用声明：全局` `ReSharper：双上下文调用声明（全局）突出显示`	警告
方法从两个 CQRS 上下文中被调用（显示在用法中） `双上下文调用使用：全局` `ReSharper：双上下文调用使用（全局）突出显示`	警告
方法已标记为 OperationContract，但其所属类型未标记为 ServiceContract `OperationContractWithoutServiceContract` `resharper_operation_contract_without_service_contract_highlighting`	警告
带有可选或 'params' 参数的方法被重载隐藏 `MethodOverloadWithOptionalParameter` `resharper_method_overload_with_optional_parameter_highlighting`	警告
重写方法中的可选参数值不匹配 `OptionalParameterHierarchyMismatch` `resharper_optional_parameter_hierarchy_mismatch_highlighting`	警告
库代码中的异步可释放对象缺少 '.ConfigureAwait(false)' `UseConfigureAwaitFalseForAsyncDisposable` `resharper_use_configure_await_false_for_async_disposable_highlighting`	已禁用
库代码中缺少 '.ConfigureAwait(false)' `UseConfigureAwaitFalse` `resharper_use_configure_await_false_highlighting`	建议
请将 shebang 指令移动到文件开头 `Shebang 指令放置位置错误` `ReSharper：Shebang 指令放置位置错误突出显示`	警告
多次连续调用 'OrderBy' `使用多个 OrderBy 子句` `对多个 OrderBy 子句的高亮显示`	警告
未访问的字段（非私有可访问性） `未访问的全局字段` `对未访问的全局字段的高亮显示`	建议
未访问的字段（私有可访问性） `未访问的局部字段` `对未访问的局部字段的高亮显示`	警告
未访问的位置属性（非私有可访问性） `未访问的位置属性（全局）` `对未访问的位置属性（全局）的高亮显示`	警告
未访问的位置属性（私有可访问性） `未访问的位置属性（局部）` `对未访问的位置属性（局部）的高亮显示`	警告
实现类中的非公开成员隐藏了接口中的默认实现 `成员隐藏了具有默认实现的接口成员` `对隐藏了具有默认实现的接口成员的高亮显示`	警告
在 'GetHashCode()' 中引用的非 readonly 类型成员 `在 GetHashCode 中使用了非 readonly 成员` `对在 GetHashCode 中使用了非 readonly 成员的高亮显示`	警告
可空性与层级结构中的注解冲突 `空值注解与 JetBrains 注解冲突` `对空值注解与 JetBrains 注解冲突的高亮显示`	警告
可空性警告抑制运算符可能与取反的 'is' 表达式混淆 `抑制 Nullable 警告表达式被用作反向 is 表达式` `对抑制 Nullable 警告表达式被用作反向 is 表达式的高亮显示`	警告
'Object.ReferenceEquals' 始终为 false，因为它是用值类型调用的 `针对值类型使用 ReferenceEquals` `对针对值类型使用 ReferenceEquals 的高亮显示`	警告
单向操作不得返回值 `具有返回类型的 one-way 操作契约` `对具有返回类型的 one-way 操作契约的高亮显示`	警告
可以使用运算符 'is'/'Type Of ... Is ...' `可以使用 is 运算符` `对可以使用 is 运算符的高亮显示`	警告
运算符未提供匹配的 checked 运算符 `运算符缺少对应的 checked 运算符` `对缺少对应 checked 运算符的运算符的高亮显示`	警告
重写的 GetHashCode 调用了基类 'Object.GetHashCode()' `在 GetHashCode 中调用了基类 Object.GetHashCode` `对在 GetHashCode 中调用基类 Object.GetHashCode 的高亮显示`	警告
参数隐藏了成员 `参数隐藏了成员` `对参数隐藏成员的高亮显示`	警告
参数隐藏了主构造函数参数 `构造函数参数隐藏了主构造函数的参数` `对构造函数参数隐藏主构造函数参数的高亮显示`	警告
partial 成员声明中的参数名称不同 `partial 方法参数名称不匹配` `对 partial 方法参数名称不匹配的高亮显示`	警告
通过接口访问成员时可能存在歧义 `接口成员可能存在歧义` `对接口成员可能存在歧义的高亮显示`	警告
值类型与 'null' 的比较可能无意义 `将未受约束的泛型与 null 进行比较` `对将未受约束的泛型与 null 进行比较的高亮显示`	已禁用
可能存在循环构造函数调用 `构造函数初始化器循环调用` `对构造函数初始化器循环调用的高亮显示`	警告
可能的双重检查锁定模式的错误实现。可能对检查字段的多次写访问。 `双重检查锁定中可能的多次写入访问` `对双重检查锁定中可能的多次写入访问的高亮显示`	警告
可能的双重检查锁定模式的错误实现。对检查字段的读取访问。 `双重检查锁定中的读取访问` `对双重检查锁定中的读取访问的高亮显示`	警告
可能的无限继承 `可能的无限继承` `对可能的无限继承的高亮显示`	警告
可能丢失小数部分 `可能丢失小数部分` `对可能丢失小数部分的高亮显示`	警告
可能错误地传递了类型为 'System.Type' 的参数 `可能错误使用了 System 类型参数` `对可能错误使用 System 类型参数的高亮显示`	警告
可能错误调用了 'GetType()' `可能误用 GetType 调用` `对可能误用 GetType 调用的高亮显示`	警告
可能的多次枚举 `可能进行了多次枚举` `对可能进行了多次枚举的高亮显示`	警告
可能溢出 `整数变量溢出` `对整数变量溢出的高亮显示`	警告
在 checked 上下文中可能溢出 `在 checked 上下文中整数变量溢出` `对在 checked 上下文中整数变量溢出的高亮显示`	警告
在 unchecked 上下文中可能溢出 `在 unchecked 上下文中整数变量溢出` `对在 unchecked 上下文中整数变量溢出的高亮显示`	警告
可能抛出 'System.ArgumentOutOfRangeException'。索引必须为非负整数。 `负索引` `对负索引的高亮显示`	警告
可能抛出 'System.ArgumentOutOfRangeException'。起始索引必须小于或等于结束索引。 `使用无效范围进行索引` `对使用无效范围进行索引的高亮显示`	警告
可能抛出 'System.InvalidCastException' `可能的无效强制转换异常` `对可能的无效强制转换异常的高亮显示`	警告
在 foreach 循环中可能抛出 'System.InvalidCastException' `在 foreach 循环中可能出现的无效强制转换异常` `对在 foreach 循环中可能出现的无效强制转换异常的高亮显示`	警告
可能抛出 'System.InvalidOperationException' `可能的 InvalidOperationException` `对可能的 InvalidOperationException 的高亮显示`	警告
可能抛出 'System.InvalidOperationException: Collection was modified' `集合被修改后可能抛出 InvalidOperationException` `对集合被修改后可能抛出 InvalidOperationException 的高亮显示`	警告
可能抛出 'System.NullReferenceException' `可能的空引用异常` `对可能的空引用异常的高亮显示`	警告
通过 'new' 表达式创建的对象可能未被赋值 `对象创建作为语句使用` `对将对象创建用作语句的高亮显示`	警告
可能为非预期的引用比较 `可能是无意的引用比较` `对可能的无意引用比较的高亮显示`	警告
可能在 readonly 变量上调用非纯结构体方法：结构体值在调用前始终被复制 `在 readonly 变量上调用可能具有副作用的方法` `对在 readonly 变量上调用可能具有副作用的方法的高亮显示`	警告
使用 'DefaultValueAttribute' 定义可选参数值可能具有误导性 `可选参数使用 DefaultValue 特性` `对可选参数使用 DefaultValue 特性的高亮显示`	警告
索引器初始化器前可能缺少逗号 `索引器初始化器可能缺失逗号` `对索引器初始化器可能缺失逗号的高亮显示`	警告
可能错误使用了 'CancellationToken' `可能错误地使用了 CancellationToken` `resharper_possibly_mistaken_use_of_cancellation_token_highlighting`	警告
集合中可能为非预期的线性查找 `在集合中可能出现非预期的线性搜索` `resharper_possible_unintended_linear_search_in_set_highlighting`	警告
条件调用中可能为非预期的修改 `条件调用中可能存在非预期的副作用` `resharper_possibly_unintended_side_effects_inside_conditional_invocation_highlighting`	警告
可能为非预期的字符串插值而非格式字符串模板 `可能错误地使用了插值字符串插入项` `resharper_possibly_mistaken_use_of_interpolated_string_insert_highlighting`	警告
字符串比较可能有误：仅当 span 指向同一内存位置时才相等 `字符串与 Span 的比较` `resharper_string_span_comparison_highlighting`	警告
lambda 或局部函数中的参数名可能具有误导性 `局部参数名全部为下划线` `resharper_all_underscore_local_parameter_name_highlighting`	警告
建议显式提供元组组件名称 `建议显式提供元组组件名称` `resharper_prefer_explicitly_provided_tuple_component_name_highlighting`	提示
禁止捕获主构造函数参数 `主构造函数参数捕获不被允许` `resharper_primary_constructor_parameter_capture_disallowed_highlighting`	已禁用
带 [Optional] 属性的 'ref' 或 'out' 参数 `可选参数不能为 ref 或 out` `resharper_optional_parameter_ref_out_highlighting`	警告
返回由 'using' 捕获对象生成的 task `返回由 using 变量生成的 Task` `resharper_return_of_task_produced_by_using_variable_highlighting`	警告
返回被 'using' 语句捕获的变量 `返回 using 变量` `resharper_return_of_using_variable_highlighting`	警告
函数的返回类型可设为非可空类型 `返回类型可以为非可为空类型` `resharper_return_type_can_be_not_nullable_highlighting`	警告
带有 [MustUseReturnValue] 注解的方法的返回值未被使用 `必须使用返回值` `resharper_must_use_return_value_highlighting`	警告
带有 [MustDisposeResource] 注解的方法的返回值从未被释放 `资源未释放` `resharper_not_disposed_resource_highlighting`	警告
属性的返回值必须由调用方释放 `资源未释放但通过属性返回` `resharper_not_disposed_resource_is_returned_by_property_highlighting`	警告
'GetEnumerator' 方法调用的返回值从未被释放 `泛型枚举器未释放` `resharper_generic_enumerator_not_disposed_highlighting`	警告
迭代器的返回值未被使用 `迭代器方法的结果被忽略` `resharper_iterator_method_result_is_ignored_highlighting`	警告
纯方法的返回值未被使用 `纯方法的返回值未使用` `resharper_return_value_of_pure_method_is_not_used_highlighting`	警告
返回值应被释放，但方法或函数未加 [MustDisposeResource] 注解 `未释放的资源被返回` `resharper_not_disposed_resource_is_returned_highlighting`	建议
安全类型转换表达式始终成功 `TryCast 总是成功` `resharper_try_cast_always_succeeds_highlighting`	建议
左操作数为零的移位表达式结果为零 `左操作数为零的移位表达式` `resharper_shift_expression_zero_left_operand_highlighting`	警告
附近检测到相似的匿名类型 `附近存在相似的匿名类型` `resharper_similar_anonymous_type_nearby_highlighting`	提示
相似表达式比较 `相等表达式比较` `resharper_equal_expression_comparison_highlighting`	警告
枚举的部分值未在 'switch' 表达式中处理，而是在默认分支通过异常处理 `switch 表达式处理部分已知 enum 值，default 抛出异常` `resharper_switch_expression_handles_some_known_enum_values_with_exception_in_default_highlighting`	提示
枚举的部分值未在 'switch' 语句中处理 `switch 语句缺失部分枚举项且无 default` `resharper_switch_statement_missing_some_enum_cases_no_default_highlighting`	提示
枚举的部分值未在 'switch' 语句中处理，而是在默认分支处理 `switch 语句处理部分已知枚举项并包含 default` `resharper_switch_statement_handles_some_known_enum_values_with_default_highlighting`	提示
泛型类型中的静态字段或自动属性 `泛型类型中的静态成员` `resharper_static_member_in_generic_type_highlighting`	警告
静态成员初始化器引用了下面或其他部分的静态成员 `静态成员初始化器引用了后面的成员` `resharper_static_member_initializer_referes_to_member_below_highlighting`	警告
字符串格式化方法问题 `格式字符串问题` `resharper_format_string_problem_highlighting`	警告
结构化日志消息项重复或仅大小写不同 `日志模板中存在重复项` `ReSharper：日志模板中重复项突出显示`	警告
结构化消息模板问题 `结构化消息模板问题` `resharper_structured_message_template_problem_highlighting`	警告
对同步原语加锁可疑 `对同步原语加锁存在疑点` `resharper_suspicious_lock_over_synchronization_primitive_highlighting`	警告
ArgumentNullException 中的参数名可疑 `ArgumentNullException 中的参数名可能有误` `resharper_suspicious_parameter_name_in_argument_null_exception_highlighting`	警告
此类型左操作数的移位数可疑 `移位表达式右操作数与实际位数不等` `resharper_shift_expression_right_operand_not_equal_real_count_highlighting`	警告
可疑的类型转换或检查 `可疑类型转换（全局）` `resharper_suspicious_type_conversion_global_highlighting`	警告
使用类似丢弃名称的变量可疑 `应使用丢弃而非赋值` `resharper_assignment_instead_of_discard_highlighting`	警告
可疑的 'volatile' 字段用法：复合操作不是原子的。可改用 'Interlocked' 类。 `非原子复合运算符` `resharper_non_atomic_compound_operator_highlighting`	警告
模块中可能在运行时缺失的符号 `使用了未在本地复制的引用中的符号` `resharper_symbol_from_not_copied_locally_reference_used_warning_highlighting`	警告
尾递归调用可替换为循环 `尾递归调用` `resharper_tail_recursive_call_highlighting`	提示
'is' 运算符的表达式从不是所提供的类型 `is 表达式永远为 false` `resharper_is_expression_always_false_highlighting`	警告
'is' 运算符的给定表达式始终为所提供的类型 `is 表达式永远为 true` `resharper_is_expression_always_true_highlighting`	警告
该模式是多余的，不会产生任何运行时检查 `模式多余` `resharper_pattern_is_redundant_highlighting`	警告
源表达式始终匹配所提供的模式 `模式总是匹配` `始终匹配的模式`	警告
源表达式从不匹配所提供的模式 `模式从不匹配` `模式从不匹配`	警告
线程静态字段具有初始化器 `带初始值的 ThreadStatic 字段` `带初始值的 ThreadStatic 字段`	警告
可用类型检查替换类型转换及 null 检查 `类型检查中使用了安全类型转换` `类型检查中使用了安全类型转换`	建议
类型检查和强制转换可以合并 `将类型转换与类型检查合并` `将类型转换与类型检查合并`	建议
类型模式与类型转换可合并 `在 switch 语句中使用模式变量` `在 switch 语句中使用模式变量`	建议
未分配的字段（非私有可访问性） `未赋值字段（作用域：全局）` `未赋值字段（作用域：全局）`	建议
未分配的字段（私有可访问性） `未赋值字段（作用域：局部）` `未赋值字段（作用域：局部）`	警告
未分配的 readonly 字段 `未赋值的 readonly 字段` `未赋值的 readonly 字段`	警告
未识别的 CQRS 实体 `多个 CQRS 实体` `ReSharper：多个 CQRS 实体突出显示`	警告
未知的 Razor 布局 `Razor 布局未解析` `Razor 布局未解析`	错误
未知的 Razor 区段 `Razor 区段未解析` `Razor 区段未解析`	错误
<inheritdoc /> 的用法无效 `对 inheritdoc 的用法无效` `对 inheritdoc 的用法无效`	警告
Use <inheritdoc /> on root level to inherit documentation from base candidate `请考虑使用 inheritdoc` `请考虑使用 inheritdoc`	已禁用
Use collection's count property `使用集合的 Count 属性` `使用集合的 Count 属性`	建议
在格式字符串中使用格式说明符 `在格式字符串中使用格式说明符` `在格式字符串中使用格式说明符`	建议
Use format specifier in interpolated strings `简化字符串插值` `简化字符串插值`	建议
Use null check instead of a type check succeeding on any not-null value `将类型检查转换为 null 检查` `将类型检查转换为 null 检查`	警告
Use null check pattern instead of a type check succeeding on any not-null value `将类型模式检查转换为 null 检查` `将类型模式检查转换为 null 检查`	警告
Use nullable annotation instead of an attribute `用可空性注解替代特性` `用可空性注解替代特性`	建议
Useless arithmetical operation `无用的二元运算` `无用的二元运算`	警告
Using stackalloc inside loop `循环中包含 stackalloc` `循环中包含 stackalloc`	警告
赋值给非变量限定符表达式的属性的值可能会丢失 `可能对非常量结构体的成员进行了修改` `可能对非常量结构体的成员进行了修改`	警告
'value' parameter is not used `未使用的值参数` `未使用的值参数`	警告
Variable can be declared as non-nullable `变量可以是非可空类型` `变量可以是非可空类型`	警告
Variable in local function hides variable from outer scope `变量隐藏了外部作用域变量` `变量隐藏了外部作用域变量`	警告
Virtual member call in constructor `构造函数中调用虚成员` `构造函数中调用虚成员`	警告
'void' method is annotated with the [MustDisposeResource] attribute `void 方法具有 MustDisposeResource 特性` `void 方法具有 MustDisposeResource 特性`	警告
'void' method is annotated with the [MustUseReturnValue] attribute `void 方法具有 MustUseReturnValue 特性` `void 方法具有 MustUseReturnValue 特性`	警告
'void' 方法带有 [Pure] 属性注解 `void 方法上应用了 Pure 特性` `void 方法上应用了 Pure 特性`	警告
'with' expression is used instead of object initializer `使用 with 表达式代替初始化器` `使用 with 表达式代替初始化器`	建议
'with' expression modifies all accessible instance members `with 表达式修改了所有成员` `with 表达式修改了所有成员`	警告

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

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

检查 ID EditorConfig 属性	默认严重性
'??' condition is known to be null or not null `常量 null 合并条件` `常量 null 合并条件`	警告
'??' condition is never null according to nullable reference types' annotations `根据 API 契约，null 合并条件始终不为 null` `根据 API 契约，null 合并条件始终不为 null`	警告
[NotNull] or [CanBeNull] attribute is applied to a type that already has the same annotation from nullable reference types `在启用可空引用类型时冗余的空值特性` `在启用可空引用类型时冗余的空值特性`	警告
匿名方法签名是多余的 `未使用的匿名方法签名` `未使用的匿名方法签名`	警告
数组创建可替换为数组初始化器 `冗余的数组创建表达式` `冗余的数组创建表达式`	提示
赋值未被使用 `冗余的赋值` `冗余的赋值`	警告
赋值结果被完全丢弃 `赋值被完全丢弃` `赋值被完全丢弃`	警告
与整型常量的比较无意义 `对整数常量的无用比较` `对整数常量的无用比较`	警告
条件访问限定表达式已知为 null 或非 null `常量条件访问限定符` `常量条件访问限定符`	警告
根据可空引用类型注解，条件访问限定表达式不为 null `根据 API 契约，条件访问限定符为非可空` `根据 API 契约，条件访问限定符为非可空`	警告
在向字典添加项前调用 'ContainsKey' 是多余的 `添加前包含了冗余的 Dictionary.ContainsKey 调用` `添加前包含了冗余的 Dictionary.ContainsKey 调用`	警告
CQRS 属性是冗余的，可予以删除 `冗余 CQRS 特性` `ReSharper：冗余 CQRS 特性突出显示`	警告
双重取反运算符 `双重否定运算符` `ReSharper 双重否定运算符高亮`	建议
重复语句 `重复语句` `ReSharper 重复语句高亮`	警告
空的 for 循环是多余的 `空的 for 语句` `ReSharper 空的 for 语句高亮`	警告
空的区域 `空的区域` `ReSharper 空的区域高亮`	建议
显式委托创建表达式是多余的 `冗余的委托创建` `ReSharper 冗余的委托创建高亮`	警告
表达式始终为 'null' `表达式始终为 null` `ReSharper 表达式始终为 null 高亮`	警告
表达式始终为 'true' 或始终为 'false' `条件始终为 true 或 false` `ReSharper 条件始终为 true 或 false 高亮`	警告
根据可空引用类型注解，表达式始终为 'true' 或 'false' `根据可为 null API 合约，条件始终为 true 或 false` `ReSharper 根据可为 null API 合约，条件始终为 true 或 false 高亮`	警告
启发式不可达代码 `启发式无法访问的代码` `ReSharper 启发式无法访问的代码高亮`	警告
立即调用委托 `冗余的立即委托调用` `ReSharper 冗余的立即委托调用高亮`	建议
Math.Abs() 参数始终为非负数 `Math.Abs 方法是多余的` `ReSharper Math.Abs 方法是多余的高亮`	警告
Math.Sign() 方法始终返回相同结果 `可疑的 Math.Sign 方法` `ReSharper 可疑的 Math.Sign 方法高亮`	警告
如果属性没有参数，括号是多余的 `冗余的特性括号` `ReSharper 冗余的特性括号高亮`	提示
模式始终为 'true' 或始终为 'false' `模式始终为 true 或 false` `ReSharper 模式始终为 true 或 false 高亮`	警告
私有字段可转换为局部变量 `私有字段可转换为局部变量` `ReSharper 私有字段可转换为局部变量高亮`	警告
原始字符串可简化 `原始字符串可以简化` `ReSharper 原始字符串可以简化高亮`	提示
多余的 [AttributeUsage] 属性属性赋值 `冗余的 AttributeUsage 属性` `ReSharper 冗余的 AttributeUsage 属性高亮`	建议
Redundant 'abstract' modifier `冗余的 abstract 修饰符` `ReSharper 冗余的 abstract 修饰符高亮`	警告
Redundant anonymous type property explicit name `冗余的匿名类型属性名称` `ReSharper 冗余的匿名类型属性名称高亮`	警告
传递给调用者参数表达式参数的多余参数 `冗余的 CallerArgumentExpression 默认值` `ReSharper 冗余的 CallerArgumentExpression 默认值高亮`	警告
Redundant argument with default value `冗余的参数默认值` `ReSharper 冗余的参数默认值高亮`	警告
Redundant arithmetic overflow checking context `冗余的溢出检查上下文` `ReSharper 冗余的溢出检查上下文高亮`	警告
Redundant 'Attribute' suffix `冗余的特性后缀` `ReSharper 冗余的特性后缀高亮`	警告
Redundant 'base.' qualifier `冗余的 base 限定符` `ReSharper 冗余的 base 限定符高亮`	警告
Redundant boolean comparison `冗余的布尔比较` `ReSharper 冗余的布尔比较高亮`	警告
Redundant braces in collection initializer `冗余的集合初始化元素大括号` `ReSharper 冗余的集合初始化元素大括号高亮`	提示
Redundant 'case' label `冗余的 case 标签` `ReSharper 冗余的 case 标签高亮`	警告
Redundant 'case' label before default section `默认分支的冗余枚举 case 标签` `ReSharper 默认分支的冗余枚举 case 标签高亮`	已禁用
多余的强制转换 `冗余的强制类型转换` `ReSharper 冗余的强制类型转换高亮`	警告
Redundant catch clause `冗余的 catch 子句` `ReSharper 冗余的 catch 子句高亮`	警告
Redundant 'class' keyword in record declaration `冗余的 record class 关键字` `ReSharper 冗余的 record class 关键字高亮`	警告
Redundant collection copy `冗余的集合复制调用` `ReSharper 冗余的集合复制调用高亮`	警告
Redundant condition check before assignments `赋值前的冗余检查` `ReSharper 赋值前的冗余检查高亮`	警告
Redundant conditional ternary expression usage `冗余的三元表达式` `ReSharper 冗余的三元表达式高亮`	警告
Redundant context capturing with 'ConfigureAwait' `冗余的 ConfigureAwait` `ReSharper 冗余的 ConfigureAwait 高亮`	建议
多余的控制流跳转语句 `冗余的跳转语句` `ReSharper 冗余的跳转语句高亮`	警告
Redundant discard designation `冗余的舍弃符号` `ReSharper 冗余的舍弃符号高亮`	建议
多余的 'else' 关键字 `冗余的 if-else 块` `ReSharper 冗余的 if-else 块高亮`	提示
Redundant empty argument list on object creation expression `冗余的空对象创建参数列表` `ReSharper 冗余的空对象创建参数列表高亮`	提示
冗余的空 finally 块 `冗余的空 finally 块` `ReSharper 冗余的空 finally 块高亮`	警告
Redundant empty object or collection initializer `冗余的空对象或集合初始化器` `ReSharper 冗余的空对象或集合初始化器高亮`	警告
Redundant empty switch section `冗余的空 switch 区段` `冗余的空 switch 区块高亮显示`	警告
Redundant explicit collection creation in argument of 'params' parameter `冗余的显式参数数组创建` `冗余的显式参数数组创建高亮显示`	建议
Redundant explicit nullable type creation `冗余的显式 Nullable 创建` `冗余的显式 Nullable 创建高亮显示`	警告
Redundant explicit positional property declaration `冗余的显式位置属性声明` `冗余的显式位置属性声明高亮显示`	警告
数组创建中的多余显式大小指定 `冗余的显式数组大小` `冗余的显式数组大小高亮显示`	警告
Redundant explicit tuple component name `冗余的显式元组组件名称` `冗余的显式元组组件名称高亮显示`	警告
Redundant explicit type in array creation `冗余的显式数组创建` `冗余的显式数组创建高亮显示`	警告
Redundant fixed pointer declaration `冗余的 fixed 指针声明` `冗余的 fixed 指针声明高亮显示`	建议
Redundant global using directive `冗余的全局 using 指令` `冗余的全局 using 指令高亮显示`	警告
Redundant 'IEnumerable.Cast<T>' or 'IEnumerable.OfType<T>' call `冗余的 Enumerable.Cast 调用` `冗余的 Enumerable.Cast 调用高亮显示`	警告
Redundant lambda expression parameter type specification `冗余的 Lambda 参数类型` `冗余的 Lambda 参数类型高亮显示`	警告
Redundant lambda signature parentheses `冗余的 Lambda 括号` `冗余的 Lambda 括号高亮显示`	提示
Redundant name qualifier `冗余的名称限定符` `冗余的名称限定符高亮显示`	警告
Redundant 'notnull' constraint on type parameter constrained by non-nullable base type `冗余的 NotNull 约束` `冗余的 NotNull 约束高亮显示`	警告
Redundant nullable annotation on base type constraint of type parameter constrained by another non-nullable base type `类型约束具有非 Nullable 基类型时的冗余 Nullable 注解` `类型约束具有非 Nullable 基类型时的冗余 Nullable 注解高亮显示`	警告
Redundant nullable annotation on base type constraint of type parameter having non-nullable type kind `类型约束具有非 Nullable 类型种类时的冗余 Nullable 注解` `类型约束具有非 Nullable 类型种类时的冗余 Nullable 注解高亮显示`	警告
Redundant nullable annotation on 'class?' constraint of type parameter constrained by non-nullable base type `引用类型约束上的冗余 Nullable 注解` `引用类型约束上的冗余 Nullable 注解高亮显示`	警告
Redundant nullable attribute `冗余的 NullableFlowAttribute` `冗余的 NullableFlowAttribute 高亮显示`	警告
Redundant nullable directive `冗余的 Nullable 指令` `冗余的 Nullable 指令高亮显示`	警告
Redundant nullable warning suppression expression `冗余的抑制 Nullable 警告表达式` `冗余的抑制 Nullable 警告表达式高亮显示`	警告
Redundant 'object.ToString()' call `冗余的 ToString 调用` `冗余的 ToString 调用高亮显示`	警告
Redundant 'object.ToString()' call for value types `值类型上的冗余 ToString 调用` `值类型上的冗余 ToString 调用高亮显示`	提示
逻辑条件表达式中的多余操作数 `冗余的逻辑条件表达式操作数` `冗余的逻辑条件表达式操作数高亮显示`	警告
Redundant 'orderby' clause 'ascending' keyword `冗余的升序查询排序关键字` `冗余的升序查询排序关键字高亮显示`	提示
Redundant property pattern clause `冗余的属性模式子句` `冗余的属性模式子句高亮显示`	建议
Redundant range bound `冗余的区间边界` `冗余的区间边界高亮显示`	建议
Redundant 'readonly' modifier `冗余的 readonly 修饰符` `冗余的 readonly 修饰符高亮显示`	建议
Redundant 'scoped' parameter modifier `冗余的 scoped 参数修饰符` `冗余的 scoped 参数修饰符高亮显示`	警告
Redundant semicolon after type or namespace declaration `冗余的声明分号` `冗余的声明分号高亮显示`	提示
Redundant string interpolation `冗余的字符串内插` `冗余的字符串内插高亮显示`	建议
Redundant 'string.Format()' call `冗余的 string.Format 调用` `冗余的 string.Format 调用高亮显示`	警告
Redundant 'string.ToCharArray()' call `冗余的字符串 ToCharArray 调用` `冗余的字符串 ToCharArray 调用高亮显示`	警告
冗余的 'switch' 表达式分支项 `冗余的 switch 表达式分支` `冗余的 switch 表达式分支高亮显示`	警告
Redundant type arguments inside 'nameof' `nameof 中冗余的类型参数` `nameof 中冗余的类型参数高亮显示`	建议
Redundant type arguments of method `方法上的冗余类型参数` `方法上的冗余类型参数高亮显示`	警告
Redundant type check in a pattern `模式中的冗余类型检查` `模式中的冗余类型检查高亮显示`	警告
Redundant type declaration body `冗余的类型声明主体` `冗余的类型声明主体高亮显示`	建议
冗余的 using 指令 `冗余的 using 指令` `冗余的 using 指令高亮显示`	警告
Redundant verbatim prefix `冗余的逐字字符串前缀` `冗余的逐字字符串前缀高亮显示`	建议
Redundant verbatim string prefix `冗余的逐字字符串前缀` `冗余的逐字字符串前缀高亮显示`	建议
Redundant 'virtual' modifier `冗余的 virtual 修饰符` `冗余的 virtual 修饰符高亮显示`	警告
Redundant 'WithCancellation()' invocation `冗余的 WithCancellation` `带有取消操作的多余代码高亮显示`	警告
Remove redundant pattern-matching parentheses `多余的模式括号` `多余的模式括号高亮显示`	提示
Subpattern that always matches is redundant `始终匹配的多余子模式` `始终匹配的多余子模式高亮显示`	建议
'true' is redundant as 'for'-statement condition `For 语句的条件始终为 true` `For 语句条件始终为 true 的高亮显示`	警告
Type check for nullable type is equal to underlying type check `多余的 Nullable 类型标记` `多余的 Nullable 类型标记高亮显示`	警告
Unsafe context declaration is redundant `多余的不安全上下文` `多余的不安全上下文高亮显示`	警告
Unused nullable directive `未使用的 Nullable 指令` `未使用的 Nullable 指令高亮显示`	警告

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

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

检查 ID EditorConfig 属性	默认严重性
具有虚拟（可重写）成员的类从未被继承（非私有可访问性） `具有虚成员但从未被继承的类（全局）` `具有虚成员但从未被继承的类的全局高亮显示`	建议
具有虚拟（可重写）成员的类从未被继承（私有可访问性） `具有虚成员但从未被继承的类（局部）` `具有虚成员但从未被继承的类的局部高亮显示`	建议
Component of the tuple is never used `返回值中未使用的元组组件` `返回值中未使用的元组组件高亮显示`	警告
'DefaultParameterValueAttribute' must be used in conjunction with 'OptionalAttribute' `无意义的默认参数值` `无意义的默认参数值高亮显示`	警告
Empty constructor `空构造函数` `空构造函数高亮显示`	警告
Empty destructor `空析构函数` `空析构函数高亮显示`	警告
Empty implementation of 'partial void' method is redundant `部分方法的空实现多余` `部分方法的多余空实现高亮显示`	警告
Empty namespace declaration `空命名空间` `空命名空间高亮显示`	警告
实体仅用于捕获其名称（非私有可访问性） `仅被捕获的实体名称（全局）` `仅被捕获的实体名称的全局高亮显示`	警告
实体仅用于捕获其名称（私有可访问性） `仅在本地捕获的实体名称` `仅在本地捕获的实体名称`	警告
Local function is never used `未使用的本地函数` `未使用的本地函数`	警告
Local function is never used `未使用的本地函数（编译器）` `未使用的本地函数（编译器）`	警告
Local function return value is never used `未使用的本地函数返回值` `未使用的本地函数返回值`	警告
方法返回值从未使用（非私有可访问性） `未使用的方法返回值（全局）` `未使用的方法返回值（全局）`	建议
方法返回值从未使用（私有可访问性） `未使用的方法返回值（本地）` `未使用的方法返回值（本地）`	警告
未访问的局部变量 `未访问的变量` `未访问的变量`	警告
未访问的局部变量仅用于丢弃 'out' 参数值 `未访问的 out 参数变量` `未访问的 out 参数变量`	警告
未访问的主构造函数参数 `未访问的主构造函数参数（编译器）` `未访问的主构造函数参数（编译器）`	警告
参数仅用于前置条件检查（非私有可访问性） `仅用于前置条件检查的参数（全局）` `仅用于前置条件检查的参数（全局）`	建议
参数仅用于前置条件检查（私有可访问性） `仅用于前置条件检查的参数（本地）` `仅用于前置条件检查的参数（本地）`	警告
参数输出值始终被丢弃（非私有可访问性） `out 参数值始终被丢弃（全局）` `out 参数值始终被丢弃（全局）`	建议
参数输出值始终被丢弃（私有可访问性） `out 参数值始终被丢弃（本地）` `out 参数值始终被丢弃（本地）`	警告
'params' modifier is always ignored on overrides `多余的 params` `多余的 params`	警告
冗余属性 [SetsRequiredMembers] `冗余的 SetsRequiredMembers 特性` `ReSharper：冗余设置 RequiredMembers 特性突出显示`	警告
Redundant base constructor call `多余的基构造函数调用` `多余的基构造函数调用`	警告
Redundant class or interface specification in base types list `多余的 Extends 列表项` `多余的 Extends 列表项`	警告
Redundant member initializer `多余的默认成员初始化` `多余的默认成员初始化`	警告
Redundant member override `多余的重写成员` `多余的重写成员`	警告
Redundant method overload (non-private accessibility) `多余的重载（全局）` `多余的重载（全局）`	建议
Redundant method overload (private accessibility) `多余的重载（本地）` `多余的重载（本地）`	建议
Redundant 'partial' modifier on method declaration `仅包含单个部分的 partial 方法` `仅包含单个部分的 partial 方法`	警告
Redundant 'partial' modifier on type declaration `仅包含单个部分的 partial 类型` `仅包含单个部分的 partial 类型`	警告
Sealed member in sealed class `密封类中的密封成员` `密封类中的密封成员`	警告
类型从未使用（非私有可访问性） `未使用的类型（全局）` `未使用的类型（全局）`	建议
类型从未使用（私有可访问性） `未使用的类型（本地）` `未使用的类型（本地）`	警告
类型成员从未通过基类型访问（非私有可访问性） `子类中未使用的基类成员（全局）` `子类中未使用的基类成员（全局）`	建议
类型成员从未通过基类型访问（私有可访问性） `子类中未使用的基类成员（本地）` `子类中未使用的基类成员（本地）`	警告
类型成员从未使用（非私有可访问性） `未使用的成员（全局）` `未使用的成员（全局）`	建议
类型成员从未使用（私有可访问性） `未使用的成员（本地）` `未使用的成员（本地）`	警告
类型成员仅在重写中使用（非私有可访问性） `未使用的成员层级（全局）` `未使用的成员层级（全局）`	建议
类型成员仅在重写中使用（私有可访问性） `未使用的成员层级（本地）` `未使用的成员层级（本地）`	警告
Underlying type of enum is 'int' `枚举的基础类型为 int` `枚举的基础类型为 int`	警告
未使用的标签 `未使用的标签` `未使用的标签`	警告
未使用的局部变量 `未使用的变量` `未使用的变量`	警告
未使用的参数（非私有可访问性） `未使用的参数（全局）` `未使用的参数（全局）`	建议
未使用的参数（私有可访问性） `未使用的参数（本地）` `未使用的参数（本地）`	警告
部分方法中未使用的参数 `partial 方法中未使用的参数` `partial 方法中未使用的参数`	警告
未使用的位置参数 `未使用的位置参数（编译器）` `未使用的位置参数（编译器）`	警告
未使用的类型参数 `未使用的类型参数` `未使用的类型参数`	警告
虚拟（可重写）成员从未被重写（非私有可访问性） `虚成员从未被重写（全局）` `虚成员从未被重写（全局）`	建议
虚拟（可重写）成员从未被重写（私有可访问性） `虚成员从未被重写（本地）` `虚成员从未被重写（本地）`	建议

安全性（1 项检查）

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

检查 ID EditorConfig 属性	默认严重性
存在安全漏洞的 API 使用 `存在已知漏洞的 API` `存在已知漏洞的 API`	警告

拼写问题（3 项检查）

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

检查 ID EditorConfig 属性	默认严重性
注释中的拼写错误 `注释中有拼写错误` `注释中有拼写错误`	建议
标识符中的拼写错误 `标识符拼写错误` `标识符拼写错误突出显示`	建议
字符串字面量中的拼写错误 `字符串文本拼写错误` `字符串文本拼写错误突出显示`	建议

语法风格（46 项检查）

此类别中的检查检测代码语法风格的违规行为。与大多数代码检查不同，这些检查是否将相同的代码结构检测为代码问题取决于在 ReSharper 选项的代码编辑 | C# | 语法样式页面上配置的相应代码风格规则 Alt+R, O。您还可以使用代码清理修复这些检查检测到的问题。

检查 ID EditorConfig 属性	默认严重性
添加括号以避免不明显的优先级 `整理缺失的括号` `整理缺失的括号突出显示`	已禁用
为静态成员添加/移除限定符 `整理静态成员限定符` `整理静态成员限定符突出显示`	提示
添加/移除 'this.' 限定符 `整理 this 限定符` `整理 this 限定符突出显示`	提示
调整修饰符声明顺序 `整理修饰符顺序` `整理修饰符顺序突出显示`	建议
整理 null 检查模式 `整理空检查模式` `整理空检查模式突出显示`	提示
合并或拆分区块中的属性 `整理特性` `整理特性突出显示`	已禁用
解构声明中合并或拆分 'var' `整理解构声明中的 var 关键字` `整理解构声明中的 var 关键字突出显示`	建议
将赋值表达式放入代码块 `将赋值表达式放入代码块中` `将赋值表达式放入代码块突出显示`	已禁用
移除多余的括号 `整理多余的括号` `整理多余的括号突出显示`	提示
用 CLR 类型名或关键字替换内置类型引用 `内置类型引用样式` `内置类型引用样式突出显示`	提示
在静态成员访问表达式中用 CLR 类型名或关键字替换内置类型引用 `成员访问的内置类型引用样式` `成员访问的内置类型引用样式突出显示`	提示
用空行分隔控制流转移语句 `分隔控制转移语句` `分隔控制转移语句突出显示`	已禁用
行尾存在不必要的空白字符 `不必要的空白` `不必要的空白突出显示`	已禁用
禁止使用制表符进行缩进 `不允许使用制表符` `不允许使用制表符突出显示`	已禁用
类型成员使用显式或隐式修饰符定义 `整理类型成员修饰符` `整理类型成员修饰符突出显示`	提示
类型使用显式或隐式修饰符定义 `整理类型修饰符` `整理类型修饰符突出显示`	提示
使用首选参数风格 `其他参数样式` `其他参数样式突出显示`	已禁用
Use preferred argument style for anonymous functions `匿名函数的参数样式` `匿名函数的参数样式突出显示`	已禁用
Use preferred argument style for literal values `文本字面量的参数样式` `文本字面量的参数样式突出显示`	已禁用
Use preferred argument style for named expressions `具名表达式的参数样式` `具名表达式的参数样式突出显示`	已禁用
Use preferred argument style for string literal values `字符串文本的参数样式` `字符串文本的参数样式突出显示`	已禁用
Use preferred body style (convert into constructor or destructor with preferred body style) `整理构造函数或析构函数体` `整理构造函数或析构函数体突出显示`	已禁用
Use preferred body style (convert into local function with preferred body style) `整理局部函数体` `整理局部函数体突出显示`	已禁用
Use preferred body style (convert into method or operator with preferred body style) `整理方法或运算符体` `整理方法或运算符体突出显示`	已禁用
Use preferred body style (convert into property, indexer, or event with preferred body style) `整理访问器所属主体` `整理访问器所属主体突出显示`	建议
使用首选的大括号样式（强制在 'do-while' 语句中使用大括号） `强制 do-while 语句使用花括号` `强制 do-while 语句使用花括号突出显示`	已禁用
Use preferred braces style (enforce braces in 'fixed' statement) `强制 fixed 语句使用花括号` `强制 fixed 语句使用花括号突出显示`	已禁用
使用首选的大括号样式（强制在 'for' 语句中使用大括号） `强制 for 语句使用花括号` `强制 for 语句使用花括号突出显示`	已禁用
Use preferred braces style (enforce braces in 'foreach' statement) `强制 foreach 语句使用花括号` `强制 foreach 语句使用花括号突出显示`	已禁用
使用首选的大括号样式（强制在 'if' 语句中使用大括号） `强制 if 语句使用花括号` `强制 if 语句使用花括号突出显示`	已禁用
Use preferred braces style (enforce braces in 'lock' statement) `强制 lock 语句使用花括号` `强制 lock 语句使用花括号突出显示`	已禁用
Use preferred braces style (enforce braces in 'using' statement) `强制 using 语句使用花括号` `强制 using 语句使用花括号突出显示`	已禁用
使用首选的大括号样式（强制在 'while' 语句中使用大括号） `强制 while 语句使用花括号` `强制 while 语句使用花括号突出显示`	已禁用
使用首选的大括号样式（移除多余的大括号） `删除多余的花括号` `删除多余的花括号突出显示`	已禁用
Use preferred namespace body style `整理命名空间体` `整理命名空间体突出显示`	提示
Use preferred style for discard declaration `建议使用丢弃声明的 var 样式` `建议使用丢弃声明的 var 样式突出显示`	提示
Use preferred style for trailing comma before new line in multiline lists `整理多行列表中的结尾逗号` `整理多行列表中的结尾逗号突出显示`	提示
Use preferred style for trailing comma when the last element is not followed by a new line `整理单行列表中的结尾逗号` `整理单行列表中的结尾逗号突出显示`	提示
Use preferred style of default value expression when type is evident `整理类型明显时的默认值` `整理类型明显时的默认值突出显示`	建议
Use preferred style of default value expression when type is not evident `整理类型不明显时的默认值` `整理类型不明显时的默认值突出显示`	提示
Use preferred style of 'new' expression when created type is evident `当类型明显时整理对象创建` `resharper_arrange_object_creation_when_type_evident_highlighting`	建议
Use preferred style of 'new' expression when created type is not evident `当类型不明显时整理对象创建` `resharper_arrange_object_creation_when_type_not_evident_highlighting`	提示
Use preferred 'var' style (elsewhere) `在其他位置建议使用 var 或类型` `resharper_suggest_var_or_type_elsewhere_highlighting`	提示
Use preferred 'var' style (for built-in types) `对内置类型建议使用 var 或类型` `resharper_suggest_var_or_type_built_in_types_highlighting`	提示
Use preferred 'var' style (in deconstruction declarations) `在解构声明中建议使用 var 或类型` `resharper_suggest_var_or_type_deconstruction_declarations_highlighting`	提示
Use preferred 'var' style (when type is simple) `对简单类型建议使用 var 或类型` `resharper_suggest_var_or_type_simple_types_highlighting`	提示

Unity（48 项检查）

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

检查 ID EditorConfig 属性	默认严重性
可用的非分配方法替代方案 `Unity：优先使用非分配 API` `resharper_unity_prefer_non_alloc_api_highlighting`	警告
在继承自 'PropertyDrawer' 的类中避免使用 'base.OnGUI()' `Unity：派生自 PropertyDrawer 的类必须调用 base.OnGUI` `resharper_unity_property_drawer_on_gui_base_highlighting`	警告
无法解析组件或 ScriptableObject `Unity：组件或 ScriptableObject 未解析` `resharper_unity_unresolved_component_or_scriptable_object_highlighting`	警告
DOTS：IAspect 字段必须为以下类型之一：RefRW、RefRO、EnabledRefRW、EnabledRefRO、DynamicBuffer 或 Entity `Unity.Entities：Aspect 字段类型不正确` `resharper_unity_entities_aspect_wrong_fields_type_highlighting`	错误
DOTS：类型关键字不一致 `Unity.Entities：Dots 派生类使用的不一致修饰符` `resharper_unity_entities_inconsistent_modifiers_for_dots_inheritor_highlighting`	错误
DOTS：指定的类型必须为结构体类型 `Unity.Entities：Dots 派生类必须为 struct` `resharper_unity_entities_must_be_struct_for_dots_inheritor_highlighting`	错误
已声明同名事件函数 `Unity：存在重复的事件函数` `resharper_unity_duplicate_event_function_highlighting`	警告
应为 'Component' 或 'MonoBehaviour' 的派生类型 `Unity：预期为组件` `resharper_unity_expected_component_highlighting`	警告
应为 'ScriptableObject' 的派生类型 `Unity：预期为 ScriptableObject` `resharper_unity_expected_scriptable_object_highlighting`	警告
'ComponentLookup' 类型的字段在使用前必须先更新。 `Unity.Entities：ComponentLookup 未刷新` `resharper_unity_entities_not_updated_component_lookup_highlighting`	警告
文件名应与程序集名称一致 `ASMDEF 文件名不匹配` `resharper_mismatched_asmdef_filename_highlighting`	建议
未定义分组路径 `Odin：未知的分组路径` `resharper_odin_odin_unknown_grouping_path_highlighting`	警告
方法签名不正确 `Unity：方法签名不正确` `resharper_unity_incorrect_method_signature_highlighting`	警告
Odin 分组属性类型不正确 `Odin：成员使用了错误的分组属性` `resharper_odin_odin_member_wrong_grouping_attribute_highlighting`	警告
成员同时出现在多个 UI 分组中 `Odin：成员出现在多个分组中` `resharper_odin_odin_member_present_in_multiple_groups_highlighting`	警告
字符串字面量中引用的方法签名不符合预期 `Unity：字符串文本中的方法签名不正确` `resharper_unity_incorrect_method_signature_in_string_literal_highlighting`	警告
'MonoBehaviour' 实例必须通过 'GameObject.AddComponent<T>()' 实例化，而非 'new' `Unity：不正确的 MonoBehaviour 实例化` `resharper_unity_incorrect_mono_behaviour_instantiation_highlighting`	警告
参数应为 'Component' 的派生类型 `Unity：参数未从 Component 派生` `resharper_unity_parameter_not_derived_from_component_highlighting`	警告
属性可能被错误地应用于多个字段 `Unity：属性可能被错误地应用于多个字段` `resharper_unity_possible_misapplication_of_attribute_to_multiple_fields_highlighting`	警告
对派生自 'UnityEngine.Object' 的类型进行 null 合并操作会绕过底层 Unity 引擎对象的生命周期检查，可能导致非预期的生命周期检查绕过 `Unity：禁止使用空合并操作符` `resharper_unity_no_null_coalescing_highlighting`	已禁用
对派生自 'UnityEngine.Object' 的类型进行 null 传播操作会绕过底层 Unity 引擎对象的生命周期检查，可能导致非预期的生命周期检查绕过 `Unity：禁止使用空传播操作符` `resharper_unity_no_null_propagation_highlighting`	已禁用
对派生自 'UnityEngine.Object' 的类型进行模式匹配 null 检查会绕过底层 Unity 引擎对象的生命周期检查，可能导致非预期的生命周期检查绕过 `Unity：禁止使用空模式匹配` `resharper_unity_no_null_pattern_matching_highlighting`	已禁用
建议优先使用基于 GUID 的程序集引用 `Unity：建议使用 GUID 引用` `resharper_unity_prefer_guid_reference_highlighting`	提示
属性用法多余（应用于此声明类型时属性是多余的） `Unity：在目标上存在冗余的属性` `resharper_unity_redundant_attribute_on_target_highlighting`	警告
属性用法多余（'FormerlySerializedAs' 属性多余） `Unity：存在冗余的 FormerlySerializedAs 属性` `resharper_unity_redundant_formerly_serialized_as_attribute_highlighting`	警告
属性用法多余（'HideInInspector' 属性多余） `Unity：存在冗余的 HideInInspector 属性` `resharper_unity_redundant_hide_in_inspector_attribute_highlighting`	警告
属性用法多余（'InitializeOnLoad' 属性多余） `Unity：存在冗余的 InitializeOnLoad 属性` `resharper_unity_redundant_initialize_on_load_attribute_highlighting`	警告
属性用法多余（'SerializeField' 属性多余） `Unity：存在冗余的 SerializeField 属性` `resharper_unity_redundant_serialize_field_attribute_highlighting`	警告
Unity 事件函数多余 `Unity：存在冗余的事件函数` `resharper_unity_redundant_event_function_highlighting`	警告
多次访问内置组件的属性效率低下 `Unity：属性访问效率低下` `resharper_unity_inefficient_property_access_highlighting`	已禁用
场景不存在 `Unity：尝试加载不存在的场景` `resharper_unity_load_scene_unexisting_scene_highlighting`	警告
场景在构建设置中被禁用 `Unity：尝试加载名称被禁用的场景` `resharper_unity_load_scene_disabled_scene_name_highlighting`	警告
'ScriptableObject' 实例必须通过 'ScriptableObject.CreateInstance<T>()' 实例化，而非 'new' `Unity：不正确的 ScriptableObject 实例化` `resharper_unity_incorrect_scriptable_object_instantiation_highlighting`	警告
对象实例化后立即设置 'parent' 属性效率低下 `Unity：未指定父级的 Instantiate 调用` `resharper_unity_instantiate_without_parent_highlighting`	警告
场景短名称不唯一 `Unity：场景名歧义` `resharper_unity_load_scene_ambiguous_scene_name_highlighting`	警告
基于字符串的图形属性查找效率低下 `Unity：优先使用通过 ID 访问图形参数` `Unity：优先使用通过 ID 访问图形参数的代码检查高亮`	警告
基于字符串的组件类型查找效率低下 `Unity：优先使用泛型方法重载` `Unity：优先使用泛型方法重载的代码检查高亮`	警告
SystemApi.Query<...> 类型参数必须为 Aspect、RefRO 或 RefRW `Unity.Entities：必须使用 ref、rw 或 ro 包裹` `Unity.Entities：必须使用 ref、rw 或 ro 包裹的代码检查高亮`	警告
构建设置中缺少索引 `Unity：使用了错误的场景索引加载场景` `Unity：使用了错误的场景索引加载场景的代码检查高亮`	警告
输入名称未在 Input 管理器中定义 `Unity：未知输入轴` `Unity：未知输入轴的代码检查高亮`	警告
图层未在“Tags & Layers”中定义 `Unity：未知图层` `Unity：未知图层的代码检查高亮`	警告
项目中未定义该资源 `Unity：未知资源` `Unity：未知资源的代码检查高亮`	警告
The same shortcut is defined for another menu item `Unity：重复的快捷键` `Unity：重复的快捷键的代码检查高亮`	警告
The tag is not defined in the 'Tags & Layers' `Unity：未知标签` `Unity：未知标签的代码检查高亮`	警告
There is no animator state with the same name in the project. `Unity：未知 Animator 状态名称` `Unity：未知 Animator 状态名称的代码检查高亮`	警告
There is no scene with the same name in the build settings `Unity：使用了未知场景名称加载场景` `Unity：使用了未知场景名称加载场景的代码检查高亮`	警告
To use the result of a 'GetSingleton' call in the function, 'OnCreate' must include a 'RequireForUpdate' call `Unity.Entities：必须显式请求单例` `Unity.Entities：必须显式请求单例的代码检查高亮`	警告
Use 'CompareTag' instead of explicit string comparison `Unity：显示进行标签比较` `Unity：显示进行标签比较的代码检查高亮`	警告

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

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

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

Unity 性能检查（5 项检查）

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

检查 ID EditorConfig 属性	默认严重性
'Camera.main' 性能开销大 `Unity：性能关键代码中访问 Camera.main` `Unity：性能关键代码中访问 Camera.main 的代码检查高亮`	提示
高开销方法调用 `Unity：性能关键代码中函数调用` `Unity：性能关键代码中函数调用的代码检查高亮`	提示
高开销 null 比较 `Unity：性能关键代码中进行 null 比较` `Unity：性能关键代码中进行 null 比较的代码检查高亮`	提示
乘法运算顺序效率低下 `Unity：乘法顺序低效` `Unity：乘法顺序低效的代码检查高亮`	警告
建议使用交错数组或一维数组替代多维数组 `Unity：低效地使用多维数组` `Unity：低效地使用多维数组的代码检查高亮`	警告

Unreal Build System（2 项检查）

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

检查 ID EditorConfig 属性	默认严重性
项目文件中缺少该插件的依赖项 `缺少插件依赖` `缺少插件依赖的代码检查高亮`	警告
不存在此名称的模块 `CSharpBuild.cs 模块名称无效` `CSharpBuild.cs 模块名称无效的代码检查高亮`	警告

Xunit（1 项检查）

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

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

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