Metode System.Object.Equals

  • Artikel

Artikel ini menyediakan keterangan tambahan untuk dokumentasi referensi untuk API ini.

Artikel ini berkaitan dengan Object.Equals(Object) metode .

Jenis perbandingan antara instans saat ini dan obj parameter tergantung pada apakah instans saat ini adalah jenis referensi atau jenis nilai.

  • Jika instans saat ini adalah jenis referensi, Equals(Object) metode menguji kesetaraan referensi, dan panggilan ke Equals(Object) metode tersebut setara dengan panggilan ke ReferenceEquals metode . Kesetaraan referensi berarti bahwa variabel objek yang dibandingkan merujuk ke objek yang sama. Contoh berikut mengilustrasikan hasil perbandingan tersebut. Ini mendefinisikan Person kelas, yang merupakan jenis referensi, dan memanggil Person konstruktor kelas untuk membuat instans dua objek baru Person , person1a dan person2, yang memiliki nilai yang sama. Ini juga menetapkan person1a ke variabel objek lain, person1b. Seperti yang ditunjukkan oleh output dari contoh, person1a dan person1b sama karena mereferensikan objek yang sama. Namun, person1a dan person2 tidak sama, meskipun mereka memiliki nilai yang sama.

    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

  • Jika instans saat ini adalah jenis nilai, Equals(Object) metode akan menguji kesetaraan nilai. Kesetaraan nilai berarti sebagai berikut:

    • Dua objek berjenis yang sama. Seperti yang ditunjukkan contoh berikut, Byte objek yang memiliki nilai 12 tidak sama dengan Int32 objek yang memiliki nilai 12, karena kedua objek memiliki jenis run-time yang berbeda.

      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

    • Nilai bidang publik dan privat dari dua objek sama. Contoh berikut menguji kesetaraan nilai. Ini mendefinisikan Person struktur, yang merupakan jenis nilai, dan memanggil Person konstruktor kelas untuk membuat instans dua objek baru Person , person1 dan person2, yang memiliki nilai yang sama. Seperti yang ditunjukkan oleh output dari contoh, meskipun dua variabel objek merujuk ke objek yang berbeda, person1 dan person2 sama karena memiliki nilai yang sama untuk bidang privat 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 Karena kelas adalah kelas dasar untuk semua jenis di .NET, Object.Equals(Object) metode ini menyediakan perbandingan kesetaraan default untuk semua jenis lainnya. Namun, jenis sering mengambil alih Equals metode untuk mengimplementasikan kesetaraan nilai. Untuk informasi selengkapnya, lihat bagian Catatan untuk Penelepon dan Catatan untuk Pewaris.

Catatan untuk Windows Runtime

Ketika Anda memanggil Equals(Object) kelebihan beban metode pada kelas di Windows Runtime, metode ini menyediakan perilaku default untuk kelas yang tidak mengambil alih Equals(Object). Ini adalah bagian dari dukungan yang disediakan .NET untuk Windows Runtime (lihat Dukungan .NET untuk Aplikasi Windows Store dan Runtime Windows). Kelas di Windows Runtime tidak mewarisi Object, dan saat ini tidak menerapkan Equals(Object) metode. Namun, mereka tampaknya memiliki ToStringmetode , Equals(Object), dan GetHashCode ketika Anda menggunakannya dalam kode C# atau Visual Basic Anda, dan .NET menyediakan perilaku default untuk metode ini.

Catatan

Kelas Windows Runtime yang ditulis dalam C# atau Visual Basic dapat menimpa Equals(Object) kelebihan metode.

Catatan untuk penelepon

Kelas turunan sering mengambil alih Object.Equals(Object) metode untuk mengimplementasikan kesetaraan nilai. Selain itu, jenis juga sering memberikan kelebihan beban tambahan yang ditik dengan kuat ke Equals metode , biasanya dengan menerapkan IEquatable<T> antarmuka. Ketika Anda memanggil Equals metode untuk menguji kesetaraan, Anda harus tahu apakah instans saat ini mengambil alih Object.Equals dan memahami bagaimana panggilan tertentu ke Equals metode diselesaikan. Jika tidak, Anda mungkin melakukan pengujian untuk kesetaraan yang berbeda dari apa yang Anda inginkan, dan metode dapat mengembalikan nilai yang tidak terduga.

Contoh berikut memberikan ilustrasi. Ini membuat instans tiga StringBuilder objek dengan string yang identik, dan kemudian melakukan empat panggilan ke Equals metode. Panggilan metode pertama mengembalikan true, dan tiga falsepengembalian yang tersisa .

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

Dalam kasus pertama, metode yang sangat ditik StringBuilder.Equals(StringBuilder) kelebihan beban, yang menguji kesetaraan nilai, dipanggil. Karena string yang ditetapkan ke dua StringBuilder objek sama, metode mengembalikan true. Namun, StringBuilder tidak mengambil alih Object.Equals(Object). Karena itu, ketika StringBuilder objek ditransmisikan ke Object, ketika StringBuilder instans ditetapkan ke variabel jenis Object, dan ketika Object.Equals(Object, Object) metode diteruskan dua StringBuilder objek, metode default Object.Equals(Object) dipanggil. Karena StringBuilder merupakan jenis referensi, ini setara dengan meneruskan dua StringBuilder objek ke ReferenceEquals metode . Meskipun ketiga StringBuilder objek berisi string yang identik, objek tersebut mengacu pada tiga objek yang berbeda. Akibatnya, ketiga panggilan metode ini mengembalikan false.

