C# 中的“相等判断”

diannao · 前天 19:02

C# 中的“相等判断”

C# 中判断相等的方式很多，例如：

双等号 ==
实例的 Equals() 方法
Object.Equals() 静态方法
Object.ReferenceEquals() 方法
EqualityComparer<int>.Default.Equals() 方法
is 运算符

还有一些特殊的类型内部实现了相等判断，例如：

元组
匿名类型

还有一些特别的相等判断，例如：

内部元素结构化相等比较

这些相等判断都是做什么的？何时使用？下面我将一一列举说明。
1. 双等号（==）的相等判断

1.1 基元类型

对于基元类型（int、float 等），== 是比较二者值是否相等。查看这些基元类型的源码可以发现，它们并没有对 == 运算符进行重载，但它们却可以使用 == 进行比较。这是因为编译器对基元类型进行了特殊优化：

编译阶段：直接生成 ceq IL 指令（Compare Equal）
运行时：JIT 编译器将 ceq 转换为底层 CPU 的整数比较指令，无需调用任何方法

1.2 部分预定义值类型

部分内置的值类型（非基元类型，如 decimal），它们可以使用 == 进行比较，是因为对 == 运算符进行了重载。下面两段代码比较了 int 和 decimal 进行相等比较对应的 IL 代码：
int num = 1;int num2 = 2;bool flag = num == num2;// 对应的 IL 代码如下，有删减IL_0000: nop// int num = 1;IL_0001: ldc.i4.1IL_0002: stloc.0// int num2 = 2;IL_0003: ldc.i4.2IL_0004: stloc.1// bool flag = num == num2;IL_0005: ldloc.0IL_0006: ldloc.1IL_0007: ceqIL_0009: stloc.2decimal num = 1m;decimal num2 = 2m;bool flag = num == num2;// 对应的 IL 代码如下，有删减IL_0000: nop// decimal num = 1m;IL_0001: ldsfld valuetype [System.Runtime]System.Decimal [System.Runtime]System.Decimal::OneIL_0006: stloc.0// decimal num2 = 2m;IL_0007: ldloca.s 1IL_0009: ldc.i4.2IL_000a: call instance void [System.Runtime]System.Decimal::.ctor(int32)// bool flag = num == num2;IL_000f: ldloc.0IL_0010: ldloc.1IL_0011: call bool [System.Runtime]System.Decimal::op_Equality(valuetype [System.Runtime]System.Decimal, valuetype [System.Runtime]System.Decimal)IL_0016: stloc.2对于值类型，如果没有重载 == 运算符，是无法使用 == 进行比较的。如下代码无法通过编译：
Person person1 = new Person();Person person2 = new Person();bool flag = person1 == person2;struct Person{ public int Age { get; set; }}1.3 引用类型

对于引用类型，== 判断返回二者的引用是否为相同（前提是未重载 == 运算符）。最典型的是 string 类型，它的 == 方法判断两个字符串内容是否相同，将其强转为 object 类型再进行 == 比较时，将转化为引用比较。以如下代码为例，它将依次输出 True、False：
string value = "123";string content1 = value + value;string content2 = value + value;Console.WriteLine(content1 == content2);Console.WriteLine((object)content1 == (object)content2);上述 string 变量值是在运行时才确定的，因此它们的引用不相同。再看下面这段代码，它将依次输出 True、True：
string value = "123";string content1 = value;string content2 = value;Console.WriteLine(content1 == content2);Console.WriteLine((object)content1 == (object)content2);这是因为编译时 string 变量的值已经确定了，为了节省内存，二者是同一实例。
2. Equals() 实例方法

2.1 Equals() 的编写准则与使用场景

Equals() 实例方法常用于哈希表等需要执行相等判断的集合类型，因此它对相等判断的要求更为严格。它遵循如下准则：

自反性
x.Equals(x) 应该为 true。
对称性
x.Equals(y) 的返回值与 y.Equals(x) 相同。
传递性
x.Equals(y)、y.Equals(z) 为 true，则 x.Equals(z) 也应该为 true
一致性
只要 x 和 y 未被修改，x.Equals(y) 的返回值都应该相同。
非空性
x.Equals(null) 应返回 false。

