System.Object.Equals 方法

發行項
01/31/2024

本文提供此 API 參考文件的補充備註。

目前實例與 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 市集應用程式和 Windows 執行階段的 .NET 支援）。 Windows 執行階段中的類別不會繼承 Object，而且目前不會實Equals(Object)作方法。不過，當您在 C# 或 Visual Basic 程式代碼中使用、和方法時，它們似乎有 ToString Equals(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)。因此，當物件轉換成 Object時，當StringBuilder實例指派給類型的Object變數，而當方法傳遞兩StringBuilder個StringBuilder物件時Object.Equals(Object, Object)，就會呼叫預設Object.Equals(Object)方法。因為 StringBuilder 是參考型別，這相當於將兩 StringBuilder 個對象傳遞至 ReferenceEquals 方法。雖然這三 StringBuilder 個物件都包含相同的字串，但是它們會參考三個不同的物件。因此，這三個方法呼叫會傳回 false。

您可以呼叫 ReferenceEquals 方法，將目前的物件與另一個對象進行比較，以取得參考相等性。在 Visual Basic 中，您也可以使用 is 關鍵詞（例如， If Me Is otherObject Then ...）。

繼承者的注意事項

當您定義自己的類型時，該類型會繼承其基底類型方法所 Equals 定義的功能。下表列出 .NET 中類型主要類別之方法的預設實 Equals 作。

型別分類	所定義的相等	註解
直接衍生自的類別 Object	Object.Equals(Object)	參考相等;相當於通話 Object.ReferenceEquals。
結構	ValueType.Equals	值相等;使用反映直接位元組比較或欄位段逐欄位比較。
列舉型別	Enum.Equals	值必須具有相同的列舉型別和相同的基礎值。
Delegate	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 物件具有屬性的相同值 Person.Id ，則兩個物件相等。

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) 都必須有下列語句。在清單中， x、 y和 z 代表非 Null 的物件參考。

x.Equals(x) 傳回 true。
x.Equals(y) 會傳回與 y.Equals(x) 相同的值。
x.Equals(y)如果與 y 都是 xNaN，則傳true回。
如果 (x.Equals(y) && y.Equals(z)) 傳 true回，則會 x.Equals(z) 傳 true回。
只要和 xy 所參考的物件未修改，後續呼叫會x.Equals(y)傳回相同的值。
x.Equals(null) 傳回 false。

的 Equals 實作不得擲回例外狀況;它們應該一律傳回值。例如，如果 obj 是，則Equals方法應該傳回 false ，而不是擲回 ArgumentNullExceptionnull。

覆寫 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方法可避免將自變數 Boxing。obj

範例

下列範例顯示 Point 覆寫 Equals 方法以提供值相等的類別，以及 Point3D 衍生自 Point的類別。因為 Point 覆寫 Object.Equals(Object) 以測試值是否相等， Object.Equals(Object) 因此不會呼叫方法。不過， Point3D.Equals 呼叫 Point.Equals ，因為 PointObject.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# 或 TryCast(obj, Point) Visual Basic 中使用表單obj is Point的檢查，則檢查會傳回 true ，如果是 obj 衍生類別Point的實例，即使 obj 和目前的實例不是相同的運行時間類型。確認這兩個物件的類型相同，方法會轉換成 obj 類型 Point ，並傳回比較兩個對象的實例欄位的結果。

在中Point3D.Equals，會覆寫 Object.Equals(Object)的繼承Point.Equals方法會在完成任何其他動作之前叫用。因為 Point3D 是密封類別（NotInheritable在 Visual Basic 中），因此在 C# 或 TryCast(obj, Point) Visual Basic 中籤入表單obj is Point就足以確保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 。

System.Object.Equals 方法

Windows 執行階段注意事項

來電者注意事項

繼承者的注意事項

參考型別的指導方針

實值型別的指導方針

範例

意見反應

其他資源

System.Object.Equals 方法

Windows 執行階段 注意事項

來電者注意事項

繼承者的注意事項

參考型別的指導方針

實值型別的指導方針

範例

意見反應

其他資源

Windows 執行階段注意事項