Sdílet prostřednictvím

Metoda System.Object.Equals

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Tento článek se týká Object.Equals(Object) metody.

Typ porovnání mezi aktuální instancí a obj parametrem závisí na tom, zda je aktuální instance referenčním typem nebo typem hodnoty.

  • Pokud je aktuální instance referenčním typem, Equals(Object) metoda testuje rovnost odkazů a volání Equals(Object) metody je ekvivalentní volání ReferenceEquals metody. Rovnost odkazů znamená, že proměnné objektů, které jsou porovnány, odkazují na stejný objekt. Následující příklad znázorňuje výsledek takového porovnání. Person Definuje třídu, která je referenčním typem, a volá Person konstruktor třídy k vytvoření instance dvou nových Person objektů a person1aperson2, které mají stejnou hodnotu. Také se přiřazuje person1a k jiné proměnné objektu, person1b. Jak ukazuje výstup z příkladu, person1a a person1b jsou stejné, protože odkazují na stejný objekt. person1a a person2 nejsou stejné, i když mají stejnou hodnotu.

    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

  • Pokud je aktuální instance typ hodnoty, Equals(Object) metoda testuje rovnost hodnot. Rovnost hodnot znamená následující:

    • Dva objekty mají stejný typ. Jak ukazuje následující příklad, Byte objekt s hodnotou 12 se nerovná Int32 objektu, který má hodnotu 12, protože oba objekty mají různé typy modulu runtime.

      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

    • Hodnoty veřejných a privátních polí těchto dvou objektů jsou stejné. Následující příklad testuje rovnost hodnot. Definuje Person strukturu, což je typ hodnoty, a volá Person konstruktor třídy, aby vytvořil instanci dvou nových objektů Person, person1 a person2, které mají stejnou hodnotu. Jak ukazuje výstup z příkladu, i když dvě proměnné objektu odkazují na různé objekty, person1 a person2 jsou si rovny, protože mají stejnou hodnotu pro soukromé personName pole.

      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

Vzhledem k tomu, že Object třída je základní třídou pro všechny typy v .NET, Object.Equals(Object) metoda poskytuje výchozí porovnání rovnosti pro všechny ostatní typy. Typy však často přepíší metodu Equals pro implementaci rovnosti hodnot. Další informace najdete v částech Poznámky pro volající a Poznámky pro dědiče.

Poznámky k prostředí Windows Runtime

Při volání přetížené verze metody na třídě v prostředí Windows Runtime se poskytuje výchozí chování pro ty třídy, které nepřepisují Equals(Object). Toto je součástí podpory, kterou .NET poskytuje pro prostředí Windows Runtime (viz podpora aplikací pro Windows Store a prostředí Windows Runtime). Třídy v prostředí Windows Runtime nedědí Objecta v současné době neimplementují metodu Equals(Object) . Zdá se však, že mají ToStringEquals(Object), a GetHashCode metody, když je použijete v kódu jazyka C# nebo Visual Basic, a .NET poskytuje výchozí chování pro tyto metody.

Poznámka:

Třídy prostředí Windows Runtime napsané v jazyce C# nebo Visual Basic mohou přepsat Equals(Object) přetížené metody.

Poznámky pro volající

Odvozené třídy často přepíší metodu Object.Equals(Object) pro implementaci rovnosti hodnot. Kromě toho typy často poskytují další přetížení pro metodu Equals se silným typováním, což obvykle provádějí implementací rozhraní IEquatable<T>. Když voláte metodu Equals pro testování rovnosti, měli byste vědět, jestli aktuální instance přepisuje Object.Equals a také pochopit, jak se řeší konkrétní volání metody Equals. Jinak můžete provést test rovnosti, který se liší od toho, co jste chtěli, a metoda může vrátit neočekávanou hodnotu.

V následujícím příkladu je uvedena ukázka. Vytvoří instanci tří StringBuilder objektů s identickými řetězci a pak provede čtyři volání Equals metod. První volání metody vrátí true, a zbývající tři vrátí 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

V prvním případě se volá přetížení metody silného typu StringBuilder.Equals(StringBuilder) , které testuje rovnost hodnot. Vzhledem k tomu, že řetězce přiřazené k dvěma StringBuilder objektům jsou stejné, metoda vrátí true. Nicméně, StringBuilder nepřepíše Object.Equals(Object). Z tohoto důvodu, když je StringBuilder objekt přetypován na Object, když je instance StringBuilder přiřazena proměnné typu Object, a když jsou metodě Object.Equals(Object, Object) předány dva objekty StringBuilder, je volána výchozí metoda Object.Equals(Object). Vzhledem k tomu StringBuilder , že jde o typ odkazu, je to ekvivalentem předání dvou StringBuilder objektů metodě ReferenceEquals . I když všechny tři StringBuilder objekty obsahují identické řetězce, odkazují na tři odlišné objekty. V důsledku toho tyto tři volání metod vrátí false.