如果不严格遵守上述准则，那么哈希表中的工作就会出错！假设我们有如下 Person 类，它覆写了 Equals() 方法，并且始终返回 false，这使得它在插入 HashSet<T> 后，却无法正确查找。如下代码将输出 False：
Person person = new Person{ Name = "John", Age = 20};HashSet<Person> set = new();set.Add(person);Console.WriteLine(set.Contains(person));struct Person{ public string Name { get; set; } public int Age { get; set; } public override bool Equals(object obj) { return false; }}以上是 Equals() 方法的主要用途（我很少在业务代码中看到调用 Equals() 方法的），下面我们讲解 Euqals() 在值类型、引用类型中的不同。
2.1 基元类型

基元类型的 Equals() 方法直接调用了 == 运算符，因此它的调用和使用 == 运算符没有差别。
2.1.1 NaN 的相等判断

在学习 NaN 的相等判断之前我们先回答一个问题：NaN 是什么？
NaN 是“Not a Number”的缩写，表示未定义或不可表示的值。它常出现在浮点计算被除数为 0 的情况。如下计算便会得到 NaN：
Console.WriteLine(0.0 / 0.0);NaN 十分特殊，使用 == 运算符进行判断和使用 Equals() 进行判断结果刚好相反！以如下代码为例，它将分别输出 False、True
double value = 0.0 / 0.0;Console.WriteLine(value == value);Console.WriteLine(value.Equals(value));这是因为 == 更多的是表示“数学中的相等”，在数学中，两个 NaN 无论如何都不可能相等，因此 value == value 的结果是 False。而 Equals() 必须支持自反性，因此 value.Equals(value) 的结果是 True。集合和字典需要 Equals() 保持这个行为，否则就无法找到之前存储的项目了。
我们通常使用 floast.IsNaN() 或 double.IsNaN() 方法判断一个值是否为 NaN：
Console.WriteLine (double.IsNaN (0.0 / 0.0));

Info
请参考第2章 C# 语言基础 - hihaojie - 博客园 2.4.7 特殊的浮点值、第6章框架基础 - hihaojie - 博客园 6.11.2.6 Equals 和 == 在何时并不等价

2.2 值类型

这里我们特指自定义结构体，其 Equals() 方法未被覆写。
值类型的 Equals() 方法很特别，它的底层会通过反射对所有字段进行相等比较！以如下代码为例，即使 p1 和 p2 分别定义，Equals() 方法仍能判断二者相等。
Person p1 = new Person{ Name = "John", Age = 18};Person p2 = new Person{ Name = "John", Age = 18};Console.WriteLine(p1.Equals(p2));struct Person{ public string Name { get; set; } public int Age { get; set; }}通过反射完成相等判断，它的性能必然受限，并且值类型在使用 object.Equals() 方法比较时会进行装箱。为此 C# 提供了 IEquatable<T> 接口。
2.2.1 IEquatable<T> 接口

Info
该内容可参考第4章类型设计准则 - hihaojie - 博客园的 4.7 struct 的设计、第8章使用准则 - hihaojie - 博客园的 8.6 IComparable<T> 与 IEquatable<T>、8.9 Object

值类型实现 IEquatable<T> 可以避免 2 个问题：

值类型的 Object.Equals() 方法会导致装箱，
Object.Equals() 使用了反射，它的默认实现效率不高。

该接口定义如下，其 Equals() 方法要求我们自行完成成员的相等判断：
public interface IEquatable<T>{ bool Equals(T? other);}以前文的 Person 结构体为例，它的实现如下：
Person p1 = new Person{ Name = "John", Age = 18};Person p2 = new Person{ Name = "John", Age = 18};Console.WriteLine(p1.Equals(p2));class Person : IEquatable<Person>{ public string Name { get; set; } public int Age { get; set; } public override bool Equals(object? obj) { return Equals(obj as Person); } public bool Equals(Person? other) { if (other is null) { return false; } if (!Name.Equals(other.Name)) { return false; } if (Age != other.Age) { return false; } return true; }}2.3 引用类型

