通过

System.Object.Equals 方法

  • 项目

本文提供了此 API 参考文档的补充说明。

本文与该方法相关 Object.Equals(Object) 。

当前实例与 obj 参数之间的比较类型取决于当前实例是引用类型还是值类型。

  • 如果当前实例是引用类型，则 Equals(Object) 方法测试引用相等性，对方法的调用 Equals(Object) 等效于对方法的 ReferenceEquals 调用。 引用相等意味着比较的对象变量引用同一对象。 下面的示例演示了此类比较的结果。 它定义一个 Person 类，该类是引用类型，并调用 Person 类构造函数来实例化两个新 Person 对象， person1a 以及 person2具有相同值的类。 它还分配给person1a另一个对象变量。 person1b 如示例中的输出所示， person1a 并且 person1b 相等，因为它们引用了同一对象。 但是， person1a 虽然它们具有相同的值，但 person2 并不相等。

    using System;

// Define a reference type that does not override Equals.
public class Person
{
   private string personName;

   public Person(string name)
   {
      this.personName = name;
   }

   public override string ToString()
   {
      return this.personName;
   }
}

public class Example1
{
   public static void Main()
   {
      Person person1a = new Person("John");
      Person person1b = person1a;
      Person person2 = new Person(person1a.ToString());

      Console.WriteLine("Calling Equals:");
      Console.WriteLine("person1a and person1b: {0}", person1a.Equals(person1b));
      Console.WriteLine("person1a and person2: {0}", person1a.Equals(person2));

      Console.WriteLine("\nCasting to an Object and calling Equals:");
      Console.WriteLine("person1a and person1b: {0}", ((object) person1a).Equals((object) person1b));
      Console.WriteLine("person1a and person2: {0}", ((object) person1a).Equals((object) person2));
   }
}
// The example displays the following output:
//       person1a and person1b: True
//       person1a and person2: False
//
//       Casting to an Object and calling Equals:
//       person1a and person1b: True
//       person1a and person2: False

    // Define a reference type that does not override Equals.
type Person(name) =
    override _.ToString() =
        name

let person1a = Person "John"
let person1b = person1a
let person2 = Person(string person1a)

printfn "Calling Equals:"
printfn $"person1a and person1b: {person1a.Equals person1b}"
printfn $"person1a and person2: {person1a.Equals person2}"

printfn "\nCasting to an Object and calling Equals:"
printfn $"person1a and person1b: {(person1a :> obj).Equals(person1b :> obj)}"
printfn $"person1a and person2: {(person1a :> obj).Equals(person2 :> obj)}"
// The example displays the following output:
//       person1a and person1b: True
//       person1a and person2: False
//
//       Casting to an Object and calling Equals:
//       person1a and person1b: True
//       person1a and person2: False

    ' Define a reference type that does not override Equals.
Public Class Person1
    Private personName As String

    Public Sub New(name As String)
        Me.personName = name
    End Sub

    Public Overrides Function ToString() As String
        Return Me.personName
    End Function
End Class

Module Example0
    Public Sub Main()
        Dim person1a As New Person1("John")
        Dim person1b As Person1 = person1a
        Dim person2 As New Person1(person1a.ToString())

        Console.WriteLine("Calling Equals:")
        Console.WriteLine("person1a and person1b: {0}", person1a.Equals(person1b))
        Console.WriteLine("person1a and person2: {0}", person1a.Equals(person2))
        Console.WriteLine()

        Console.WriteLine("Casting to an Object and calling Equals:")
        Console.WriteLine("person1a and person1b: {0}", CObj(person1a).Equals(CObj(person1b)))
        Console.WriteLine("person1a and person2: {0}", CObj(person1a).Equals(CObj(person2)))
    End Sub
End Module
' The example displays the following output:
'       Calling Equals:
'       person1a and person1b: True
'       person1a and person2: False
'       
'       Casting to an Object and calling Equals:
'       person1a and person1b: True
'       person1a and person2: False

  • 如果当前实例是值类型，则 Equals(Object) 方法将测试值相等性。 值相等性表示以下内容：

    • 这两个对象的类型相同。 如以下示例所示， Byte 值为 12 的对象不等于值为 12 的对象，因为两个 Int32 对象具有不同的运行时类型。

      byte value1 = 12;
int value2 = 12;

object object1 = value1;
object object2 = value2;

Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                  object1, object1.GetType().Name,
                  object2, object2.GetType().Name,
                  object1.Equals(object2));

// The example displays the following output:
//        12 (Byte) = 12 (Int32): False

      let value1 = 12uy
let value2 = 12

let object1 = value1 :> obj
let object2 = value2 :> obj

printfn $"{object1} ({object1.GetType().Name}) = {object2} ({object2.GetType().Name}): {object1.Equals object2}"