Anda dapat membandingkan objek saat ini dengan objek lain untuk kesetaraan referensi dengan memanggil ReferenceEquals metode . Di Visual Basic, Anda juga dapat menggunakan is kata kunci (misalnya, If Me Is otherObject Then ...).

Catatan untuk pewaris

Saat Anda menentukan jenis Anda sendiri, jenis tersebut mewarisi fungsionalitas yang ditentukan oleh Equals metode jenis dasarnya. Tabel berikut mencantumkan implementasi Equals default metode untuk kategori utama jenis di .NET.

Jenis kategori Kesetaraan yang ditentukan oleh Komentar
Kelas yang berasal langsung dari Object Object.Equals(Object) Kesetaraan referensi; setara dengan panggilan Object.ReferenceEquals.
Struktur ValueType.Equals Kesetaraan nilai; perbandingan byte-byte langsung atau perbandingan bidang demi bidang menggunakan pantulan.
Enumeration Enum.Equals Nilai harus memiliki jenis enumerasi yang sama dan nilai dasar yang sama.
Delegasikan MulticastDelegate.Equals Delegasi harus memiliki jenis yang sama dengan daftar pemanggilan yang identik.
Antarmuka Object.Equals(Object) Kesetaraan referensi.

Untuk jenis nilai, Anda harus selalu mengambil Equalsalih , karena pengujian untuk kesetaraan yang mengandalkan refleksi menawarkan performa yang buruk. Anda juga dapat mengambil alih implementasi Equals default untuk jenis referensi untuk menguji kesetaraan nilai alih-alih kesetaraan referensi dan untuk menentukan arti yang tepat dari kesetaraan nilai. Implementasi Equals pengembalian true tersebut jika kedua objek memiliki nilai yang sama, bahkan jika mereka bukan instans yang sama. Pelaksana jenis memutuskan apa yang merupakan nilai objek, tetapi biasanya beberapa atau semua data yang disimpan dalam variabel instans objek. Misalnya, nilai String objek didasarkan pada karakter string; String.Equals(Object) metode mengambil alih Object.Equals(Object) metode untuk mengembalikan true dua instans string yang berisi karakter yang sama dalam urutan yang sama.

Contoh berikut menunjukkan cara mengambil Object.Equals(Object) alih metode untuk menguji kesetaraan nilai. Ini mengambil alih Equals metode untuk Person kelas . Jika Person menerima implementasi kelas dasar kesetaraannya, dua Person objek akan sama hanya jika mereferensikan satu objek. Namun, dalam hal ini, dua Person objek sama jika memiliki nilai yang sama untuk Person.Id properti .

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

Selain mengesampingkan Equals, Anda dapat mengimplementasikan IEquatable<T> antarmuka untuk menyediakan pengujian yang sangat di ketik untuk kesetaraan.

Pernyataan berikut harus benar untuk semua implementasi Equals(Object) metode. Dalam daftar, x, , dan z mewakili referensi objek yang tidak nully.

  • x.Equals(x) menghasilkan true.

  • x.Equals(y) mengembalikan nilai yang sama dengan y.Equals(x).

  • x.Equals(y)true mengembalikan jika keduanya x dan y adalah NaN.

  • Jika (x.Equals(y) && y.Equals(z)) mengembalikan true, maka x.Equals(z) mengembalikan true.

  • Panggilan berturut-turut untuk x.Equals(y) mengembalikan nilai yang sama selama objek yang dirujuk oleh x dan y tidak dimodifikasi.

  • x.Equals(null) menghasilkan false.

Equals Implementasi tidak boleh melemparkan pengecualian; mereka harus selalu mengembalikan nilai. Misalnya, jika obj adalah null, Equals metode harus kembali false alih-alih melempar ArgumentNullException.

Ikuti panduan ini saat mengambil alih Equals(Object):

  • Jenis yang menerapkan IComparable harus mengambil alih Equals(Object).

  • Jenis yang mengambil alih Equals(Object) juga harus mengambil alih GetHashCode; jika tidak, tabel hash mungkin tidak berfungsi dengan benar.

  • Anda harus mempertimbangkan untuk mengimplementasikan IEquatable<T> antarmuka untuk mendukung pengujian yang sangat di ketik untuk kesetaraan. Implementasi Anda IEquatable<T>.Equals harus mengembalikan hasil yang konsisten dengan Equals.

  • Jika bahasa pemrograman Anda mendukung kelebihan beban operator dan Anda membebani operator kesetaraan untuk jenis tertentu, Anda juga harus mengambil alih Equals(Object) metode untuk mengembalikan hasil yang sama dengan operator kesetaraan. Ini membantu memastikan bahwa kode pustaka kelas yang menggunakan Equals (seperti ArrayList dan Hashtable) berprilaku dengan cara yang konsisten dengan cara operator kesetaraan digunakan oleh kode aplikasi.

