VB.NET 中的代码检查

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

可配置的 VB.NET 检查列在下方，并按其类别分组。

代码通知（1 个检查）

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

检查 ID EditorConfig 属性	默认严重性
非活动的预处理器分支 `非活动预处理程序分支` `非活动预处理程序分支`	警告

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

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

检查 ID EditorConfig 属性	默认严重性
层次结构中的注解重复 `层级结构中的注解冗余` `resharper_annotation_redundancy_in_hierarchy_highlighting`	警告
自动属性可以设置为仅 get（非私有访问权限） `自动属性可设为 GetOnly．全局` `resharper_auto_property_can_be_made_get_only_global_highlighting`	建议
自动属性可以设置为仅 get（私有访问权限） `自动属性可设为 GetOnly．本地` `resharper_auto_property_can_be_made_get_only_local_highlighting`	建议
改为检查引用相等性 `VB 请改用引用相等检查．1` `resharper_vb_check_for_reference_equality_instead_1_highlighting`	建议
改为检查引用相等性 `应使用引用等同性检查（VB.NET）` `应使用引用等同性检查（VB.NET）`	建议
类可以设为密封（不可继承）（非私有可访问性） `类可以为密封类（全局）` `类可以为密封类（全局）`	已禁用
类可以设为密封（不可继承）（私有可访问性） `类可以为密封类（局部）` `类可以为密封类（局部）`	已禁用
容器可空性属性用于非容器类型的声明 `容器注解冗余` `容器注解冗余`	警告
将局部变量或字段转换为常量（非私有可访问性） `转换为常量（全局）` `全局常量可替换项的 ReSharper 高亮显示`	提示
将局部变量或字段转换为常量（私有可访问性） `局部常量可替换项` `局部常量可替换项的 ReSharper 高亮显示`	提示
将属性转换为自动属性 `转换为 VB 自动实现属性` `转换为 VB 自动实现属性的 ReSharper 高亮显示`	建议
在可能的情况下将属性转换为自动属性 `在可行时转换为 VB 自动实现属性` `在可行时转换为 VB 自动实现属性的 ReSharper 高亮显示`	提示
将属性转换为带私有 setter 的自动属性 `转换为带 Private Setter 的 VB 自动实现属性` `转换为带 Private Setter 的 VB 自动实现属性的 ReSharper 高亮显示`	提示
字段可以设为只读（非私有访问权限） `字段可声明为 readonly（全局）` `字段可声明为 readonly（全局）`	建议
字段可以设为只读（私有访问权限） `字段可声明为 readonly（局部）` `字段可声明为 readonly（局部）`	建议
仅可读自动属性从未被赋值 `未赋值的只读自动属性` `未赋值的只读自动属性`	警告
成员可以设为私有（非私有访问权限） `成员可设为 private（全局）` `成员可设为 private（全局）`	建议
成员可以设为私有（私有访问权限） `成员可设为 private（局部）` `成员可设为 private（局部）`	建议
成员可以设为受保护（非私有访问权限） `成员可设为 protected（全局）` `成员可设为 protected（全局）`	建议
成员可以设为受保护（私有访问权限） `成员可设为 protected（局部）` `成员可设为 protected（局部）`	建议
成员可以设为静态（共享）（非私有访问权限） `成员可设为 static（全局）` `成员可设为 static（全局）`	提示
成员可以设为静态（共享）（私有访问权限） `成员可设为 static（局部）` `成员可设为 static（局部）`	提示
成员或类型可以设为内部（友元） `成员可设为 internal` `成员可设为 internal`	已禁用
多次使用可空属性 `多次使用 Nullable 特性` `多次使用 Nullable 特性`	警告
在 void 或值类型声明中使用可空属性 `在值类型上的注解冗余` `在值类型上的注解冗余`	警告
参数可以声明为基类型 `建议为参数使用基类型` `建议为参数使用基类型`	已禁用
构造函数的参数可以声明为基类型 `建议在构造函数中为参数使用基类型` `建议在构造函数中为参数使用基类型`	已禁用
参数类型可以是 IEnumerable<T>（非私有可访问性） `参数类型可设为 IEnumerable（全局）` `参数类型可设为 IEnumerable（全局）`	已禁用
参数类型可以是 IEnumerable<T>（私有可访问性） `参数类型可设为 IEnumerable（局部）` `参数类型可设为 IEnumerable（局部）`	已禁用
可能的错误参数 `可能误用的参数（VB）` `可能误用的参数（VB）`	警告
可能错误地调用了 GetType() `可能错误调用 GetType（VB）.1` `可能错误调用 GetType（VB）.1`	警告
可能错误地调用了 GetType() `可能错误调用 GetType（VB）.2` `可能错误调用 GetType（VB）.2`	警告
属性可以设置为仅初始化（非私有可访问性） `属性可设为 init only（全局）` `属性可设为 init only（全局）`	建议
属性可以设置为仅初始化（私有可访问性） `属性可设为 init only（局部）` `属性可设为 init only（局部）`	建议
移除 ToList() `移除 ToList 调用（VB）.1` `移除 ToList 调用（VB）.1`	建议
移除 ToList() `移除 ToList 调用（VB）.2` `移除 ToList 调用（VB）.2`	建议
替换为 FirstOrDefault($args$) `使用 FirstOrDefault 替换` `ReSharper：使用 FirstOrDefault 替换高亮显示`	建议
替换为 LastOrDefault($args$) `使用 LastOrDefault 替换` `ReSharper：使用 LastOrDefault 替换高亮显示`	建议
替换为 OfType<T>()（替换为 OfType(Of ..)()） `使用 OfType 替换（1）` `ReSharper：使用 OfType 替换（1）高亮显示`	建议
替换为 OfType<T>()（替换为 OfType(Of ..)()） `使用 OfType 替换（2）` `ReSharper：使用 OfType 替换（2）高亮显示`	建议
替换为 OfType<T>().Any()（替换为 OfType(Of ..)().Any()） `使用 OfType.Any 替换（1）` `ReSharper：使用 OfType.Any 替换（1）高亮显示`	建议
替换为 OfType<T>().Any()（替换为 OfType(Of ..)().Any(..)） `使用 OfType.Any 替换（2）` `ReSharper：使用 OfType.Any 替换（2）高亮显示`	建议
替换为 OfType<T>().Count()（替换为 OfType(Of ..)().Count()） `使用 OfType.Count 替换（1）` `ReSharper：使用 OfType.Count 替换（1）高亮显示`	建议
替换为 OfType<T>().Count()（替换为 OfType(Of ..)().Count(..)） `使用 OfType.Count 替换（2）` `ReSharper：使用 OfType.Count 替换（2）高亮显示`	建议
替换为 OfType<T>().First()（替换为 OfType(Of ..)().First()） `使用 OfType.First 替换（1）` `ReSharper：使用 OfType.First 替换（1）高亮显示`	建议
替换为 OfType<T>().First()（替换为 OfType(Of ..)().First(..)） `使用 OfType.First 替换（2）` `ReSharper：使用 OfType.First 替换（2）高亮显示`	建议
替换为 OfType<T>().FirstOrDefault()（替换为 OfType(Of ..)().FirstOrDefault()） `使用 OfType.FirstOrDefault 替换（1）` `ReSharper：使用 OfType.FirstOrDefault 替换（1）高亮显示`	建议
替换为 OfType<T>().FirstOrDefault()（替换为 OfType(Of ..)().FirstOrDefault(..)） `使用 OfType.FirstOrDefault 替换（2）` `ReSharper：使用 OfType.FirstOrDefault 替换（2）高亮显示`	建议
替换为 OfType<T>().Last()（替换为 OfType(Of ..)().Last()） `使用 OfType.Last 替换（1）` `ReSharper：使用 OfType.Last 替换（1）高亮显示`	建议
替换为 OfType<T>().Last()（替换为 OfType(Of ..)().Last(..)） `使用 OfType.Last 替换（2）` `ReSharper：使用 OfType.Last 替换（2）高亮显示`	建议
替换为 OfType<T>().LastOrDefault()（替换为 OfType(Of ..)().LastOrDefault()） `使用 OfType.LastOrDefault 替换（1）` `ReSharper：使用 OfType.LastOrDefault 替换（1）高亮显示`	建议
替换为 OfType<T>().LastOrDefault()（替换为 OfType(Of ..)().LastOrDefault(..)） `使用 OfType.LastOrDefault 替换（2）` `ReSharper：使用 OfType.LastOrDefault 替换（2）高亮显示`	建议
替换为 OfType<T>().Single()（替换为 OfType(Of ..)().Single()） `使用 OfType.Single 替换（1）` `ReSharper：使用 OfType.Single 替换（1）高亮显示`	建议
替换为 OfType<T>().Single()（替换为 OfType(Of ..)().Single(..)） `使用 OfType.Single 替换（2）` `ReSharper：使用 OfType.Single 替换（2）高亮显示`	建议
替换为 OfType<T>().SingleOrDefault()（替换为 OfType(Of ..)().SingleOrDefault()） `使用 OfType.SingleOrDefault 替换（1）` `ReSharper：使用 OfType.SingleOrDefault 替换（1）高亮显示`	建议
替换为 OfType<T>().SingleOrDefault()（替换为 OfType(Of ..)().SingleOrDefault(..)） `使用 OfType.SingleOrDefault 替换（2）` `ReSharper：使用 OfType.SingleOrDefault 替换（2）高亮显示`	建议
替换为 OfType<T>().Where()（替换为 OfType(Of ..)().Where(..)） `使用 OfType.Where 替换` `ReSharper：使用 OfType.Where 替换高亮显示`	建议
替换为单一赋值 `使用单一赋值替换（1）` `ReSharper：使用单一赋值替换（1）高亮显示`	建议
替换为单一赋值 `使用单一赋值替换（2）` `ReSharper：使用单一赋值替换（2）高亮显示`	建议
替换为单次调用 Any(..) `使用对 Any 的单一调用替换` `ReSharper：使用对 Any 的单一调用替换高亮显示`	建议
替换为单次调用 Count(..) `使用对 Count 的单一调用替换` `ReSharper：使用对 Count 的单一调用替换高亮显示`	建议
替换为单次调用 First(..) `使用对 First 的单一调用替换` `ReSharper：使用对 First 的单一调用替换高亮显示`	建议
替换为对 FirstOrDefault(..) 的单次调用 `使用对 FirstOrDefault 的单一调用替换` `ReSharper：使用对 FirstOrDefault 的单一调用替换高亮显示`	建议
替换为对 Last(..) 的单次调用 `使用对 Last 的单一调用替换` `ReSharper：使用对 Last 的单一调用替换高亮显示`	建议
替换为对 LastOrDefault(..) 的单次调用 `使用对 LastOrDefault 的单一调用替换` `ReSharper：使用对 LastOrDefault 的单一调用替换高亮显示`	建议
替换为对 Single(..) 的单次调用 `使用对 Single 的单一调用替换` `ReSharper：使用对 Single 的单一调用替换高亮显示`	建议
替换为对 SingleOrDefault(..) 的单次调用 `使用对 SingleOrDefault 的单一调用替换` `ReSharper：使用对 SingleOrDefault 的单一调用替换高亮显示`	建议
替换为 SingleOrDefault($args$) `使用 SingleOrDefault 替换` `ReSharper：使用 SingleOrDefault 替换高亮显示`	建议
返回类型可以是 IEnumerable<T>（非私有可访问性） `返回类型可为 IEnumerable（全局）` `ReSharper：返回类型可为 IEnumerable（全局）高亮显示`	已禁用
返回类型可以是 IEnumerable<T>（私有可访问性） `返回类型可为 IEnumerable（局部）` `ReSharper：返回类型可为 IEnumerable（局部）高亮显示`	已禁用
简化条件运算符 `简化条件运算符` `ReSharper：简化条件运算符高亮显示`	建议
简化表达式 `简化 LINQ 表达式（1）` `ReSharper：简化 LINQ 表达式（1）高亮显示`	建议
简化表达式 `简化 LINQ 表达式（2）` `ReSharper：简化 LINQ 表达式（2）高亮显示`	建议
简化表达式 `简化 LINQ 表达式（3）` `ReSharper：简化 LINQ 表达式（3）高亮显示`	建议
简化表达式 `简化 LINQ 表达式（4）` `ReSharper：简化 LINQ 表达式（4）高亮显示`	建议
简化表达式 `简化 LINQ 表达式（5）` `ReSharper：简化 LINQ 表达式（5）高亮显示`	建议
简化表达式 `简化 LINQ 表达式（6）` `ReSharper：简化 LINQ 表达式（6）高亮显示`	建议
简化表达式 `简化 LINQ 表达式（7）` `ReSharper：简化 LINQ 表达式（7）高亮显示`	提示
简化表达式 `简化 LINQ 表达式（8）` `ReSharper：简化 LINQ 表达式（8）高亮显示`	提示
简化表达式 `简化 LINQ 表达式（9）` `ReSharper：简化 LINQ 表达式（9）高亮显示`	提示
简化表达式 `简化 LINQ 表达式（10）` `ReSharper 为 Visual Basic 简化 LINQ 表达式的高亮显示`	提示
简化 'IIf' `简化 IIf 表达式` `ReSharper 简化 IIf 表达式的高亮显示`	建议
明确指定字符串比较 `指定 StringComparison 参数` `ReSharper 指定 StringComparison 参数的高亮显示`	提示
String.Compare 是特定于文化的（string.Compare(string, int, string, int) 是特定于文化的） `在 Visual Basic 中进行字符串比较具有文化特定性。建议明确指定 StringComparison 参数以提高代码的可预测性和跨文化一致性。` `ReSharper 标识 Visual Basic 字符串比较具有文化特定性的高亮显示`	警告
String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的） `VBStringCompare 是特定于区域性的字符串比较。5` `VBStringCompare 是特定于区域性的字符串比较规则。5 的高亮显示`	警告
String.Compare 是特定于文化的（string.Compare(string, int, string, int, bool) 是特定于文化的） `VBStringCompare 是特定于区域性的字符串比较。6` `VBStringCompare 是特定于区域性的字符串比较规则。6 的高亮显示`	警告
String.Compare 是特定于文化的（string.Compare(string, string) 是特定于文化的） `VBStringCompare 是特定于区域性的字符串比较。1` `VBStringCompare 是特定于区域性的字符串比较规则。1 的高亮显示`	警告
String.Compare 是特定于区域性的（string.Compare(string, string, bool) 是特定于区域性的） `VBStringCompare 是特定于区域性的字符串比较。2` `VBStringCompare 是特定于区域性的字符串比较规则。2 的高亮显示`	警告
String.Compare 是特定于区域性的（string.Compare(string, string, bool) 是特定于区域性的） `VBStringCompare 是特定于区域性的字符串比较。3` `VBStringCompare 是特定于区域性的字符串比较规则。3 的高亮显示`	警告
String.CompareTo 是特定于区域性的 `String.CompareTo 是特定于区域性的` `String.CompareTo 是特定于区域性的的高亮显示`	警告
String.EndsWith 是特定于区域性的（string.EndsWith(string) 是特定于区域性的） `String.EndsWith 是特定于区域性的` `String.EndsWith 是特定于区域性的的高亮显示`	已禁用
String.IndexOf 是特定于区域性的（string.IndexOf(string) 是特定于区域性的） `String.IndexOf 是特定于区域性的。1` `String.IndexOf 是特定于区域性的规则。1 的高亮显示`	警告
String.IndexOf 是特定于区域性的（string.IndexOf(string, int) 是特定于区域性的） `String.IndexOf 是特定于区域性的。2` `String.IndexOf 是特定于区域性的规则。2 的高亮显示`	警告
String.IndexOf 是特定于区域性的（string.IndexOf(string, int) 是特定于区域性的） `String.IndexOf 是特定于区域性的。3` `String.IndexOf 是特定于区域性的规则。3 的高亮显示`	警告
String.LastIndexOf 是特定于区域性的（string.LastIndexOf(string) 是特定于区域性的） `String.LastIndexOf 是特定于区域性的。1` `String.LastIndexOf 是特定于区域性的规则。1 的高亮显示`	警告
String.LastIndexOf 是特定于区域性的（string.LastIndexOf(string, int) 是特定于区域性的） `String.LastIndexOf 是特定于区域性的。2` `String.LastIndexOf 是特定于区域性的规则。2 的高亮显示`	警告
String.LastIndexOf 是特定于区域性的（string.LastIndexOf(string, int) 是特定于区域性的） `String.LastIndexOf 是特定于区域性的。3` `String.LastIndexOf 是特定于区域性的规则。3 的高亮显示`	警告
String.StartsWith 是特定于区域性的（string.StartsWith(string) 是特定于区域性的） `String.StartsWith 是特定于区域性的` `String.StartsWith 是特定于区域性的的高亮显示`	已禁用
结构体可以声明为 readonly `结构可设为只读` `结构可设为只读的高亮显示`	建议
结构体缺少 'IEquatable' 实现（非私有可访问性） `结构缺少 IEquatable（全局）` `结构缺少 IEquatable（全局）的高亮显示`	警告
结构体缺少 'IEquatable' 实现（私有可访问性） `结构缺少 IEquatable（局部）` `结构缺少 IEquatable（局部）的高亮显示`	警告
结构体成员可以声明为 readonly `结构成员可设为只读` `结构成员可设为只读的高亮显示`	已禁用
使用默认相等成员的结构体用于比较（非私有可访问性） `默认结构相等性正在使用（全局）` `默认结构相等性正在使用（全局）的高亮显示`	警告
使用默认相等成员的结构体用于比较（私有可访问性） `默认结构相等性正在使用（局部）` `默认结构相等性正在使用（局部）的高亮显示`	警告
try-catch 和 try-finally 语句可以合并 `Try 语句可合并` `Try 语句可合并的高亮显示`	提示
在记录中使用了具有可疑相等性的类型（非私有可访问性） `记录中使用了相等性可疑的类型（全局）` `记录中使用了相等性可疑的类型（全局）的高亮显示`	警告
在记录中使用了具有可疑相等性的类型（私有可访问性） `记录中使用了相等性可疑的类型（局部）` `记录中使用了相等性可疑的类型（局部）的高亮显示`	警告
使用数组创建表达式 `建议使用数组创建表达式。1` `建议使用数组创建表达式。1 的高亮显示`	建议
使用数组创建表达式 `建议使用数组创建表达式。2` `建议使用数组创建表达式。2 的高亮显示`	建议
改用 First() `建议使用 First 方法代替` `建议使用 First 方法代替的高亮显示`	警告
使用方法 Any() `建议使用 Any 方法。1` `建议使用 Any 方法。1 的高亮显示`	建议
使用方法 Any() `建议使用 Any 方法。2` `建议使用 Any 方法。2 的高亮显示`	建议
使用方法 Any() `建议使用 Any 方法。3` `建议使用 Any 方法。3 的高亮显示`	建议
使用方法 Any() `建议使用 Any 方法。4` `建议使用 Any 方法。4 的高亮显示`	建议
使用方法 Any() `建议使用 IsInstanceOfType 方法` `建议使用 IsInstanceOfType 方法的高亮显示`	建议
使用方法 IsInstanceOfType(..) `建议使用 TypeOf...Is 运算符。1` `建议使用 TypeOf...Is 运算符。1 的高亮显示`	建议
使用 'TypeOf .. 是 ..' 运算符 `建议使用 TypeOf...Is 运算符。2` `建议使用 TypeOf...Is 运算符。2 的高亮显示`	建议
使用 'TypeOf .. 是 ..' 运算符 `VB 使用 TypeOf...Is 运算符.2` `resharper_vb_use_type_of_is_operator_2_highlighting`	建议