// The example displays the following output:
//        12 (Byte) = 12 (Int32): False

      Module Example2
    Public Sub Main()
        Dim value1 As Byte = 12
        Dim value2 As Integer = 12

        Dim object1 As Object = value1
        Dim object2 As Object = value2

        Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                        object1, object1.GetType().Name,
                        object2, object2.GetType().Name,
                        object1.Equals(object2))
    End Sub
End Module
' The example displays the following output:
'       12 (Byte) = 12 (Int32): False

    • 两个对象的公共字段和私有字段的值相等。 以下示例测试值相等性。 它定义一个 Person 结构，它是一个值类型，并调用 Person 类构造函数来实例化两个新 Person 对象， person1 并且 person2具有相同的值。 如示例中的输出所示，尽管这两个对象变量引用不同的对象， person1 并且 person2 相等，因为它们具有与专用 personName 字段相同的值。

      using System;

// Define a value type that does not override Equals.
public struct Person3
{
   private string personName;

   public Person3(string name)
   {
      this.personName = name;
   }

   public override string ToString()
   {
      return this.personName;
   }
}

public struct Example3
{
   public static void Main()
   {
      Person3 person1 = new Person3("John");
      Person3 person2 = new Person3("John");

      Console.WriteLine("Calling Equals:");
      Console.WriteLine(person1.Equals(person2));

      Console.WriteLine("\nCasting to an Object and calling Equals:");
      Console.WriteLine(((object) person1).Equals((object) person2));
   }
}
// The example displays the following output:
//       Calling Equals:
//       True
//
//       Casting to an Object and calling Equals:
//       True

      // Define a value type that does not override Equals.
[<Struct>]
type Person(personName: string) =
    override _.ToString() =
        personName

let person1 = Person "John"
let person2 = Person "John"

printfn "Calling Equals:"
printfn $"{person1.Equals person2}"

printfn $"\nCasting to an Object and calling Equals:"
printfn $"{(person1 :> obj).Equals(person2 :> obj)}"
// The example displays the following output:
//       Calling Equals:
//       True
//
//       Casting to an Object and calling Equals:
//       True

      ' Define a value type that does not override Equals.
Public Structure Person4
    Private personName As String

    Public Sub New(name As String)
        Me.personName = name
    End Sub

    Public Overrides Function ToString() As String
        Return Me.personName
    End Function
End Structure

Module Example4
    Public Sub Main()
        Dim p1 As New Person4("John")
        Dim p2 As New Person4("John")

        Console.WriteLine("Calling Equals:")
        Console.WriteLine(p1.Equals(p2))
        Console.WriteLine()

        Console.WriteLine("Casting to an Object and calling Equals:")
        Console.WriteLine(CObj(p1).Equals(p2))
    End Sub
End Module
' The example displays the following output:
'       Calling Equals:
'       True
'       
'       Casting to an Object and calling Equals:
'       True

由于该 Object 类是 .NET 中所有类型的基类，因此该方法 Object.Equals(Object) 为所有其他类型提供默认相等比较。 但是，类型通常重写 Equals 方法来实现值相等性。 有关详细信息，请参阅“调用方说明”和“继承者备注”部分。

Windows 运行时说明

在Windows 运行时中对类调用Equals(Object)方法重载时，它会为不重写Equals(Object)的类提供默认行为。 这是 .NET 为Windows 运行时提供的支持的一部分（请参阅 Windows 应用商店应用的 .NET 支持和Windows 运行时）。 Windows 运行时中的类不会继承Object，当前不实现方法Equals(Object)。 但是，在 C# 或 Visual Basic 代码中使用它们时，它们似乎具有ToStringEquals(Object)和GetHashCode方法，.NET 为这些方法提供了默认行为。

注意

Windows 运行时用 C# 或 Visual Basic 编写的类可以替代Equals(Object)方法重载。

呼叫者说明

派生类经常重写 Object.Equals(Object) 方法以实现值相等性。 此外，类型还经常通过实现IEquatable<T>接口向Equals方法提供额外的强类型重载。 调用 Equals 方法以测试相等性时，应知道当前实例是否重写 Object.Equals 并了解如何解析对方法的特定调用 Equals 。 否则，可能会对与预期值不同的相等性执行测试，并且该方法可能会返回意外值。

下面的示例进行了这方面的演示。 它实例化三 StringBuilder 个具有相同字符串的对象，然后对方法进行四次调用 Equals 。 第一个方法调用返回 true，其余三个返回 false。

using System;
using System.Text;