对于引用类型（在 Equals() 方法、== 运算符未被覆写的情况下），其 Equals() 方法与 == 运算符含义相同，比较引用是否相同。
而 Equals 和 == 含义不同这种做法在引用类型中有很多，开发者自定义 Equals() 实现值的相等比较，而仍旧令 == 执行（默认的）引用相等比较。StringBuilder 类便采用了这种方式，如下代码将输出“False、True”：
var sb1 = new StringBuilder ("foo");var sb2 = new StringBuilder ("foo");Console.WriteLine (sb1 == sb2);Console.WriteLine (sb1.Equals (sb2));

Notice
StringBuilder 并未覆写 object.Equals() 实例方法，它只是添加了一个新的重载方法。因此如下两段代码执行结果不同：
Console.WriteLine(sb1.Equals(sb2));Console.WriteLine(((object)sb1).Equals(sb2));

什么情况下应该覆写引用类型的 Equals() 方法呢？《框架设计指南》第8章使用准则给出了建议：

CONSIDER：如果引用类型表示的是一个值，考虑覆盖 Equals() 方法以提供值相等语义。
例如：表示数值、数学实体的引用类型。

Info
更多内容，请参考第6章框架基础 - hihaojie - 博客园 6.11.2.6 Equals 和 == 在何时并不等价、第8章使用准则 8.9.1 Object.Equals

3. Object.Equals() 静态方法

Object.Equals() 静态方法主要用于避免“实例为空导致的空引用异常（NullReferenceException）”。它的内部操作如下：
public static bool Equals (object objA, object objB) => objA == null ? objB == null : objA.Equals (objB);与 object.Equals() 实例方法不同，该静态方法接受两个参数。它常用于 == 和 != 无法使用的场景，譬如泛型实例比较：
class Test<T>{ T _value; public void SetValue(T newValue) { if (!object.Equals(newValue, _value)) { _value = newValue; OnValueChanged(); } } protected virtual void OnValueChanged() {}}上述代码无法使用 == 和 !=（因为类型不确定，编译时无法绑定）；对于 object.Equals() 实例方法，如果 newValue 为 null，则会抛出 NullReferenceException 异常，因此这里使用静态方法 Object.Equals()。
4. Object.ReferenceEquals() 方法

我们在2.3 引用类型提到：

而 Equals 和 == 含义不同这种做法在引用类型中有很多，开发者自定义 Equals() 实现值的相等比较，而仍旧令 == 执行（默认的）引用相等比较。StringBuilder 类便采用了这种方式，如下代码将输出“False、True”：

如果 == 和 Equals() 都进行了重载，我们又需要判断引用是否相同，应该怎么做？
有 2 种方案：

将实例显式转换为 object 再用 == 进行比较
通过 Object.ReferenceEquals() 静态方法比较

我们实际看 Object.ReferenceEquals() 代码会发现，上述两种方案其实是一样的：都是将实例转换为 object 再用 == 进行比较，只是实例转换为 object 这一步通过传参的方式省略了：
public static bool ReferenceEquals (Object objA, Object objB){ return objA == objB;}如下这段代码对比了各种比较方式，只有最后两条输出语句正确进行了引用比较：
var p1 = new Person{ Name = "John", Age = 18};var p2 = new Person{ Name = "John", Age = 18};Console.WriteLine(p1 == p2);Console.WriteLine(p1.Equals(p2));Console.WriteLine(((object)p1).Equals(p2));Console.WriteLine(object.Equals(p1, p2));Console.WriteLine((object)p1 == (object)p2);Console.WriteLine(object.ReferenceEquals(p1, p2));class Person : IEquatable<Person>{ public string Name { get; set; } public int Age { get; set; } public static bool operator ==(Person left, Person right) { return left.Equals(right); } public static bool operator !=(Person left, Person right) { return !(left == right); } public override bool Equals(object? obj) { return Equals(obj as Person); } public bool Equals(Person? other) { if (other is null) { return false; } if (!Name.Equals(other.Name)) { return false; } if (Age != other.Age) { return false; } return true; }}5. EqualityComparer<T>.Default.Equals() 方法

我们在3. Object.Equals() 静态方法的用例代码中展示了两个泛型实例比较是否相等：

