位置：文档库 > C#(.NET) > 一次性搞懂C#中的==、Equals()和ReferenceEquals()的区别

一次性搞懂C#中的==、Equals()和ReferenceEquals()的区别

JAMStacker 上传于 2024-07-31 02:09

### 一次性搞懂C#中的==、Equals()和ReferenceEquals()的区别

在C#编程中，比较两个对象是否相等是常见的操作，但开发者常常会被`==`运算符、`Equals()`方法以及`ReferenceEquals()`方法之间的区别所困扰。这三种方式虽然都用于比较，但它们的实现逻辑、应用场景和结果可能完全不同。本文将通过理论解析、代码示例和实际应用场景，帮助你彻底掌握它们的区别与联系。

一、基础概念解析

1. == 运算符

`==`是C#中的运算符，用于比较两个对象是否“相等”。但它的行为高度依赖于操作数的类型：

对于值类型（如`int`、`struct`），`==`比较的是值是否相同。
对于引用类型（如`class`），`==`的默认行为是比较引用地址（即是否指向同一个对象），但某些类（如`string`）会重写`==`以比较值。

2. Equals() 方法

`Equals()`是`System.Object`的虚方法，所有类都继承它。默认实现（引用类型）也是比较引用地址，但许多内置类型（如`string`、`int`）和自定义类会重写它以实现值比较。

3. ReferenceEquals() 方法

`ReferenceEquals()`是`System.Object`的静态方法，始终比较引用地址，无论类型是否重写了`Equals()`或`==`。它用于明确判断两个对象是否指向同一内存地址。

二、值类型与引用类型的行为差异

1. 值类型的比较

对于值类型（如`int`、`struct`），`==`和`Equals()`的行为一致，均比较值：

int a = 10;
int b = 10;
Console.WriteLine(a == b);      // True
Console.WriteLine(a.Equals(b)); // True

但若自定义`struct`未重写`Equals()`，默认使用反射比较字段，性能较差。建议重写`Equals()`和`GetHashCode()`：

public struct Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y) => (X, Y) = (x, y);

    public override bool Equals(object obj)
    {
        return obj is Point other && X == other.X && Y == other.Y;
    }

    public override int GetHashCode() => (X, Y).GetHashCode();

    public static bool operator ==(Point left, Point right) => left.Equals(right);
    public static bool operator !=(Point left, Point right) => !(left == right);
}

Point p1 = new Point(1, 2);
Point p2 = new Point(1, 2);
Console.WriteLine(p1 == p2);      // True（需重写==）
Console.WriteLine(p1.Equals(p2)); // True

2. 引用类型的比较

对于引用类型，默认情况下`==`和`Equals()`均比较引用地址：

object obj1 = new object();
object obj2 = new object();
Console.WriteLine(obj1 == obj2);      // False
Console.WriteLine(obj1.Equals(obj2)); // False
Console.WriteLine(ReferenceEquals(obj1, obj2)); // False

但某些类（如`string`）重写了`==`和`Equals()`以比较值：

string s1 = "hello";
string s2 = "hello";
Console.WriteLine(s1 == s2);      // True（重写==）
Console.WriteLine(s1.Equals(s2)); // True（重写Equals）
Console.WriteLine(ReferenceEquals(s1, s2)); // 可能True（字符串驻留）

三、关键区别总结

特性	== 运算符	Equals()	ReferenceEquals()
是否可重写	是（通过运算符重载）	是（虚方法）	否（静态方法）
默认行为（引用类型）	比较引用地址	比较引用地址	始终比较引用地址
值类型行为	比较值	比较值（若重写）	不适用（装箱后比较引用）
null处理	安全（如`null == obj`不会抛出异常）	调用`null.Equals()`会抛出异常	安全（`ReferenceEquals(null, obj)`返回`false`）

四、实际应用场景

1. 判断对象是否为同一实例

使用`ReferenceEquals()`确保比较引用地址：

object a = new object();
object b = a;
Console.WriteLine(ReferenceEquals(a, b)); // True

2. 值比较需求

重写`Equals()`和`==`以实现自定义值比较：

public class Person
{
    public string Name { get; }
    public int Age { get; }

    public Person(string name, int age) => (Name, Age) = (name, age);

    public override bool Equals(object obj)
    {
        return obj is Person other && Name == other.Name && Age == other.Age;
    }

    public override int GetHashCode() => (Name, Age).GetHashCode();

    public static bool operator ==(Person left, Person right) => left.Equals(right);
    public static bool operator !=(Person left, Person right) => !(left == right);
}

var p1 = new Person("Alice", 30);
var p2 = new Person("Alice", 30);
Console.WriteLine(p1 == p2); // True

3. 避免空引用异常

使用`==`比`Equals()`更安全（避免`null.Equals()`）：

string str = null;
Console.WriteLine(str == "test"); // False
Console.WriteLine(str.Equals("test")); // 抛出NullReferenceException

五、最佳实践建议

重写`Equals()`时同步重写`GetHashCode()`：否则在哈希集合（如`Dictionary`）中可能行为异常。
自定义类型重写`==`和`!=`运算符：保持与`Equals()`逻辑一致。
比较引用时显式使用`ReferenceEquals()`：避免因类型重写导致的混淆。
优先使用`==`进行值比较：除非明确需要引用比较。

六、常见陷阱与解决方案

陷阱1：字符串比较的驻留问题

字符串字面量可能被驻留（同一地址），但动态创建的字符串不会：

string s1 = "hello";
string s2 = "hello";
string s3 = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });

Console.WriteLine(ReferenceEquals(s1, s2)); // True（驻留）
Console.WriteLine(ReferenceEquals(s1, s3)); // False
Console.WriteLine(s1 == s3); // True（值比较）

解决方案：始终用`==`比较字符串值，用`ReferenceEquals()`判断是否同一实例。

陷阱2：自定义类未重写`Equals()`

默认的`Equals()`基于引用，可能导致意外结果：

class Car { }

var car1 = new Car();
var car2 = new Car();
Console.WriteLine(car1.Equals(car2)); // False（引用比较）

解决方案：根据需求重写`Equals()`实现值比较。

陷阱3：可空类型的比较

可空类型需注意`null`和`HasValue`：

int? a = null;
int? b = 10;
Console.WriteLine(a == b); // False
Console.WriteLine(a.Equals(b)); // 抛出NullReferenceException（若a为null）

解决方案：使用`==`或显式检查`null`。

七、性能考量

`ReferenceEquals()`最快：直接比较引用地址。
`==`和`Equals()`性能取决于实现：值类型比较通常快于引用类型的值比较（后者可能涉及字段遍历）。
避免在循环中频繁调用`Equals()`：若类型未重写且为引用类型，性能等同于`ReferenceEquals()`，但若重写则可能较慢。

### 关键词

C#、==运算符、Equals()方法、ReferenceEquals()方法、值类型、引用类型、运算符重载、虚方法、静态方法、引用比较、值比较、字符串驻留、NullReferenceException、最佳实践

### 简介

本文详细解析了C#中`==`、`Equals()`和`ReferenceEquals()`的区别，涵盖值类型与引用类型的行为差异、重写方法的影响、实际应用场景及最佳实践。通过代码示例和陷阱分析，帮助开发者正确选择比较方式，避免常见错误。

立即下载