public class Example5
{
   public static void Main()
   {
      StringBuilder sb1 = new StringBuilder("building a string...");
      StringBuilder sb2 = new StringBuilder("building a string...");

      Console.WriteLine("sb1.Equals(sb2): {0}", sb1.Equals(sb2));
      Console.WriteLine("((Object) sb1).Equals(sb2): {0}",
                        ((Object) sb1).Equals(sb2));
      Console.WriteLine("Object.Equals(sb1, sb2): {0}",
                        Object.Equals(sb1, sb2));

      Object sb3 = new StringBuilder("building a string...");
      Console.WriteLine("\nsb3.Equals(sb2): {0}", sb3.Equals(sb2));
   }
}
// The example displays the following output:
//       sb1.Equals(sb2): True
//       ((Object) sb1).Equals(sb2): False
//       Object.Equals(sb1, sb2): False
//
//       sb3.Equals(sb2): False

open System
open System.Text

let sb1 = StringBuilder "building a string..."
let sb2 = StringBuilder "building a string..."

printfn $"sb1.Equals(sb2): {sb1.Equals sb2}"
printfn $"((Object) sb1).Equals(sb2): {(sb1 :> obj).Equals sb2}"
                  
printfn $"Object.Equals(sb1, sb2): {Object.Equals(sb1, sb2)}"

let sb3 = StringBuilder "building a string..."
printfn $"\nsb3.Equals(sb2): {sb3.Equals sb2}"
// The example displays the following output:
//       sb1.Equals(sb2): True
//       ((Object) sb1).Equals(sb2): False
//       Object.Equals(sb1, sb2): False
//
//       sb3.Equals(sb2): False

Imports System.Text

Module Example5
    Public Sub Main()
        Dim sb1 As New StringBuilder("building a string...")
        Dim sb2 As New StringBuilder("building a string...")

        Console.WriteLine("sb1.Equals(sb2): {0}", sb1.Equals(sb2))
        Console.WriteLine("CObj(sb1).Equals(sb2): {0}",
                        CObj(sb1).Equals(sb2))
        Console.WriteLine("Object.Equals(sb1, sb2): {0}",
                        Object.Equals(sb1, sb2))

        Console.WriteLine()
        Dim sb3 As Object = New StringBuilder("building a string...")
        Console.WriteLine("sb3.Equals(sb2): {0}", sb3.Equals(sb2))
    End Sub
End Module
' The example displays the following output:
'       sb1.Equals(sb2): True
'       CObj(sb1).Equals(sb2): False
'       Object.Equals(sb1, sb2): False
'
'       sb3.Equals(sb2): False

在第一种情况下，将调用测试值相等性的强类型 StringBuilder.Equals(StringBuilder) 方法重载。 由于分配给这两 StringBuilder 个对象的字符串相等，因此该方法返回 true。 但是， StringBuilder 不重写 Object.Equals(Object)。 因此，当对象StringBuilder被强制转换为某个Object对象时，当实例被赋给类型的Object变量时，以及当方法传递两StringBuilder个StringBuilder对象时Object.Equals(Object, Object)，将调用默认Object.Equals(Object)方法。 由于 StringBuilder 是引用类型，这等效于将两 StringBuilder 个对象传递给 ReferenceEquals 该方法。 尽管所有三 StringBuilder 个对象都包含相同的字符串，但它们引用三个不同的对象。 因此，这三个方法调用将返回 false。

可以通过调用 ReferenceEquals 该方法，将当前对象与另一个对象进行比较，以保持引用相等性。 在 Visual Basic 中，也可以使用is关键字 (keyword)（例如If Me Is otherObject Then ...）。

继承者的说明

定义自己的类型时，该类型将继承其基类型方法定义的 Equals 功能。 下表列出了 .NET 中主要类型类别的方法的默认实现 Equals 。

类型类别 所定义的相等性 注释
从中直接派生的类 Object Object.Equals(Object) 引用相等性;等效于调用 Object.ReferenceEquals。
结构 ValueType.Equals 值相等;使用反射进行直接字节比较或逐字段比较。
枚举 Enum.Equals 值必须具有相同的枚举类型和相同的基础值。
委托 MulticastDelegate.Equals 委托必须具有具有相同调用列表的相同类型。
接口 Object.Equals(Object) 引用相等性。

对于值类型，应始终重写 Equals，因为对依赖于反射的相等性测试提供较差的性能。 还可以重写引用类型的默认实现 Equals ，以测试值相等性而不是引用相等性，并定义值的精确含义。 如果两个对象具有相同的值，则返回true的Equals此类实现，即使它们不是同一实例也是如此。 该类型的实现程序决定构成对象值的内容，但通常是对象实例变量中存储的部分或所有数据。 例如，对象的值 String 基于字符串的字符; String.Equals(Object) 该方法将重写 Object.Equals(Object) 该方法，以返回 true 以相同顺序包含相同字符的任何两个字符串实例。