编译器警告（25 项检查）

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

检查 ID EditorConfig 属性	默认严重性
通过实例访问共享成员 `VB 编译器警告：BC42025` `VB 编译器警告：BC42025 的高亮显示`	警告
异步方法缺少 'Await' 运算符 `VB 编译器警告：BC42356` `VB 编译器警告：BC42356 的高亮显示`	警告
由于此调用未被等待，当前方法的执行将在调用完成之前继续。考虑将 'Await' 运算符应用于调用结果。 `VB 编译器警告：BC42358` `VB 编译器警告：BC42358 的高亮显示`	警告
字段从未使用过 `未使用的字段（由编译器报告）` `未使用字段（由编译器报告）的高亮显示`	警告
函数在所有代码路径上未返回引用类型值 `VB 编译器警告：BC42105、BC42106、BC42107` `VB 编译器警告：BC42105、BC42106、BC42107 的高亮显示`	警告
函数在所有代码路径上未返回结构体值 `VB 编译器警告：BC42353、BC42354、BC42355` `VB 编译器警告：BC42353、BC42354、BC42355 的高亮显示`	警告
成员隐藏了可重写的成员 `VB 编译器警告：BC400005` `VB 编译器警告：BC400005 的高亮显示`	警告
Imports 'name' 中指定的命名空间或类型不包含任何公共成员或无法找到 `VB 编译器警告：BC40056` `VB 编译器警告：BC40056 的高亮显示`	警告
命名空间应为此项目的默认命名空间 `VB 编译器警告：WME006` `VB 编译器警告：WME006 的高亮显示`	警告
未访问的字段 `未访问的字段（由编译器报告）` `未访问字段（由编译器报告）的高亮显示`	警告
未访问的局部变量 `未访问的变量（由编译器报告）` `未访问变量（由编译器报告）的高亮显示`	警告
对相等值类型的冗余 DirectCast `VB 警告：BC42349` `resharper_vb_warnings_bc42349_highlighting`	警告
将 X 转换为 Y 时可能会发生运行时错误 `VB 警告：BC42322` `resharper_vb_warnings_bc42322_highlighting`	警告
将 X 转换为 Y 时可能会发生运行时错误 `VB 警告：BC42016` `resharper_vb_warnings_bc42016_highlighting`	警告
XML 注释中的语法错误 `VB 警告：BC42304` `resharper_vb_warnings_bc42304_highlighting`	警告
应用于参数的 CallerArgumentExpressionAttribute 将不起作用，因为它是自引用的 `VB 警告：BC42504` `resharper_vb_warnings_bc42504_highlighting`	警告
应用于参数的 CallerArgumentExpressionAttribute 将不起作用。它应用了一个无效的参数名称。 `VB 警告：BC42505` `resharper_vb_warnings_bc42505_highlighting`	警告
此类型仅用于评估目的，可能会在未来更新中更改或移除。抑制此诊断以继续。 `VB 警告：BC42380` `resharper_vb_warnings_bc42380_highlighting`	警告
未赋值的字段 `未分配字段．编译器` `resharper_unassigned_field_compiler_highlighting`	警告
未赋值的 readonly 字段 `未分配只读字段．编译器` `resharper_unassigned_readonly_field_compiler_highlighting`	警告
未使用的局部变量 `未使用变量．编译器` `resharper_unused_variable_compiler_highlighting`	警告
使用已过时的成员 `VB 警告：BC40000` `resharper_vb_warnings_bc40000_highlighting`	警告
使用已过时的成员（无消息） `VB 警告：BC40008` `resharper_vb_warnings_bc40008_highlighting`	警告
变量在赋值之前被使用 `VB 警告：BC42104` `resharper_vb_warnings_bc42104_highlighting`	警告
XML 注释中包含无法解析的带有 'cref' 属性的标签 `VB 警告：BC42309` `resharper_vb_warnings_bc42309_highlighting`	警告