class Test<T>{ T _value; public void SetValue(T newValue) { if (!object.Equals(newValue, _value)) { _value = newValue; OnValueChanged(); } } protected virtual void OnValueChanged() {}}

它虽然实现了功能，但性能上仍有部分损耗：如果 T 是值类型，使用 object.Equals() 比较的过程中会发生装箱！EqualityComparer<T>.Default.Equals() 方法便应运而生。
EqualityComparer<T>.Default 属性会返回一个通用的相等比较器，替代静态的 object.Equals 方法。它会首先检查 T 是否实现了 IEquatable<T>，实现了则直接调用实现类，从而避免装箱开销。
如下代码改为了使用 EqualityComparer<T>.Default.Equals()，避免了装箱：
class Test<T>{ T _value; public void SetValue(T newValue) { if (!EqualityComparer<T>.Default.Equals(newValue, _value)) { _value = newValue; OnValueChanged(); } } protected virtual void OnValueChanged() { }}

Info
更多内容，请参考第7章集合 - hihaojie - 博客园 7.7.1 IEqualityComparer 和 EqualityComparer

6. is 运算符

is 运算符可用的模式有三种：常量模式、类型模式、var模式。这里我们讲解常量模式涉及的相等比较。
6.1 常量模式

使用 is 与常量比较相等时，有两种情况：

整型表达式：使用 == 进行比较
其他类型：使用 object.Equals() 静态方法进行比较。

6.1.1 整型表达式

整型表达式会转为使用 == 运算符进行比较。以如下代码为例，反编译生成的程序可以看到，它实际使用 == 进行比较：
long x = 10L;if (x is 10){ Console.WriteLine("x is 10");}long x = 10L;if (x == 10){ Console.WriteLine("x is 10");}6.1.2 其他类型

我们可用通过 is 判断变量是否为 null，此时相等比较使用的是 object.Equals() 方法：

检查是否为 null，如下例所示：

if (input is null){ return;}将表达式与 null 匹配时，编译器保证不会调用用户重载的 == 或 != 运算符。

可使用否定模式执行非 null 检查，如下例所示：

if (result is not null){ Console.WriteLine(result.ToString());}

Question
请思考如下代码，会输出什么内容？符合上述情况中的哪种？
Match(10L);static void Match(object input){ if (input is 10) Console.WriteLine("input 是整型类型的 10"); else Console.WriteLine("Input 不是整型类型的 10");}答案是第二种。在传入 10L 的值时发生了装箱，因此 input is 10 实际调用了 object.Equals() 方法比较相等，显然，object.Equals(10L, 10) 的结果是 False

6.2 列表模式

从 C#11 开始，可以使用列表模式来匹配列表或数组的元素。以下代码检查数组中处于预期位置的整数值：

int[] empty = [];int[] one = [1];int[] odd = [1, 3, 5];int[] even = [2, 4, 6];int[] fib = [1, 1, 2, 3, 5];Console.WriteLine(odd is [1, _, 2, ..]); // falseConsole.WriteLine(fib is [1, _, 2, ..]); // trueConsole.WriteLine(fib is [_, 1, 2, 3, ..]); // trueConsole.WriteLine(fib is [.., 1, 2, 3, _ ]); // trueConsole.WriteLine(even is [2, _, 6]); // trueConsole.WriteLine(even is [2, .., 6]); // trueConsole.WriteLine(odd is [.., 3, 5]); // trueConsole.WriteLine(even is [.., 3, 5]); // falseConsole.WriteLine(fib is [.., 3, 5]); // true

Info
更多内容，请参考is 运算符 - 将表达式与类型或常量模式匹配 - C# reference | Microsoft Learn 、《深入理解C#》第4版 12.4.1 常量模式、你不知道的C#冷知识（其二）_哔哩哔哩_bilibili

7. IEqualityComparer<T> 和 EqualityComparer<T>