以下示例演示如何重写 Object.Equals(Object) 用于测试值相等性的方法。 它重写 Equals 类 Person 的方法。 如果 Person 接受其基类实现相等，则仅当两 Person 个对象引用单个对象时才相等。 但是，在这种情况下，如果两个对象具有Person.Id相同的属性值，则两Person个对象相等。

public class Person6
{
   private string idNumber;
   private string personName;

   public Person6(string name, string id)
   {
      this.personName = name;
      this.idNumber = id;
   }

   public override bool Equals(Object obj)
   {
      Person6 personObj = obj as Person6;
      if (personObj == null)
         return false;
      else
         return idNumber.Equals(personObj.idNumber);
   }

   public override int GetHashCode()
   {
      return this.idNumber.GetHashCode();
   }
}

public class Example6
{
   public static void Main()
   {
      Person6 p1 = new Person6("John", "63412895");
      Person6 p2 = new Person6("Jack", "63412895");
      Console.WriteLine(p1.Equals(p2));
      Console.WriteLine(Object.Equals(p1, p2));
   }
}
// The example displays the following output:
//       True
//       True

open System

type Person(name, id) =
    member _.Name = name
    member _.Id = id

    override _.Equals(obj) =
        match obj with
        | :? Person as personObj ->
            id.Equals personObj.Id
        | _ -> 
            false

    override _.GetHashCode() =
        id.GetHashCode()

let p1 = Person("John", "63412895")
let p2 = Person("Jack", "63412895")
printfn $"{p1.Equals p2}"
printfn $"{Object.Equals(p1, p2)}"
// The example displays the following output:
//       True
//       True

Public Class Person
   Private idNumber As String
   Private personName As String
   
   Public Sub New(name As String, id As String)
      Me.personName = name
      Me.idNumber = id
   End Sub
   
   Public Overrides Function Equals(obj As Object) As Boolean
      Dim personObj As Person = TryCast(obj, Person) 
      If personObj Is Nothing Then
         Return False
      Else
         Return idNumber.Equals(personObj.idNumber)
      End If   
   End Function
   
   Public Overrides Function GetHashCode() As Integer
      Return Me.idNumber.GetHashCode() 
   End Function
End Class

Module Example6
    Public Sub Main()
        Dim p1 As New Person("John", "63412895")
        Dim p2 As New Person("Jack", "63412895")
        Console.WriteLine(p1.Equals(p2))
        Console.WriteLine(Object.Equals(p1, p2))
    End Sub
End Module
' The example displays the following output:
'       True
'       True

除了重写 Equals之外，还可以实现 IEquatable<T> 接口以提供强类型测试以实现相等性。

对于该方法的所有实现 Equals(Object) ，以下语句必须为 true。 在列表中，xy表示z非 null 的对象引用。

  • x.Equals(x) 返回 true。

  • x.Equals(y) 返回与 y.Equals(x) 相同的值。

  • x.Equals(y)true返回这两个x值和y值 NaN。

  • 如果 (x.Equals(y) && y.Equals(z)) 返回 true，则 x.Equals(z) 返回 true。

  • 连续调用以 x.Equals(y) 返回相同的值，只要对象 x 被引用且 y 未修改。

  • x.Equals(null) 返回 false。

实现 Equals 不能引发异常;它们应始终返回值。 例如，如果obj为null，该方法Equals应返回false而不是引发 。ArgumentNullException

重写 Equals(Object)时遵循以下准则：

  • 实现 IComparable 的类型必须重写 Equals(Object)。

  • 重写 Equals(Object) 的类型也必须重写 GetHashCode;否则，哈希表可能无法正常工作。

  • 应考虑实现 IEquatable<T> 接口以支持强类型化测试以实现相等。 IEquatable<T>.Equals 实现应返回与 Equals 一致的结果。

  • 如果编程语言支持运算符重载，并且重载给定类型的相等运算符，则还必须重写 Equals(Object) 该方法以返回与相等运算符相同的结果。 这有助于确保使用 Equals （如 ArrayList 和 Hashtable）的类库代码的行为方式与应用程序代码使用相等运算符的方式一致。

参考类型的指南

以下准则适用于替代 Equals(Object) 引用类型：

  • 如果类型的语义基于类型表示某些值的事实，请考虑重写 Equals 。

  • 大多数引用类型不得重载相等运算符，即使它们重写 Equals也是如此。 但是，如果实现的引用类型旨在具有值语义（例如复数类型），则必须重写相等运算符。

  • 不应在可变引用类型上重写 Equals 。 这是因为重写 Equals 要求你也重写方法 GetHashCode ，如上一部分所述。 这意味着可变引用类型的实例的哈希代码在其生存期内可能会更改，这可能导致对象在哈希表中丢失。

值类型的准则