Aktuální objekt můžete porovnat s jiným objektem pro rovnost odkazů voláním ReferenceEquals metody. V jazyce Visual Basic můžete také použít is klíčové slovo (například If Me Is otherObject Then ...).

Poznámky pro dědiče

Když definujete vlastní typ, tento typ dědí funkce definované metodou Equals základního typu. Následující tabulka uvádí výchozí implementaci Equals metody pro hlavní kategorie typů v .NET.

Typ kategorie Rovnost definovaná podle Komentáře
Třída odvozená přímo z Object Object.Equals(Object) Rovnost odkazů; odpovídá volání Object.ReferenceEquals.
Struktura ValueType.Equals Rovnost hodnoty; buď přímé porovnávání bajt po bajtu, nebo porovnávání pole po poli pomocí reflexe.
Výčet Enum.Equals Hodnoty musí mít stejný typ výčtu a stejnou podkladovou hodnotu.
Delegát MulticastDelegate.Equals Delegáti musí mít stejný typ se stejnými seznamy volání.
Rozhraní Object.Equals(Object) Rovnost odkazů.

U typu hodnoty byste měli vždy přepsat Equals, protože testy rovnosti, které spoléhají na reflexi, nabízejí nízký výkon. Můžete také přepsat výchozí implementaci na Equals u odkazových typů, abyste testovali rovnost hodnot namísto rovnosti odkazů a definovali přesný význam rovnosti hodnot. Takové implementace Equals vrátí true, pokud oba objekty mají stejnou hodnotu, i když nejsou stejnou instancí. Implementátor typu rozhoduje, co představuje hodnotu objektu, ale obvykle se jedná o některá nebo všechna data uložená v proměnných instance objektu. Například hodnota objektu String je založená na znacích řetězce; String.Equals(Object) metoda přepíše Object.Equals(Object) metodu tak, aby se vrátila true pro všechny dvě instance řetězců, které obsahují stejné znaky ve stejném pořadí.

Následující příklad ukazuje, jak přepsat metodu Object.Equals(Object), aby byla testována rovnost hodnot. Přepisuje metodu Equals třídy Person. Pokud Person by byla přijata implementace rovnosti základní třídy, dva Person objekty by byly stejné pouze v případě, že odkazují na jeden objekt. V tomto případě jsou však dva Person objekty stejné, pokud mají stejnou hodnotu vlastnosti 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

Kromě přepsání Equals můžete implementovat rozhraní IEquatable<T>, které poskytuje silně typový test pro rovnost.

Následující příkazy musí být pravdivé pro všechny implementace Equals(Object) metody. V seznamu x, y a z představují reference objektů, které nejsou null.

  • x.Equals(x) vrátí true.

  • x.Equals(y) vrátí stejnou hodnotu jako y.Equals(x).

  • x.Equals(y) vrátí true, pokud jsou x a yNaN.

  • Pokud (x.Equals(y) && y.Equals(z)) vrátí hodnotu true, vrátí x.Equals(z) hodnotu true.

  • Následná volání x.Equals(y) vrátí stejnou hodnotu, pokud se objekty, na které odkazují x a y, nezmění.

  • x.Equals(null) vrátí false.

Equals Implementace nesmí vyvolat výjimky. Vždy by měly vrátit hodnotu. Pokud je obj například null, měla by metoda Equals vrátit false místo vyvolání ArgumentNullException.

Při přepisování Equals(Object) postupujte podle těchto pokynů:

  • Typy, které implementují IComparable , musí přepsat Equals(Object).

  • Typy, které přepíší Equals(Object), musí také přepsat GetHashCode; jinak nemusí hašovací tabulky fungovat správně.

  • Měli byste zvážit implementaci IEquatable<T> rozhraní pro podporu testů silného typu pro rovnost. Vaše IEquatable<T>.Equals implementace by měla vrátit výsledky, které jsou konzistentní s Equals.

  • Pokud váš programovací jazyk podporuje přetížení operátoru a přetížíte operátor rovnosti pro daný typ, musíte také přepsat Equals(Object) metodu tak, aby vrátil stejný výsledek jako operátor rovnosti. To pomáhá zajistit, aby se kód knihovny tříd, který používá Equals (například ArrayList a Hashtable) choval způsobem, který je konzistentní se způsobem, jakým je operátor rovnosti používán kódem aplikace.