约束违规（2 项检查）

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

检查 ID EditorConfig 属性	默认严重性
命名不一致 `命名不一致` `resharper_inconsistent_naming_highlighting`	警告
命名空间与文件位置不一致 `检查命名空间` `resharper_check_namespace_highlighting`	警告

语法问题（4 项检查）

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

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

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

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

检查 ID EditorConfig 属性	默认严重性
将静态方法调用转换为扩展方法调用 `作为扩展方法调用` `resharper_invoke_as_extension_method_highlighting`	建议
foreach 循环可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法 `Foreach 可通过另一个 GetEnumerator 转换为查询` `resharper_foreach_can_be_converted_to_query_using_another_get_enumerator_highlighting`	提示
循环可以转换为 LINQ 表达式 `循环可转换为查询` `resharper_loop_can_be_converted_to_query_highlighting`	提示
部分 foreach 循环可以转换为 LINQ 表达式，但将使用另一个 'GetEnumerator' 方法 `Foreach 可部分通过另一个 GetEnumerator 转换为查询` `resharper_foreach_can_be_partly_converted_to_query_using_another_get_enumerator_highlighting`	提示
部分循环体可以转换为 LINQ 表达式 `循环可部分转换为查询` `resharper_loop_can_be_partly_converted_to_query_highlighting`	已禁用
传递字符串插值表达式 `传递字符串插值` `resharper_pass_string_interpolation_highlighting`	提示
使用字符串插值表达式 `使用字符串插值` `resharper_use_string_interpolation_highlighting`	建议

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

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