以下准则适用于重写 Equals(Object) 值类型：

  • 如果要定义一个值类型，该类型包含一个或多个字段的值是引用类型，则应重写 Equals(Object)。 Equals(Object)提供的ValueType实现对字段均为所有值类型的值类型执行字节字节比较，但它使用反射对字段包含引用类型的值类型执行逐字段比较。

  • 如果重写 Equals 并且开发语言支持运算符重载，则必须重载相等运算符。

  • 应实现 IEquatable<T> 接口。 调用强类型 IEquatable<T>.Equals 方法可避免装 obj 箱参数。

示例

下面的示例演示一个 Point 类，该类重写 Equals 方法以提供值相等性，以及 Point3D 派生自 Point的类。 由于 Point 重写 Object.Equals(Object) 用于测试值相等性， Object.Equals(Object) 因此不调用该方法。 但是， Point3D.Equals 调用 Point.Equals 是因为 Point 以提供值相等的方式实现 Object.Equals(Object) 。

using System;

class Point2
{
    protected int x, y;

    public Point2() : this(0, 0)
    { }

    public Point2(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public override bool Equals(Object obj)
    {
        //Check for null and compare run-time types.
        if ((obj == null) || !this.GetType().Equals(obj.GetType()))
        {
            return false;
        }
        else
        {
            Point2 p = (Point2)obj;
            return (x == p.x) && (y == p.y);
        }
    }

    public override int GetHashCode()
    {
        return (x << 2) ^ y;
    }

    public override string ToString()
    {
        return String.Format("Point2({0}, {1})", x, y);
    }
}

sealed class Point3D : Point2
{
    int z;

    public Point3D(int x, int y, int z) : base(x, y)
    {
        this.z = z;
    }

    public override bool Equals(Object obj)
    {
        Point3D pt3 = obj as Point3D;
        if (pt3 == null)
            return false;
        else
            return base.Equals((Point2)obj) && z == pt3.z;
    }

    public override int GetHashCode()
    {
        return (base.GetHashCode() << 2) ^ z;
    }

    public override String ToString()
    {
        return String.Format("Point2({0}, {1}, {2})", x, y, z);
    }
}

class Example7
{
    public static void Main()
    {
        Point2 point2D = new Point2(5, 5);
        Point3D point3Da = new Point3D(5, 5, 2);
        Point3D point3Db = new Point3D(5, 5, 2);
        Point3D point3Dc = new Point3D(5, 5, -1);

        Console.WriteLine("{0} = {1}: {2}",
                          point2D, point3Da, point2D.Equals(point3Da));
        Console.WriteLine("{0} = {1}: {2}",
                          point2D, point3Db, point2D.Equals(point3Db));
        Console.WriteLine("{0} = {1}: {2}",
                          point3Da, point3Db, point3Da.Equals(point3Db));
        Console.WriteLine("{0} = {1}: {2}",
                          point3Da, point3Dc, point3Da.Equals(point3Dc));
    }
}
// The example displays the following output:
//       Point2(5, 5) = Point2(5, 5, 2): False
//       Point2(5, 5) = Point2(5, 5, 2): False
//       Point2(5, 5, 2) = Point2(5, 5, 2): True
//       Point2(5, 5, 2) = Point2(5, 5, -1): False

type Point(x, y) =
    new () = Point(0, 0)
    member _.X = x
    member _.Y = y

    override _.Equals(obj) =
        //Check for null and compare run-time types.
        match obj with
        | :? Point as p ->
            x = p.X && y = p.Y
        | _ -> 
            false

    override _.GetHashCode() =
        (x <<< 2) ^^^ y

    override _.ToString() =
        $"Point({x}, {y})"

type Point3D(x, y, z) =
    inherit Point(x, y)
    member _.Z = z

    override _.Equals(obj) =
        match obj with
        | :? Point3D as pt3 ->
            base.Equals(pt3 :> Point) && z = pt3.Z
        | _ -> 
            false

    override _.GetHashCode() =
        (base.GetHashCode() <<< 2) ^^^ z

    override _.ToString() =
        $"Point({x}, {y}, {z})"

let point2D = Point(5, 5)
let point3Da = Point3D(5, 5, 2)
let point3Db = Point3D(5, 5, 2)
let point3Dc = Point3D(5, 5, -1)

printfn $"{point2D} = {point3Da}: {point2D.Equals point3Da}"
printfn $"{point2D} = {point3Db}: {point2D.Equals point3Db}"
printfn $"{point3Da} = {point3Db}: {point3Da.Equals point3Db}"
printfn $"{point3Da} = {point3Dc}: {point3Da.Equals point3Dc}"
// The example displays the following output:
//       Point(5, 5) = Point(5, 5, 2): False
//       Point(5, 5) = Point(5, 5, 2): False
//       Point(5, 5, 2) = Point(5, 5, 2): True
//       Point(5, 5, 2) = Point(5, 5, -1): False

Class Point1
    Protected x, y As Integer