提到相等比较必然会谈到哈希表。前文我们也提到了 Equals() 方法对哈希表的重要性。如果你有仔细观察过 HashSet<T> 和 Dictionary<TKey, TValue> 的构造方法，会发现它们都有接收 IEqualityComparer<T> 接口实例的构造器：
public HashSet([Nullable(IEqualityComparer<T>)public Dictionary(IEqualityComparer<TKey>)我们从哈希表的原理可知：存放元素时，哈希表通过 GetHashCode() 方法获取哈希值，将元素存放至相应位置；查找元素时，哈希表通过 GetHashCode() 方法获取哈希值，获取元素，再调用 Equals() 方法确认是否为要查找的元素。
有时我们想自定义哈希表的存放、查找规则，便需要使用 IEqualityComparer<T> 接口。该接口定义如下：
public interface IEqualityComparer<in T>{ bool Equals(T x, T y); int GetHashCode(T obj);}接下来我们演示一下该接口的使用。我们假设有 Person 类：
class Person{ public string Name { get; set; } public int Age { get; set; }}我们希望只要 Person 实例的 Name 和 Age 相同，就认为是同一个“人”，下面这段代码显然不符合要求，它会输出 False：
HashSet<Person> set = new HashSet<Person>();Person person1 = new Person{ Name = "John", Age = 18};set.Add(person1);Person person2 = new Person{ Name = "John", Age = 18};Console.WriteLine(set.Contains(person2));如果 Person 是第三方类库提供的，我们无法覆写它的 Equals() 方法和 GetHashCode() 方法，这时候我们可以自定义一个类，实现 IEqualityComparer<T> 接口：
class PersonEqualityComParer : IEqualityComparer<Person>{ public bool Equals(Person? x, Person? y) {       if (x is null || y is null)       {          return false;       }       if (x.Name != y.Name)       {          return false;       }       if (x.Age != y.Age)       {          return false;       }       return true; } public int GetHashCode([DisallowNull] Person obj) {       int hash = 17;       hash = hash * 31 + obj.Name.GetHashCode();       hash = hash * 31 + obj.Age.GetHashCode();       return hash; }}将 PersonEqualityComParer 实例传入 HashSet 的构造函数，我们便可以自定义哈希表的匹配方式，如下代码将输出 True：
HashSet<Person> set = new HashSet<Person>(new PersonEqualityComParer());Person person1 = new Person{ Name = "John", Age = 18};set.Add(person1);Person person2 = new Person{ Name = "John", Age = 18};Console.WriteLine(set.Contains(person2));‍
前面讲的一大堆都是关于 IEqualityComparer<T> 接口的，那 EqualityComparer<T> 又是做什么的呢？这就不得不提到非泛型版本的 IEqualityComparer 接口。如果你观察过 HashTable 集合类型（它是非泛型的），会发现它的构造器会可以接受 IEqualityComparer 接口实例：
public Hashtable(IEqualityComparer)IEqualityComparer 接口的定义和 IEqualityComparer<T> 高度相似：
public interface IEqualityComparer{ new bool Equals(object x, object y); int GetHashCode(object obj);}如果我们想让前面实现的 PersonEqualityComParer 同时可用于泛型、非泛型哈希表，这两个接口都需要实现，显然很麻烦。为此 C# 提供了 EqualityComparer<T> 抽象类，比较器只需实现一次 Equals() 方法、一次 GetHashCode() 方法便可用于泛型、非泛型两种情况：
// 可同时用于泛型、非泛型哈希表：HashSet<Person> set = new HashSet<Person>(new PersonEqualityComParer());Hashtable table = new Hashtable(new PersonEqualityComParer());class PersonEqualityComParer : EqualityComparer<Person>{ public override bool Equals(Person? x, Person? y) {       if (x is null || y is null)       {          return false;       }       if (x.Name != y.Name)       {          return false;       }       if (x.Age != y.Age)       {          return false;       }       return true; } public override int GetHashCode([DisallowNull] Person obj) {       int hash = 17;       hash = hash * 31 + obj.Name.GetHashCode();       hash = hash * 31 + obj.Age.GetHashCode();       return hash; }}8. 一些特殊的预定义类型的相等比较

8.1 元组（ValueTuple）

元组使用 Equals() 方法和使用 == 运算符比较并不相同。以 ValueTuple<T1, T2> 为例，查看它的源码可以发现，它的 Equals() 方法通过调用 EqualityComparer<T>.Default.Equals() 实现相等比较：
public bool Equals(ValueTuple<T1, T2> other){ return EqualityComparer<T1>.Default.Equals(Item1, other.Item1)       && EqualityComparer<T2>.Default.Equals(Item2, other.Item2);}如果你在源码中找不到 == 运算符的重载！但是自 C#7.3 之后，又能使用 ==、!= 运算符进行相等判断。
这是因为编译器就为元组类型提供了元组 == 和 != 的实现。编译器将 == 运算符扩展到元素级别的 == 操作。它会对每一对元素值执行 == 操作（!= 运算符同理）。代码示例如下：
var t1 = (x: "x", y: "y", z: 1); // 比较时不考虑var t2 = ("x", "y", 1);          // 元素名称不同Console.WriteLine(t1 == t2);Console.WriteLine(t1.Item1 == t2.Item1 && //                t1.Item2 == t2.Item2 && // 编译器生成的                t1.Item3 == t2.Item3); // 等价代码Console.WriteLine(t1 != t2);Console.WriteLine(t1.Item1 != t2.Item1 || //                t1.Item2 != t2.Item2 || // 编译器生成的                t1.Item3 != t2.Item3); // 等价代码这也要求元组中的类型必须能通过 ==、!= 进行比较，以如下代码为例，因 Person 结构体未重载 ==、!= 运算符，如下代码编译器报错 CS0019：
var tuple1 = (1, p1);var tuple2 = (1, p2);Console.WriteLine(tuple1 == tuple2);struct Person{ public int Age; public string Name;}8.2 匿名类型

匿名类型本质上是引用类型，因此它可以使用 == 运算符进行比较，它比较的是引用是否相等。它的 Equals() 方法则会比较所有元素是否相同（通过  EqualityComparer<T>.Default.Equals() 方法），考虑到它常用于 LINQ，Equals() 比较所有元素是否相同的行为就非常合理了。
两个匿名类型实例相同的前提是：类型相同、属性名称相同、属性顺序相同。以如下代码为例，它将输出 True、False、False、False
var value1 = new { Name = "John", Age = 18 };var value2 = new { Name = "John", Age = 18 };var value3 = new { Age = 18, Name = "John" };var value4 = new { Title = "John", Level = 18 };Console.WriteLine(value1.Equals(value2));Console.WriteLine(value1.Equals(value3));Console.WriteLine(value1.Equals(value4));Console.WriteLine(value1 == value2);

Tips
为什么说“考虑到匿名类型常用于 LINQ，Equals() 比较所有元素是否相同的行为就非常合理了”？
以如下代码为例，我们通过匿名类型在一个查询中基于多个键进行连接查询，这就用到了匿名类型的 Equals() 方法：
from s in stringPropsjoin b in builderProps on new { s.Name, s.PropertyType } equals new { b.Name, b.PropertyType }

9. 内部元素结构化相等比较

有些类型的数据我们需要对内部元素进行相等比较，如数组、元组。此时可用通过 IStructuralEquatable 接口的 Equals() 方法执行该操作。数组和元组实现了该接口。下面是两个简单用例，分别演示了对数组、元组内部元素的相等比较：
int[] nums1 = [1, 2, 3, 4, 5];int[] nums2 = [1, 2, 3, 4, 5];Console.WriteLine(nums1.Equals(nums2));IStructuralEquatable se = (IStructuralEquatable)nums1;Console.WriteLine(se.Equals(nums2, EqualityComparer<int>.Default));var t1 = (1, "foo");var t2 = (1, "FOO");IStructuralEquatable se1 = t1;Console.WriteLine(se1.Equals(t2, StringComparer.InvariantCultureIgnoreCase));

Info
更多内容，另见第7章集合 - hihaojie - 博客园 7.7.4 IStructuralEquatable 和 IStructualComparable

<hr>参考文献：

《框架设计指南：构建可复用.NET库的约定、惯例与模式》第三版
《C#7.0 核心技术指南》
《深入解析C#》第四版

Info
前两本书的部分内容，可参阅我的阅读笔记阅读笔记目录汇总 - hihaojie - 博客园

‍
‍