Bagikan melalui

Metode System.Object.Equals

Nota

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, metode Equals(Object) menguji kesetaraan referensi, dan panggilan metode Equals(Object) setara dengan panggilan metode ReferenceEquals. 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: {person1a.Equals(person1b)}");
      Console.WriteLine($"person1a and person2: {person1a.Equals(person2)}");

      Console.WriteLine("\nCasting to an Object and calling Equals:");
      Console.WriteLine($"person1a and person1b: {((object) person1a).Equals((object) person1b)}");
      Console.WriteLine($"person1a and person2: {((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, metode Equals(Object) 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 runtime yang berbeda.

      byte value1 = 12;
int value2 = 12;

object object1 = value1;
object object2 = value2;

Console.WriteLine($"{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

Karena kelas Object adalah kelas dasar untuk semua jenis di .NET, metode Object.Equals(Object) 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 Windows Runtime). 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.

Nota

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

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 metode Equals untuk menguji kesetaraan, Anda harus tahu apakah instans saat ini mengganti Object.Equals dan memahami bagaimana panggilan tertentu ke metode Equals diselesaikan. Jika sebaliknya, Anda mungkin melakukan pengujian untuk kesetaraan yang berbeda dari apa yang Anda inginkan, dan metode tersebut dapat mengembalikan nilai yang tidak terduga.

Contoh berikut memberikan ilustrasi. Ini membuat tiga objek StringBuilder dengan string yang identik, lalu melakukan empat kali panggilan ke metode Equals. Panggilan metode pertama mengembalikan true, dan tiga panggilan lainnya mengembalikan 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): {sb1.Equals(sb2)}");
      Console.WriteLine($"((Object) sb1).Equals(sb2): {((Object) sb1).Equals(sb2)}");
      Console.WriteLine($"Object.Equals(sb1, sb2): {Object.Equals(sb1, sb2)}");

      Object sb3 = new StringBuilder("building a string...");
      Console.WriteLine($"\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

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 objek StringBuilder ditransmisikan ke Object, ketika instans StringBuilder ditetapkan ke variabel tipe Object, dan ketika metode Object.Equals(Object, Object) diteruskan dua objek StringBuilder, 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 metode default untuk jenis kategori utama 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 langsung byte demi byte atau perbandingan bidang demi bidang menggunakan refleksi.
Enumerasi Enum.Equals Nilai harus memiliki jenis enumerasi yang sama dan nilai dasar yang sama.
Mendelegasikan MulticastDelegate.Equals Delegasi harus memiliki jenis yang sama dengan daftar pemanggilan yang identik.
Antarmuka Object.Equals(Object) Kesetaraan Referensi.

Untuk tipe nilai, Anda harus selalu meng-override Equals, karena pengujian untuk persamaan yang mengandalkan refleksi menawarkan kinerja yang buruk. Anda juga dapat mengganti implementasi Equals default untuk tipe referensi guna menguji kesetaraan nilai alih-alih kesetaraan referensi dan menentukan makna yang tepat dari kesetaraan nilai. Implementasi Equals mengembalikan true jika kedua objek memiliki nilai yang sama, meskipun mereka bukan instans yang sama. Penerap jenis memutuskan apa yang menentukan nilai objek, tetapi biasanya adalah beberapa atau semua data yang disimpan dalam variabel instans objek. Misalnya, nilai objek String didasarkan pada karakter string; metode String.Equals(Object) menimpa metode Object.Equals(Object) untuk mengembalikan true bagi dua instans string yang berisi karakter yang sama dalam urutan yang sama.

Contoh berikut menunjukkan cara meng-override metode Object.Equals(Object) untuk menguji kesetaraan nilai. Ini mengganti metode Equals untuk kelas Person. 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 bertipe kuat untuk kesetaraan.

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

  • x.Equals(x) menghasilkan true.

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

  • x.Equals(y) mengembalikan true jika x dan y keduanya 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.

Implementasi Equals tidak boleh melemparkan pengecualian; harus selalu mengembalikan nilai. Misalnya, jika obj adalah null, metode Equals harus mengembalikan 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 antarmuka IEquatable<T> untuk mendukung uji tipe kuat 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 menggantikan jenis referensi Equals(Object):

  • Pertimbangkan untuk menggantikan Equals jika semantik tipe didasarkan pada fakta bahwa tipe tersebut mewakili beberapa nilai-nilai.

  • Sebagian besar jenis referensi tidak boleh meng-overload operator kesetaraan, bahkan jika mereka mengganti 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 mengganti Equals pada jenis referensi yang dapat berubah. Ini karena penimpaan Equals mengharuskan Anda juga menimpa metode GetHashCode, 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 mencakup satu atau beberapa field yang nilainya adalah jenis referensi, Anda harus meng-override Equals(Object). Implementasi Equals(Object) yang disediakan oleh ValueType melakukan perbandingan byte demi byte untuk tipe nilai yang semua bidangnya adalah tipe nilai, tetapi menggunakan refleksi untuk melakukan perbandingan bidang demi bidang dari tipe nilai yang bidangnya menyertakan tipe 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 bertipe kuat IEquatable<T>.Equals menghindari pengotakan argumen obj.

Contoh

Contoh berikut menunjukkan kelas Point yang menimpa metode Equals untuk memberikan kesetaraan nilai, dan kelas Point3D yang diturunkan dari Point. Karena Point mengambil alih Object.Equals(Object) untuk menguji kesetaraan nilai, Object.Equals(Object) metode tidak dipanggil. Namun, Point3D.Equals memanggil Point.Equals karena Point menerapkan Object.Equals(Object) dengan 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($"{point2D} = {point3Da}: {point2D.Equals(point3Da)}");
        Console.WriteLine($"{point2D} = {point3Db}: {point2D.Equals(point3Db)}");
        Console.WriteLine($"{point3Da} = {point3Db}: {point3Da.Equals(point3Db)}");
        Console.WriteLine($"{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 Point.Equals memanggil metode GetType untuk menentukan apakah tipe waktu proses dari kedua objek tersebut 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 runtime yang sama. Setelah memverifikasi bahwa kedua objek memiliki jenis yang sama, metode tersebut melemparkan obj ke jenis Point dan mengembalikan hasil perbandingan 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 mengembalikan true, metode tersebut membandingkan field instans z yang diperkenalkan pada 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($"{r1} = {r2}: {r1.Equals(r2)}");
      Console.WriteLine($"{r1} = {r3}: {r1.Equals(r3)}");
      Console.WriteLine($"{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 Visual Basic mendukung overload operator. Ketika jenis membebani operator kesetaraan, jenis juga harus mengambil alih Equals(Object) metode untuk menyediakan fungsionalitas yang sama. Ini biasanya dicapai dengan menulis metode Equals(Object) menggunakan operator kesetaraan yang di-overload, 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($"{cmplx1} <> {cmplx2}: {cmplx1 != cmplx2}");
    Console.WriteLine($"{cmplx1} = {cmplx2}: {cmplx1.Equals(cmplx2)}");

    cmplx2.re = 4.0;

    Console.WriteLine($"{cmplx1} = {cmplx2}: {cmplx1 == cmplx2}");
    Console.WriteLine($"{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, metode override Equals(Object) tidak perlu memanggil GetType untuk menentukan tipe runtime yang tepat dari setiap objek, tetapi dapat menggunakan operator is dalam C# atau operator TypeOf dalam Visual Basic untuk memeriksa tipe parameter obj.

  • Last updated on