检查 ID EditorConfig 属性	默认严重性
'?:' 表达式的 true 和 false 分支相同 `条件三元表达式分支相等` `resharper_conditional_ternary_equal_branch_highlighting`	警告
[ThreadStatic] 无法与实例字段一起使用 `实例字段上的 ThreadStatic` `resharper_thread_static_at_instance_field_highlighting`	警告
抽象或虚拟（可重写）事件从未被调用 `事件未被调用．全局` `resharper_event_never_invoked_global_highlighting`	建议
访问已释放的捕获变量 `访问已释放闭包` `resharper_access_to_disposed_closure_highlighting`	警告
在闭包中访问 foreach 变量 `在闭包中访问 foreach 变量` `resharper_access_to_for_each_variable_in_closure_highlighting`	警告
访问已修改的捕获变量 `访问已修改闭包` `resharper_access_to_modified_closure_highlighting`	警告
层次结构中的注解冲突 `层级结构中的注解冲突` `resharper_annotation_conflict_in_hierarchy_highlighting`	警告
自动属性访问器从未使用（非私有访问权限） `未使用的自动属性访问器．全局` `resharper_unused_auto_property_accessor_global_highlighting`	警告
自动属性访问器从未使用（私有访问权限） `未使用的自动属性访问器．本地` `resharper_unused_auto_property_accessor_local_highlighting`	警告
调用具有隐式默认参数的基成员 `使用默认参数调用基方法` `resharper_base_method_call_with_default_parameter_highlighting`	警告
调用 'base.Equals(...)' 是引用相等 `BaseObject.Equals 即 Object.Equals` `resharper_base_object_equals_is_object_equals_highlighting`	警告
无法解析属性 `未解析的属性` `resharper_property_not_resolved_highlighting`	错误
无法解析资源 `未解析的资源` `resharper_resource_not_resolved_highlighting`	错误
无法解析资源项 `未解析的资源项` `resharper_resource_item_not_resolved_highlighting`	错误
无法在文本参数中解析符号 `文本中未解析` `resharper_not_resolved_in_text_highlighting`	警告
类从未被实例化（非私有访问权限） `类从未被实例化．全局` `类从未被实例化（全局）`	建议
类从未被实例化（私有访问权限） `类从未被实例化（局部）` `类从未被实例化（局部）`	建议
集合内容从未被查询（非私有访问权限） `集合从未被查询（全局）` `集合从未被查询（全局）`	警告
集合内容从未被查询（私有访问权限） `集合从未被查询（局部）` `集合从未被查询（局部）`	警告
集合从未更新（非私有访问权限） `集合从未被更新（全局）` `集合从未被更新（全局）`	警告
集合从未更新（私有访问权限） `集合从未被更新（局部）` `集合从未被更新（局部）`	警告
不要在格式字符串的格式说明符后使用右大括号 `格式说明符捕获了右大括号` `格式说明符捕获了右大括号`	警告
元素可本地化 `可本地化元素` `可本地化元素`	警告
浮点数的相等性比较 `通过等号比较浮点数` `通过等号比较浮点数`	警告
事件从未被订阅（非私有访问权限） `事件从未被订阅（全局）` `事件从未被订阅（全局）`	建议
事件从未被订阅（私有访问权限） `事件从未被订阅（局部）` `事件从未被订阅（局部）`	建议
事件从未被调用 `事件从未被调用` `事件从未被调用`	警告
可能是有意重新抛出异常 `可能需要重新抛出异常` `可能需要重新抛出异常`	警告
显式参数传递给具有调用者信息属性的参数 `显式调用者信息参数` `显式调用者信息参数`	警告
函数从不返回 `函数从未返回` `函数从未返回`	警告
类型没有析构函数却调用了 'GC.SuppressFinalize' `对无析构函数的类型调用 GCSuppressFinalize` `对无析构函数的类型调用 GCSuppressFinalize`	警告
迭代器从不返回 `迭代器从未返回` `迭代器从未返回`	警告
局部变量隐藏了成员 `局部变量隐藏成员` `局部变量隐藏成员`	警告
未访问的字段（非私有访问权限） `字段未访问（全局）` `字段未访问（全局）`	建议
未访问的字段（私有访问权限） `字段未访问（局部）` `字段未访问（局部）`	警告
未访问的位置属性（非私有访问权限） `位置属性未访问（全局）` `位置属性未访问（全局）`	警告
未访问的位置属性（私有访问权限） `位置属性未访问（局部）` `位置属性未访问（局部）`	警告
在 'GetHashCode()' 中引用了非只读类型成员 `GetHashCode 中使用了可变成员` `GetHashCode 中使用了可变成员`	警告
'Object.ReferenceEquals' 始终为 false，因为它是用值类型调用的 `对值类型使用 ReferenceEquals` `对值类型使用 ReferenceEquals`	警告
可以使用运算符 'is'/'Type Of ... Is ...' `可以使用 Is 运算符` `可以使用 Is 运算符`	警告
'out' 参数在退出时未被赋值 `未赋值的 out 参数` `未赋值的 out 参数`	警告
重写的 GetHashCode 调用了基类 'Object.GetHashCode()' `在 GetHashCode 中调用基类 Object.GetHashCode` `在 GetHashCode 中调用基类 Object.GetHashCode`	警告
参数隐藏了成员 `参数隐藏成员` `参数隐藏成员`	警告
可能不正确的双重检查锁定模式实现。可能对检查字段进行多次写入访问。 `双重检查锁存在多次写入` `双重检查锁存在多次写入`	警告
可能不正确的双重检查锁定模式实现。读取检查字段的访问。 `双重检查锁中的读取访问` `双重检查锁中的读取访问`	警告
可能的无限继承 `可能的无限继承` `可能的无限继承`	警告
可能的多次枚举 `可能的多次枚举` `可能的多次枚举`	警告
可能写入 'Me' `可能写入 Me` `可能写入 Me`	警告
可能在 readonly 变量上调用了非纯结构体方法：在调用之前结构体值始终会被复制 `对只读变量调用非纯方法` `对只读变量调用非纯方法`	警告
未使用纯方法的返回值 `纯方法的返回值未使用` `纯方法的返回值未使用`	警告
相似表达式比较 `恒等表达式比较` `恒等表达式比较`	警告
泛型类型中的静态字段或自动属性 `泛型类型中含静态成员` `泛型类型中含静态成员`	警告
静态成员初始化器引用了下面或其他部分的静态成员 `静态成员初始化器引用了其后成员` `静态成员初始化器引用了其后成员`	警告
字符串格式化方法问题 `格式字符串问题` `格式字符串问题`	警告
结构化日志消息项存在重复或仅大小写不同 `记录器模板中存在重复项` `记录器模板中存在重复项`	警告
结构化消息模板问题 `结构化消息模板问题` `结构化消息模板问题`	警告
可疑的类型转换或检查 `可疑的类型转换（全局）` `可疑的类型转换（全局）`	警告
模块中的符号可能在运行时丢失 `使用了来自未复制本地引用的符号` `使用未本地复制的引用中的 ReSharper 符号`	警告
'l' 后缀容易与数字 '1' 混淆 `长整型文本以小写字母 L 结尾` `长整型文本以小写 L 结尾的 ReSharper 高亮显示`	警告
线程静态字段具有初始化器 `带初始化器的 ThreadStatic 字段` `带初始化器的 ThreadStatic 字段的 ReSharper 高亮显示`	警告
类型检查和转换可以合并 `合并类型检查与类型转换` `合并类型检查与类型转换的 ReSharper 高亮显示`	建议
未赋值的字段（非私有访问权限） `全局未赋值字段` `全局未赋值字段的 ReSharper 高亮显示`	建议
未赋值的字段（私有访问权限） `局部未赋值字段` `局部未赋值字段的 ReSharper 高亮显示`	警告
未赋值的 readonly 字段 `未赋值的 ReadOnly 字段` `未赋值 ReadOnly 字段的 ReSharper 高亮显示`	警告
在格式字符串中使用格式说明符 `在格式字符串中使用格式说明符` `格式字符串中使用格式说明符的 ReSharper 高亮显示`	建议
分配给非变量限定符表达式的属性的值可能会丢失 `对非变量结构体的结构体成员可能存在的修改` `对非变量结构体的结构体成员可能存在的修改的 ReSharper 高亮显示`	警告
'void' 方法带有 [Pure] 属性注解 `在返回类型为 Void 的方法上使用 Pure 特性` `Void 方法上的 Pure 属性的 ReSharper 高亮显示`	警告

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

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