Panduan untuk jenis referensi

Panduan berikut berlaku untuk mengambil alih Equals(Object) jenis referensi:

  • Pertimbangkan untuk mengambil Equals alih jika semantik jenis didasarkan pada fakta bahwa jenis mewakili beberapa nilai.

  • Sebagian besar jenis referensi tidak boleh membebani operator kesetaraan, bahkan jika mereka mengambil alih Equals. Namun, jika Anda menerapkan jenis referensi yang dimaksudkan untuk memiliki semantik nilai, seperti jenis angka kompleks, Anda harus mengambil alih operator kesetaraan.

  • Anda tidak boleh mengambil alih Equals jenis referensi yang dapat diubah. Ini karena penimpaan Equals mengharuskan Anda juga mengambil GetHashCode alih metode, seperti yang dibahas di bagian sebelumnya. Ini berarti bahwa kode hash instans jenis referensi yang dapat diubah dapat berubah selama masa pakainya, yang dapat menyebabkan objek hilang dalam tabel hash.

Panduan untuk jenis nilai

Panduan berikut berlaku untuk mengambil alih Equals(Object) jenis nilai:

  • Jika Anda mendefinisikan jenis nilai yang menyertakan satu atau beberapa bidang yang nilainya adalah jenis referensi, Anda harus mengambil Equals(Object)alih . Implementasi Equals(Object) yang disediakan oleh ValueType melakukan perbandingan byte-byte untuk jenis nilai yang bidangnya adalah semua jenis nilai, tetapi menggunakan refleksi untuk melakukan perbandingan bidang demi bidang dari jenis nilai yang bidangnya menyertakan jenis referensi.

  • Jika Anda mengambil alih Equals dan bahasa pengembangan mendukung kelebihan beban operator, Anda harus membebani operator kesetaraan.

  • Anda harus mengimplementasikan IEquatable<T> antarmuka. Memanggil metode yang ditik IEquatable<T>.Equals dengan kuat menghindari tinju obj argumen.

Contoh

Contoh berikut menunjukkan Point kelas yang mengambil Equals alih metode untuk memberikan kesetaraan nilai, dan Point3D kelas yang berasal dari Point. Karena Point mengambil alih Object.Equals(Object) untuk menguji kesetaraan nilai, Object.Equals(Object) metode tidak dipanggil. Namun, Point3D.Equals panggilan Point.Equals karena Point menerapkan Object.Equals(Object) dengan cara yang memberikan kesetaraan nilai.

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

Metode Point.Equals memeriksa untuk memastikan bahwa obj argumen tidak null dan mereferensikan instans dengan jenis yang sama dengan objek ini. Jika salah satu pemeriksaan gagal, metode mengembalikan false.

Metode ini Point.Equals memanggil GetType metode untuk menentukan apakah jenis run-time dari dua objek identik. Jika metode menggunakan pemeriksaan formulir obj is Point di C# atau TryCast(obj, Point) di Visual Basic, pemeriksaan akan kembali true dalam kasus di mana obj adalah instans kelas turunan Point, meskipun obj dan instans saat ini bukan dari jenis run-time yang sama. Setelah memverifikasi bahwa kedua objek memiliki jenis yang sama, metode dilemparkan obj ke jenis Point dan mengembalikan hasil membandingkan bidang instans dari dua objek.

Dalam Point3D.Equals, metode yang diwariskan Point.Equals , yang mengambil alih Object.Equals(Object), dipanggil sebelum hal lain dilakukan. Karena Point3D adalah kelas tertutup (NotInheritable di Visual Basic), pemeriksaan dalam formulir obj is Point di C# atau TryCast(obj, Point) di Visual Basic cukup untuk memastikan bahwa obj itu adalah Point3D objek. Jika itu adalah Point3D objek, itu ditransmisikan ke Point objek dan diteruskan ke implementasi kelas dasar .Equals Hanya ketika metode yang diwariskan Point.Equals kembali true melakukan metode membandingkan z bidang instans yang diperkenalkan di kelas turunan.

Contoh berikut mendefinisikan Rectangle kelas yang secara internal mengimplementasikan persegi panjang sebagai dua Point objek. Kelas Rectangle juga mengambil alih Object.Equals(Object) untuk memberikan kesetaraan nilai.

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

Beberapa bahasa seperti C# dan operator dukungan Visual Basic kelebihan beban. Ketika jenis membebani operator kesetaraan, jenis juga harus mengambil alih Equals(Object) metode untuk menyediakan fungsionalitas yang sama. Ini biasanya dicapai dengan menulis Equals(Object) metode dalam hal operator kesetaraan yang kelebihan beban, seperti dalam contoh berikut.

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

Karena Complex merupakan jenis nilai, tipe tersebut tidak dapat diturunkan. Oleh karena itu, penimpaan ke Equals(Object) metode tidak perlu memanggil GetType untuk menentukan jenis run-time yang tepat dari setiap objek, tetapi dapat menggunakan is operator di C# atau TypeOf operator di Visual Basic untuk memeriksa jenis obj parameter.