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_0000: nop
IL_0001: ldc.i4.1
IL_0002: stloc.0
IL_0003: ldc.i4.2
IL_0004: stloc.1
IL_0005: ldloc.0
IL_0006: ldloc.1
IL_0007: ceq
IL_0009: stloc.2
decimal num = 1m;
decimal num2 = 2m;
bool flag = num == num2;
IL_0000: nop
IL_0001: ldsfld valuetype [System.Runtime]System.Decimal [System.Runtime]System.Decimal::One
IL_0006: stloc.0
IL_0007: ldloca.s 1
IL_0009: ldc.i4.2
IL_000a: call instance void [System.Runtime]System.Decimal::.ctor(int32)
IL_000f: ldloc.0
IL_0010: ldloc.1
IL_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章 使用準則給出了建議：
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() 方法：
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, ..]);
Console.WriteLine(fib is [1, _, 2, ..]);
Console.WriteLine(fib is [_, 1, 2, 3, ..]);
Console.WriteLine(fib is [.., 1, 2, 3, _ ]);
Console.WriteLine(even is [2, _, 6]);
Console.WriteLine(even is [2, .., 6]);
Console.WriteLine(odd is [.., 3, 5]);
Console.WriteLine(even is [.., 3, 5]);
Console.WriteLine(fib is [.., 3, 5]);
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 stringProps
join 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));
轉自https://www.cnblogs.com/hihaojie/p/18761086/c-bk2f6
該文章在 2025/3/10 16:03:34 編輯過
400 186 1886