检查 ID EditorConfig 属性	默认严重性
赋值未被使用 `冗余赋值` `冗余赋值的 ReSharper 高亮显示`	警告
显式 'value' 参数声明是多余的 `冗余的 Setter value 参数声明` `冗余 Setter value 参数声明的 ReSharper 高亮显示`	提示
表达式始终为 'true' 或始终为 'false' `条件始终为 true 或 false` `条件始终为 true 或 false 的 ReSharper 高亮显示`	警告
迭代器函数没有 'Yield' 语句 `冗余的 Iterator 关键字` `冗余 Iterator 关键字的 ReSharper 高亮显示`	警告
多行 'If' 语句中的关键字 'Then' 是多余的 `冗余的 If 语句 Then 关键字` `冗余 If 语句 Then 关键字的 ReSharper 高亮显示`	已禁用
无参数属性的括号是多余的 `冗余属性括号` `冗余属性括号的 ReSharper 高亮显示`	提示
如果属性没有参数，则括号是多余的 `冗余属性特性括号` `冗余属性特性括号的 ReSharper 高亮显示`	提示
传递给调用者参数表达式参数的冗余参数 `冗余 CallerArgumentExpression 默认值` `冗余 CallerArgumentExpression 默认值的 ReSharper 高亮显示`	警告
冗余的数组下界指定 `冗余数组下限说明` `冗余数组下限说明的 ReSharper 高亮显示`	警告
冗余的强制转换 `冗余转换` `冗余转换的 ReSharper 高亮显示`	警告
冗余的空 'Case Else' 语句 `冗余空的 Case Else 分支` `冗余空的 Case Else 分支的 ReSharper 高亮显示`	警告
冗余的显式数组大小指定 `冗余显式数组大小` `冗余显式数组大小的 ReSharper 高亮显示`	警告
冗余的 'Me.' 限定符 `冗余 Me 限定符` `冗余 Me 限定符的 ReSharper 高亮显示`	警告
冗余的 'MyBase.' 限定符 `冗余 MyBase 限定符` `冗余 MyBase 限定符的 ReSharper 高亮显示`	警告
冗余的 'MyClass.' 限定符 `冗余 MyClass 限定符` `冗余 MyClass 限定符的 ReSharper 高亮显示`	警告
逻辑条件表达式中的冗余操作数 `冗余逻辑条件表达式操作数` `冗余逻辑条件表达式操作数的 ReSharper 高亮显示`	警告
冗余的限定符 `冗余限定符` `冗余限定符的 ReSharper 高亮显示`	警告
移除冗余的括号 `冗余括号` `冗余括号的 ReSharper 高亮显示`	已禁用
不可达代码 `VB 中不可达代码` `VB 中不可达代码的 ReSharper 高亮显示`	警告
未使用的导入子句 `未使用的 Import 子句` `未使用的 Import 子句的 ReSharper 高亮显示`	警告
使用隐式 'ByVal' 修饰符 `使用隐式 ByVal 修饰符` `隐式 ByVal 修饰符的 ReSharper 高亮显示`	提示
使用隐式类型变量声明 `使用隐式类型变量` `使用隐式类型变量的 ReSharper 高亮显示`	已禁用
使用隐式类型变量声明（显而易见） `显而易见时使用隐式类型变量` `显而易见时使用隐式类型变量的 ReSharper 高亮显示`	提示

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

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