    Public Sub New()
        Me.x = 0
        Me.y = 0
    End Sub

    Public Sub New(x As Integer, y As Integer)
        Me.x = x
        Me.y = y
    End Sub

    Public Overrides Function Equals(obj As Object) As Boolean
        ' Check for null and compare run-time types.
        If obj Is Nothing OrElse Not Me.GetType().Equals(obj.GetType()) Then
            Return False
        Else
            Dim p As Point1 = DirectCast(obj, Point1)
            Return x = p.x AndAlso y = p.y
        End If
    End Function

    Public Overrides Function GetHashCode() As Integer
        Return (x << 2) Xor y
    End Function

    Public Overrides Function ToString() As String
        Return String.Format("Point1({0}, {1})", x, y)
    End Function
End Class

Class Point3D : Inherits Point1
    Private z As Integer

    Public Sub New(ByVal x As Integer, ByVal y As Integer, ByVal z As Integer)
        MyBase.New(x, y)
        Me.z = z
    End Sub

    Public Overrides Function Equals(ByVal obj As Object) As Boolean
        Dim pt3 As Point3D = TryCast(obj, Point3D)
        If pt3 Is Nothing Then
            Return False
        Else
            Return MyBase.Equals(CType(pt3, Point1)) AndAlso z = pt3.z
        End If
    End Function

    Public Overrides Function GetHashCode() As Integer
        Return (MyBase.GetHashCode() << 2) Xor z
    End Function

    Public Overrides Function ToString() As String
        Return String.Format("Point1({0}, {1}, {2})", x, y, z)
    End Function
End Class

Module Example1
    Public Sub Main()
        Dim point2D As New Point1(5, 5)
        Dim point3Da As New Point3D(5, 5, 2)
        Dim point3Db As New Point3D(5, 5, 2)
        Dim point3Dc As New Point3D(5, 5, -1)

        Console.WriteLine("{0} = {1}: {2}",
                          point2D, point3Da, point2D.Equals(point3Da))
        Console.WriteLine("{0} = {1}: {2}",
                          point2D, point3Db, point2D.Equals(point3Db))
        Console.WriteLine("{0} = {1}: {2}",
                          point3Da, point3Db, point3Da.Equals(point3Db))
        Console.WriteLine("{0} = {1}: {2}",
                          point3Da, point3Dc, point3Da.Equals(point3Dc))
    End Sub
End Module
' The example displays the following output
'       Point1(5, 5) = Point1(5, 5, 2): False
'       Point1(5, 5) = Point1(5, 5, 2): False
'       Point1(5, 5, 2) = Point1(5, 5, 2): True
'       Point1(5, 5, 2) = Point1(5, 5, -1): False

该方法Point.Equals检查以确保obj参数不为 null，并且它引用的实例与此对象的类型相同。 如果任一检查失败，该方法将false返回 。

该方法 Point.Equals 调用 GetType 该方法来确定这两个对象的运行时类型是否相同。 如果方法在 C# 或 Visual Basic 中使用了表单obj is Point的检查，则即使当前实例不是同一运行时类型，检查也会返回true该obj类的实例Pointobj。TryCast(obj, Point) 验证这两个对象的类型相同后，该方法会强制转换为 obj 类型 Point 并返回比较两个对象的实例字段的结果。

在 Point3D.Equals继承 Point.Equals 的方法（替代 Object.Equals(Object)）在完成任何其他操作之前调用。 因为Point3D是一个密封的类 (在 Visual Basic 中为 NotInheritable)，签入窗体obj is PointC# 中或TryCast(obj, Point)在 Visual Basic 中是足以确保obj是Point3D对象。 如果它是对象 Point3D ，则将其强制转换为 Point 对象并传递给基类实现 Equals。 仅当继承 Point.Equals 的方法返回 true 时，该方法才会比较 z 派生类中引入的实例字段。

以下示例定义一个类，该类在内部实现一个矩形作为两Point个Rectangle对象。 该 Rectangle 类还会重写 Object.Equals(Object) 以提供值相等性。

using System;

class Rectangle
{
   private Point a, b;

   public Rectangle(int upLeftX, int upLeftY, int downRightX, int downRightY)
   {
      this.a = new Point(upLeftX, upLeftY);
      this.b = new Point(downRightX, downRightY);
   }

   public override bool Equals(Object obj)
   {
      // Perform an equality check on two rectangles (Point object pairs).
      if (obj == null || GetType() != obj.GetType())
          return false;
      Rectangle r = (Rectangle)obj;
      return a.Equals(r.a) && b.Equals(r.b);
   }

   public override int GetHashCode()
   {
      return Tuple.Create(a, b).GetHashCode();
   }