Pokyny pro referenční typy

Pro přepsání Equals(Object) typu odkazu platí následující pokyny:

  • Zvažte přepsání Equals , pokud jsou sémantika typu založená na skutečnosti, že typ představuje některé hodnoty.

  • Většina odkazových typů nesmí přetížit operátor rovnosti, i když přepíše Equals. Pokud však implementujete odkazový typ, který má mít sémantiku hodnot, například komplexní typ čísla, musíte přepsat operátor rovnosti.

  • U mutovatelného referenčního typu byste neměli přepsat Equals. Důvodem je, že pokud přepíšete Equals, musíte také přepsat metodu GetHashCode, jak je popsáno v předchozí části. To znamená, že kód hash instance proměnlivého referenčního typu se může během své životnosti změnit, což může způsobit ztrátu objektu v tabulce hash.

Pokyny pro typy hodnot

Pro přepsání Equals(Object) typu hodnoty platí následující pokyny:

  • Pokud definujete typ hodnoty, který obsahuje jedno nebo více polí, jejichž hodnoty jsou odkazové typy, měli byste přepsat Equals(Object). Implementace Equals(Object), kterou ValueType poskytuje, provádí bajtové porovnání pro hodnotové typy, jejichž pole jsou všechny hodnotové typy, ale používá reflexi k provedení porovnání hodnotových typů po jednotlivých polích, jejichž pole obsahují odkazové typy.

  • Pokud přepíšete Equals a váš vývojový jazyk podporuje přetížení operátorů, musíte přetížit operátor rovnosti (==).

  • Měli byste implementovat IEquatable<T> rozhraní. Volání silně typované metody IEquatable<T>.Equals zabrání zabalení argumentu obj.

Příklady

Následující příklad ukazuje Point třídu, která přepíše metodu Equals tak, aby poskytovala rovnost hodnot, a Point3D třídu, která je odvozena z Point. Protože Point přepisuje Object.Equals(Object) za účelem testování rovnosti hodnot, metoda Object.Equals(Object) není volána. Nicméně Point3D.Equals volá Point.Equals protože Point implementuje Object.Equals(Object) způsobem, který poskytuje rovnost hodnot.

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

Metoda Point.Equals zkontroluje, zda obj argument není null a že odkazuje na instanci stejného typu jako tento objekt. Pokud se některé z kontrol nezdaří, vrátí metoda false.

Metoda Point.Equals volá metodu GetType k určení, zda jsou typy modulu runtime těchto dvou objektů identické. Pokud metoda použila kontrolu formuláře obj is Point v jazyce C# nebo TryCast(obj, Point) v jazyce Visual Basic, vrátí se kontrola true v případech, kdy obj je instance odvozené třídy Point, i když obj a aktuální instance nejsou stejného typu modulu runtime. Poté, co se ověří, že oba objekty jsou stejného typu, metoda přetypuje \obj na typ \Point a vrátí výsledek porovnání polí instance těchto dvou objektů.

V Point3D.Equals je zděděná metoda Point.Equals, která přepisuje Object.Equals(Object), vyvolána dříve, než je provedeno cokoliv jiného. Point3D je zapečetěná třída (NotInheritable v jazyce Visual Basic), takže kontrola ve formě obj is Point v jazyce C# nebo TryCast(obj, Point) v jazyce Visual Basic je adekvátní k zajištění, že obj je Point3D objekt. Pokud je Point3D objekt, je přetypován na Point objekt a předán do implementace Equals základní třídy. Pouze pokud zděděná metoda Point.Equals vrátí true, porovnává metoda pole instance z zavedená v odvozené třídě.

Následující příklad definuje Rectangle třídu, která interně implementuje obdélník jako dva Point objekty. Třída Rectangle také přepíše Object.Equals(Object) , aby poskytovala rovnost hodnot.

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

Některé jazyky, jako například C# a Visual Basic, podporují přetížení operátorů. Pokud typ přetíží operátor rovnosti, musí také přepsat metodu Equals(Object), aby poskytovala stejnou funkčnost. Toho se obvykle dosahuje napsáním Equals(Object) metody z hlediska přetíženého operátoru rovnosti, jak je znázorněno v následujícím příkladu.

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

Vzhledem k tomu Complex , že je typ hodnoty, nelze jej odvodit. Proto přepsání metody Equals(Object) nemusí volat GetType k určení přesného typu modulu runtime každého objektu, ale může místo toho použít is operátor v jazyce C# nebo TypeOf operátor v jazyce Visual Basic ke kontrole typu parametru obj .

  • Last updated on