检查 ID EditorConfig 属性	默认严重性
具有虚拟（可重写）成员的类从未被继承（非私有访问权限） `从未被继承的包含虚拟成员的全局类` `从未被继承的包含虚拟成员的全局类的 ReSharper 高亮显示`	建议
具有虚拟（可重写）成员的类从未被继承（私有访问权限） `从未被继承的包含虚拟成员的局部类` `从未被继承的包含虚拟成员的局部类的 ReSharper 高亮显示`	建议
实体仅用于捕获其名称（非私有访问权限） `仅在全局范围捕获的实体名称` `仅在全局范围捕获的实体名称的 ReSharper 高亮显示`	警告
实体仅用于捕获其名称（私有访问权限） `仅在局部范围捕获的实体名称` `仅在局部范围捕获的实体名称的 ReSharper 高亮显示`	警告
方法返回值从未被使用（非私有访问权限） `未使用的方法返回值（全局）` `未使用的方法返回值（全局）的 ReSharper 高亮显示`	建议
方法返回值从未被使用（私有访问权限） `未使用的方法返回值（局部）` `未使用的方法返回值（局部）的 ReSharper 高亮显示`	警告
未访问的局部变量 `未访问的变量` `未访问变量的 ReSharper 高亮显示`	警告
未访问的局部变量仅用于丢弃 'out' 参数值 `未访问的输出参数变量` `未访问的输出参数变量的 ReSharper 高亮显示`	警告
未访问的主构造函数参数 `主构造函数参数未访问（编译器）` `主构造函数参数未访问（编译器）的 ReSharper 高亮显示`	警告
参数仅用于前置条件检查（非私有访问权限） `仅用于前置条件检查的参数（全局）` `参数仅用于前置条件检查（全局）`	建议
参数仅用于前置条件检查（私有访问权限） `参数仅用于前置条件检查（局部）` `参数仅用于前置条件检查（局部）`	警告
参数输出值始终被丢弃（非私有访问权限） `out 参数的值始终被忽略（全局）` `out 参数的值始终被忽略（全局）`	建议
参数输出值始终被丢弃（私有访问权限） `out 参数的值始终被忽略（局部）` `out 参数的值始终被忽略（局部）`	警告
类型从未使用（非私有访问权限） `未使用的类型（全局）` `未使用的类型（全局）`	建议
类型从未使用（私有访问权限） `未使用的类型（局部）` `未使用的类型（局部）`	警告
类型成员从未通过基类型访问（非私有访问权限） `基类中未使用的成员（全局）` `基类中未使用的成员（全局）`	建议
类型成员从未通过基类型访问（私有访问权限） `基类中未使用的成员（局部）` `基类中未使用的成员（局部）`	警告
类型成员从未使用（非私有访问权限） `未使用的成员（全局）` `未使用的成员（全局）`	建议
类型成员从未使用（私有访问权限） `未使用的成员（局部）` `未使用的成员（局部）`	警告
类型成员仅在重写中使用（非私有访问权限） `未使用的成员层级结构（全局）` `未使用的成员层级结构（全局）`	建议
类型成员仅在重写中使用（私有访问权限） `未使用的成员层级结构（局部）` `未使用的成员层级结构（局部）`	警告
未使用的标签 `未使用的标签` `未使用的标签`	警告
未使用的局部变量 `未使用的变量` `未使用的变量`	警告
未使用的参数（非私有访问权限） `未使用的参数（全局）` `未使用的参数（全局）`	建议
未使用的参数（私有访问权限） `未使用的参数（局部）` `未使用的参数（局部）`	警告
部分方法中未使用的参数 `Partial 方法中未使用的参数` `Partial 方法中未使用的参数`	警告
未使用的位置参数 `未使用的位置参数（编译器）` `未使用的位置参数（编译器）`	警告
未使用的类型参数 `未使用的类型参数` `未使用的类型参数`	警告
虚拟（可重写）成员从未被重写（非私有访问权限） `虚成员从未被重写（全局）` `虚成员从未被重写（全局）`	建议
虚拟（可重写）成员从未被重写（私有访问权限） `虚成员从未被重写（局部）` `虚成员从未被重写（局部）`	建议

拼写问题（3 项检查）

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

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

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