    public override String ToString()
    {
       return String.Format("Rectangle({0}, {1}, {2}, {3})",
                            a.x, a.y, b.x, b.y);
    }
}

class Point
{
  internal int x;
  internal int y;

  public Point(int X, int Y)
  {
     this.x = X;
     this.y = Y;
  }

  public override bool Equals (Object obj)
  {
     // Performs an equality check on two points (integer pairs).
     if (obj == null || GetType() != obj.GetType()) return false;
     Point p = (Point)obj;
     return (x == p.x) && (y == p.y);
  }

  public override int GetHashCode()
  {
     return Tuple.Create(x, y).GetHashCode();
  }
}

class Example
{
   public static void Main()
   {
      Rectangle r1 = new Rectangle(0, 0, 100, 200);
      Rectangle r2 = new Rectangle(0, 0, 100, 200);
      Rectangle r3 = new Rectangle(0, 0, 150, 200);

      Console.WriteLine("{0} = {1}: {2}", r1, r2, r1.Equals(r2));
      Console.WriteLine("{0} = {1}: {2}", r1, r3, r1.Equals(r3));
      Console.WriteLine("{0} = {1}: {2}", r2, r3, r2.Equals(r3));
   }
}
// The example displays the following output:
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 100, 200): True
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False

type Point(x, y) =
    member _.X = x
    member _.Y = y

    override _.Equals(obj) =
        // Performs an equality check on two points (integer pairs).
        match obj with
        | :? Point as p ->
            x = p.X && y = p.Y
        | _ ->
            false
    
    override _.GetHashCode() =
        (x, y).GetHashCode()

type Rectangle(upLeftX, upLeftY, downRightX, downRightY) =
    let a = Point(upLeftX, upLeftY)
    let b = Point(downRightX, downRightY)
    
    member _.UpLeft = a
    member _.DownRight = b

    override _.Equals(obj) =
        // Perform an equality check on two rectangles (Point object pairs).
        match obj with
        | :? Rectangle as r ->
            a.Equals(r.UpLeft) && b.Equals(r.DownRight)
        | _ -> 
            false
        
    override _.GetHashCode() =
        (a, b).GetHashCode()

    override _.ToString() =
       $"Rectangle({a.X}, {a.Y}, {b.X}, {b.Y})"

let r1 = Rectangle(0, 0, 100, 200)
let r2 = Rectangle(0, 0, 100, 200)
let r3 = Rectangle(0, 0, 150, 200)

printfn $"{r1} = {r2}: {r1.Equals r2}"
printfn $"{r1} = {r3}: {r1.Equals r3}"
printfn $"{r2} = {r3}: {r2.Equals r3}"
// The example displays the following output:
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 100, 200): True
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False

Class Rectangle 
    Private a, b As Point
    
    Public Sub New(ByVal upLeftX As Integer, ByVal upLeftY As Integer, _
                   ByVal downRightX As Integer, ByVal downRightY As Integer) 
        Me.a = New Point(upLeftX, upLeftY)
        Me.b = New Point(downRightX, downRightY)
    End Sub 
    
    Public Overrides Function Equals(ByVal obj As [Object]) As Boolean 
        ' Performs an equality check on two rectangles (Point object pairs).
        If obj Is Nothing OrElse Not [GetType]().Equals(obj.GetType()) Then
            Return False
        End If
        Dim r As Rectangle = CType(obj, Rectangle)
        Return a.Equals(r.a) AndAlso b.Equals(r.b)
    End Function

    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(a, b).GetHashCode()
    End Function 

    Public Overrides Function ToString() As String
       Return String.Format("Rectangle({0}, {1}, {2}, {3})",
                            a.x, a.y, b.x, b.y) 
    End Function
End Class 

Class Point
    Friend x As Integer
    Friend y As Integer
    
    Public Sub New(ByVal X As Integer, ByVal Y As Integer) 
        Me.x = X
        Me.y = Y
    End Sub 

    Public Overrides Function Equals(ByVal obj As [Object]) As Boolean 
        ' Performs an equality check on two points (integer pairs).
        If obj Is Nothing OrElse Not [GetType]().Equals(obj.GetType()) Then
            Return False
        Else
           Dim p As Point = CType(obj, Point)
           Return x = p.x AndAlso y = p.y
        End If
    End Function 
    
    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(x, y).GetHashCode()
    End Function 
End Class  

Class Example
    Public Shared Sub Main() 
        Dim r1 As New Rectangle(0, 0, 100, 200)
        Dim r2 As New Rectangle(0, 0, 100, 200)
        Dim r3 As New Rectangle(0, 0, 150, 200)
        
        Console.WriteLine("{0} = {1}: {2}", r1, r2, r1.Equals(r2))
        Console.WriteLine("{0} = {1}: {2}", r1, r3, r1.Equals(r3))
        Console.WriteLine("{0} = {1}: {2}", r2, r3, r2.Equals(r3))
    End Sub 
