位置：文档库 > C#(.NET) > C# 中的 == 和 equals()区别

C# 中的 == 和 equals()区别

轻车简从上传于 2022-12-10 19:35

在C#编程中，`==`运算符和`Equals()`方法是判断对象相等性的重要工具，但它们的底层机制、使用场景和行为差异常常让开发者感到困惑。本文将从值类型与引用类型的区别、运算符重载、`Equals()`方法的重写规则、`object`类的默认实现等多个维度，深入剖析两者的核心差异，并通过实际代码示例展示如何正确使用它们。

一、基础概念：值类型与引用类型的相等性

在C#中，数据类型分为值类型（`struct`）和引用类型（`class`）。这种分类直接影响了`==`和`Equals()`的行为。

对于值类型（如`int`、`float`、自定义结构体），`==`默认比较的是值是否相等。例如：

int a = 10;
int b = 10;
bool result1 = (a == b); // true，比较值

而引用类型（如`string`、自定义类）的`==`行为取决于是否重载了运算符。若未重载，则默认比较引用地址（是否指向同一对象）：

class Person { public string Name; }
Person p1 = new Person { Name = "Alice" };
Person p2 = new Person { Name = "Alice" };
bool result2 = (p1 == p2); // false，比较引用地址

相比之下，`Equals()`方法的行为更复杂。对于值类型，`object.Equals()`默认也是比较值（通过反射实现），但性能较低；对于引用类型，`object.Equals()`默认比较引用地址，但可通过重写改变行为。

二、`==`运算符的底层机制

`==`是静态运算符，其行为由编译器根据操作数类型决定。对于内置类型（如`int`、`string`），`==`已被重载为值比较：

string s1 = "hello";
string s2 = "hello";
bool result3 = (s1 == s2); // true，因为string重载了==

对于自定义类型，若未重载`==`，则比较引用地址。重载`==`需同时重载`!=`，并遵循以下规则：

使用`static`修饰符
参数类型为当前类或可空版本
通常需检查参数是否为`null`

public class Point {
    public int X, Y;
    public static bool operator ==(Point a, Point b) {
        if (object.ReferenceEquals(a, b)) return true;
        if (a is null || b is null) return false;
        return a.X == b.X && a.Y == b.Y;
    }
    public static bool operator !=(Point a, Point b) => !(a == b);
    // 需重写Equals和GetHashCode以保持一致性
    public override bool Equals(object obj) {
        if (obj is not Point other) return false;
        return X == other.X && Y == other.Y;
    }
    public override int GetHashCode() => X.GetHashCode() ^ Y.GetHashCode();
}

三、`Equals()`方法的继承与重写

`Equals()`是`object`类的虚方法，默认实现为引用比较。重写时需遵循以下原则：

自反性：`x.Equals(x)`必须返回`true`
对称性：若`x.Equals(y)`为`true`，则`y.Equals(x)`也为`true`
传递性：若`x.Equals(y)`和`y.Equals(z)`为`true`，则`x.Equals(z)`也为`true`
一致性：多次调用`x.Equals(y)`应返回相同结果（前提是对象未修改）
非空性：`x.Equals(null)`必须返回`false`

标准重写模板如下：

public class Product {
    public string Id;
    public override bool Equals(object obj) {
        // 1. 检查是否为同一引用
        if (object.ReferenceEquals(this, obj)) return true;
        // 2. 检查是否为null或类型不匹配
        if (obj is null || GetType() != obj.GetType()) return false;
        // 3. 类型转换并比较字段
        Product other = (Product)obj;
        return Id == other.Id;
    }
    public override int GetHashCode() => Id?.GetHashCode() ?? 0;
}

四、`IEquatable`接口：类型安全的比较

为避免装箱（boxing）和类型检查开销，可实现`IEquatable`接口：

public class Order : IEquatable {
    public int OrderId;
    public bool Equals(Order other) {
        if (other is null) return false;
        return OrderId == other.OrderId;
    }
    public override bool Equals(object obj) => Equals(obj as Order);
    public override int GetHashCode() => OrderId.GetHashCode();
}

优势：

消除运行时类型检查
避免值类型的装箱
提供强类型比较方法

五、字符串的特殊处理

`string`类型同时重载了`==`和重写了`Equals()`，均实现值比较：

string s3 = new string(new char[] { 'h', 'i' });
string s4 = "hi";
bool result4 = (s3 == s4); // true
bool result5 = s3.Equals(s4); // true

但`string.Equals()`提供了额外重载，支持字符串比较选项：

string cultureSensitive = "straße";
string invariant = "strasse";
bool result6 = cultureSensitive.Equals(invariant, StringComparison.InvariantCultureIgnoreCase); // true

六、集合中的相等性判断

字典（`Dictionary`）和哈希集合（`HashSet`）依赖`GetHashCode()`和`Equals()`。若未正确重写，可能导致以下问题：

var set = new HashSet();
set.Add(new Person { Name = "Bob" });
bool contains = set.Contains(new Person { Name = "Bob" }); // false（若未重写Equals/GetHashCode）

正确实现示例：

public class Employee : IEquatable {
    public int Id;
    public string Name;
    public bool Equals(Employee other) {
        if (other is null) return false;
        return Id == other.Id && Name == other.Name;
    }
    public override bool Equals(object obj) => Equals(obj as Employee);
    public override int GetHashCode() => HashCode.Combine(Id, Name);
}

七、性能优化建议

1. **值类型比较**：优先使用`==`，避免`Equals()`的反射开销

2. **引用类型比较**：

若需值比较，重写`Equals()`和`GetHashCode()`
若需引用比较，直接使用`==`（未重载时）

3. **哈希计算**：使用`HashCode.Combine()`（.NET Core 3.0+）替代手动异或：

public override int GetHashCode() => HashCode.Combine(Field1, Field2, Field3);

八、常见误区与解决方案

误区1：认为`==`总是比较值

解决方案：明确类型分类，对自定义引用类型重载`==`或重写`Equals()`。

误区2：重写`Equals()`但不重写`GetHashCode()`

解决方案：始终同时重写两者，且保持相同字段参与计算。

误区3：在`Equals()`中使用`is`进行类型检查

解决方案：使用`GetType() == obj.GetType()`确保严格类型匹配（除非有意支持派生类比较）。

九、最佳实践总结

对于值类型，默认使用`==`即可
对于引用类型：

若需值语义，重写`Equals()`、`GetHashCode()`并实现`IEquatable`
若需引用语义，直接使用`==`（或`object.ReferenceEquals()`）

在集合中使用自定义类型时，必须实现值语义

始终遵循相等性契约（自反性、对称性等）

关键词：C#、==运算符、Equals方法、值类型、引用类型、运算符重载、IEquatable接口、GetHashCode、相等性契约、字符串比较

简介：本文详细解析了C#中`==`运算符与`Equals()`方法的区别，涵盖值类型与引用类型的比较机制、运算符重载规则、`Equals()`的重写原则、`IEquatable`接口的使用场景，以及字符串和集合中的特殊处理。通过代码示例和性能优化建议，帮助开发者正确实现对象相等性判断，避免常见误区。

立即下载