End Class 
' The example displays the following output:
'    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 100, 200): True
'    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False
'    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False

某些语言（如 C# 和 Visual Basic）支持运算符重载。 当类型重载相等运算符时，它还必须重写 Equals(Object) 该方法以提供相同的功能。 这通常是通过在重载相等运算符方面编写 Equals(Object) 方法来实现的，如以下示例所示。

using System;

public struct Complex
{
   public double re, im;

   public override bool Equals(Object obj)
   {
      return obj is Complex && this == (Complex)obj;
   }

   public override int GetHashCode()
   {
      return Tuple.Create(re, im).GetHashCode();
   }

   public static bool operator ==(Complex x, Complex y)
   {
      return x.re == y.re && x.im == y.im;
   }

   public static bool operator !=(Complex x, Complex y)
   {
      return !(x == y);
   }

    public override String ToString()
    {
       return String.Format("({0}, {1})", re, im);
    }
}

class MyClass
{
  public static void Main()
  {
    Complex cmplx1, cmplx2;

    cmplx1.re = 4.0;
    cmplx1.im = 1.0;

    cmplx2.re = 2.0;
    cmplx2.im = 1.0;

    Console.WriteLine("{0} <> {1}: {2}", cmplx1, cmplx2, cmplx1 != cmplx2);
    Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2));

    cmplx2.re = 4.0;

    Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1 == cmplx2);
    Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2));
  }
}
// The example displays the following output:
//       (4, 1) <> (2, 1): True
//       (4, 1) = (2, 1): False
//       (4, 1) = (4, 1): True
//       (4, 1) = (4, 1): True

[<Struct; CustomEquality; NoComparison>]
type Complex =
    val mutable re: double
    val mutable im: double

    override this.Equals(obj) =
        match obj with 
        | :? Complex as c when c = this -> true
        | _ -> false 

    override this.GetHashCode() =
        (this.re, this.im).GetHashCode()

    override this.ToString() =
        $"({this.re}, {this.im})"

    static member op_Equality (x: Complex, y: Complex) =
        x.re = y.re && x.im = y.im

    static member op_Inequality (x: Complex, y: Complex) =
        x = y |> not

let mutable cmplx1 = Complex()
let mutable cmplx2 = Complex()

cmplx1.re <- 4.0
cmplx1.im <- 1.0

cmplx2.re <- 2.0
cmplx2.im <- 1.0

printfn $"{cmplx1} <> {cmplx2}: {cmplx1 <> cmplx2}"
printfn $"{cmplx1} = {cmplx2}: {cmplx1.Equals cmplx2}"

cmplx2.re <- 4.0

printfn $"{cmplx1} = {cmplx2}: {cmplx1 = cmplx2}"
printfn $"{cmplx1} = {cmplx2}: {cmplx1.Equals cmplx2}"

// The example displays the following output:
//       (4, 1) <> (2, 1): True
//       (4, 1) = (2, 1): False
//       (4, 1) = (4, 1): True
//       (4, 1) = (4, 1): True

Public Structure Complex
    Public re, im As Double
    
    Public Overrides Function Equals(ByVal obj As [Object]) As Boolean 
        Return TypeOf obj Is Complex AndAlso Me = CType(obj, Complex)
    End Function 
    
    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(re, im).GetHashCode()
    End Function 
    
    Public Shared Operator = (x As Complex, y As Complex) As Boolean
       Return x.re = y.re AndAlso x.im = y.im
    End Operator 
    
    Public Shared Operator <> (x As Complex, y As Complex) As Boolean
       Return Not (x = y)
    End Operator 
    
    Public Overrides Function ToString() As String
       Return String.Format("({0}, {1})", re, im)
    End Function 
End Structure

Class Example8
    Public Shared Sub Main()
        Dim cmplx1, cmplx2 As Complex

        cmplx1.re = 4.0
        cmplx1.im = 1.0

        cmplx2.re = 2.0
        cmplx2.im = 1.0

        Console.WriteLine("{0} <> {1}: {2}", cmplx1, cmplx2, cmplx1 <> cmplx2)
        Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2))

        cmplx2.re = 4.0

        Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1 = cmplx2)
        Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2))
    End Sub
End Class
' The example displays the following output:
'       (4, 1) <> (2, 1): True
'       (4, 1) = (2, 1): False
'       (4, 1) = (4, 1): True
'       (4, 1) = (4, 1): True

由于 Complex 是值类型，因此无法从中派生它。 因此，重写Equals(Object)方法不需要调用GetType来确定每个对象的精确运行时类型，但可以改用 is C# 中的运算符或 TypeOf Visual Basic 中的运算符来检查参数的类型obj。