System.Object.Equals-metoden

Anmärkning

Den här artikeln innehåller ytterligare kommentarer till referensdokumentationen för det här API:et.

Den här artikeln gäller metoden Object.Equals(Object) .

Typen av jämförelse mellan den aktuella instansen och parametern obj beror på om den aktuella instansen är en referenstyp eller en värdetyp.

  • Om den aktuella instansen Equals(Object) är en referenstyp, testas Equals(Object) metoden för referensjämlikhet och ett anrop till metoden motsvarar ett anrop till ReferenceEquals metoden. Referensjämlikhet innebär att objektvariablerna som jämförs refererar till samma objekt. I följande exempel visas resultatet av en sådan jämförelse. Den definierar en Person klass, som är en referenstyp, och anropar Person klasskonstruktorn för att instansiera två nya Person objekt person1a och person2, som har samma värde. Den tilldelar person1a även till en annan objektvariabel, person1b. Som utdata från exemplet visar person1a och person1b är lika eftersom de refererar till samma objekt. person1a och person2 är inte lika, men de har samma värde.

    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

  • Om den aktuella instansen Equals(Object) är en värdetyp testar metoden för värdejämlikhet. Värdejämlikhet innebär följande:

    • De två objekten är av samma typ. Som följande exempel visar är ett Byte objekt som har värdet 12 inte lika med ett Int32 objekt som har värdet 12, eftersom de två objekten har olika körningstyper.

      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

    • Värdena för de offentliga och privata fälten för de två objekten är lika med. I följande exempel testas värdejämlikhet. Den definierar en Person struktur, som är en värdetyp, och anropar Person klasskonstruktorn för att instansiera två nya Person objekt person1 och person2, som har samma värde. Som utdata från exemplet visar, även om de två objektvariablerna refererar till olika objekt person1 och person2 är lika eftersom de har samma värde för det privata personName fältet.

      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 Eftersom klassen är basklassen för alla typer i .NET tillhandahåller Object.Equals(Object) metoden standardjämlikhetsjämförelse för alla andra typer. Typer åsidosätter Equals dock ofta metoden för att implementera värdejämlikhet. Mer information finns i avsnitten Anteckningar för uppringare och anteckningar för arvtagare.

Anteckningar för Windows Runtime

När du anropar Equals(Object) metodens överbelastning på en klass i Windows Runtime, ger den standardbeteendet för klasser som inte åsidosätter Equals(Object). Detta är en del av det stöd som .NET tillhandahåller för Windows Runtime (se .NET-stöd för Windows Store-appar och Windows Runtime). Klasser i Windows Runtime ärver inte Object och implementerar för närvarande inte någon Equals(Object)-metod. De verkar dock ha ToStringmetoder för , Equals(Object)och GetHashCode när du använder dem i C# eller Visual Basic-koden, och .NET tillhandahåller standardbeteendet för dessa metoder.

Anmärkning

Windows Runtime-klasser som är skrivna i C# eller Visual Basic kan åsidosätta metodens Equals(Object) överlagring.

Anteckningar för uppringare

Härledda klasser åsidosätter Object.Equals(Object) ofta metoden för att implementera värdejämlikhet. Dessutom tillhandahåller typer också ofta en ytterligare starkt typad överlagring av Equals-metoden, vanligtvis genom att implementera IEquatable<T>-gränssnittet. När du anropar Equals metoden för att testa för likhet bör du veta om den aktuella instansen åsidosätter Object.Equals och förstå hur ett visst anrop till en Equals metod löses. Annars kanske du utför ett test för likhet som skiljer sig från det du avsåg, och metoden kan returnera ett oväntat värde.

I följande exempel visas en bild. Den instansierar tre StringBuilder objekt med identiska strängar och gör sedan fyra anrop till Equals metoder. Det första metodanropet returnerar true, och de återstående tre returnerar 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

I det första fallet anropas den starkt typerade StringBuilder.Equals(StringBuilder) metodöverlagringen, som testar för värdejämlikhet. Eftersom de strängar som tilldelats de två StringBuilder-objekten är lika bör metoden returnera true. Dock åsidosätter StringBuilder inte Object.Equals(Object). Därför anropas standardmetoden StringBuilder när Object objektet omvandlas till en StringBuilder, när en Object instans tilldelas till en variabel av typen Object.Equals(Object, Object), och när StringBuilder metoden skickas två Object.Equals(Object) objekt. Eftersom StringBuilder är en referenstyp motsvarar detta att skicka de två StringBuilder objekten ReferenceEquals till metoden. Även om alla tre StringBuilder objekten innehåller identiska strängar refererar de till tre distinkta objekt. Som ett resultat returnerar dessa tre metodanrop false.

Du kan jämföra det aktuella objektet med ett annat objekt för referensjämlikhet genom att anropa ReferenceEquals metoden. I Visual Basic kan du också använda nyckelordet is (till exempel If Me Is otherObject Then ...).

Anteckningar för arvtagare

När du definierar din egen typ ärver den typens funktionalitet som definieras av Equals-metoden hos dess bastyp. I följande tabell visas standardimplementeringen av Equals metoden för de viktigaste typerna av typer i .NET.

Typkategori Likhet definierad av Kommentarer
Klass härledd direkt från Object Object.Equals(Object) Referensjämlikhet; motsvarar att anropa Object.ReferenceEquals.
Struktur ValueType.Equals Värdejämlikhet; antingen direkt byte-by-byte-jämförelse eller fält-för-fält-jämförelse med reflektion.
Uppräkning Enum.Equals Värdena måste ha samma uppräkningstyp och samma underliggande värde.
Delegera MulticastDelegate.Equals Ombud måste ha samma typ med identiska anropslistor.
Gränssnitt Object.Equals(Object) Referensjämlikhet.

För en värdetyp bör du alltid åsidosätta Equals, eftersom tester för likhet som förlitar sig på reflektion ger dåliga prestanda. Du kan också åsidosätta standardimplementeringen för Equals referenstyper för att testa värdejämlikhet i stället för referensjämlikhet och definiera den exakta innebörden av värdejämlikhet. Sådana implementeringar av Equals retur true om de två objekten har samma värde, även om de inte är samma instans. Typens implementer bestämmer vad som utgör ett objekts värde, men det är vanligtvis vissa eller alla data som lagras i objektets instansvariabler. Värdet för ett String objekt baseras till exempel på strängens tecken. String.Equals(Object) Metoden åsidosätter Object.Equals(Object) metoden för att returnera true för två stränginstanser som innehåller samma tecken i samma ordning.

I följande exempel visas hur du åsidosätter Object.Equals(Object) metoden för att testa värdejämlikhet. Den åsidosätter Equals -metoden för Person klassen. Om Person accepterade sin grundläggande klassimplementering av likhet skulle två Person objekt endast vara lika ifall de refererade till ett enda objekt. Men i det här fallet är två Person objekt lika om de har samma värde för egenskapen 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

Förutom att åsidosätta Equals kan du implementera IEquatable<T>-gränssnittet för att tillhandahålla ett starkt typat test för likhet.

Följande instruktioner måste vara sanna för alla implementeringar av Equals(Object) metoden. I listan representerar x, yoch z objektreferenser som inte är null.

  • x.Equals(x) returnerar true.

  • x.Equals(y) returnerar samma värde som y.Equals(x).

  • x.Equals(y) returnerar true om både x och y är NaN.

  • Om (x.Equals(y) && y.Equals(z)) returnerar truereturnerar sedan x.Equals(z)true.

  • Efterföljande anrop för att x.Equals(y) returnera samma värde så länge som objekten som refereras av x och y inte ändras.

  • x.Equals(null) returnerar false.

Implementeringar av Equals får inte utlösa undantag. De bör alltid returnera ett värde. Om obj är null ska metoden Equals returnera false i stället för att utlösa en ArgumentNullException.

Följ dessa riktlinjer när du åsidosätter Equals(Object):

  • Typer som implementerar IComparable måste åsidosätta Equals(Object).

  • Typer som åsidosätter Equals(Object) måste också åsidosätta GetHashCode. Annars kanske hash-tabeller inte fungerar korrekt.

  • Du bör överväga att implementera IEquatable<T> gränssnittet för att stödja starkt skrivna tester för likhet. Implementeringen IEquatable<T>.Equals bör returnera resultat som är konsekventa med Equals.

  • Om programmeringsspråket stöder överlagring av operatorn och du överbelastar likhetsoperatorn för en viss typ måste du också åsidosätta Equals(Object) metoden för att returnera samma resultat som likhetsoperatorn. Detta säkerställer att klassbibliotekskoden som använder Equals (till exempel ArrayList och Hashtable) fungerar på ett sätt som överensstämmer med hur likhetsoperatorn används av programkoden.

Riktlinjer för referenstyper

Följande riktlinjer gäller för åsidosättande Equals(Object) av en referenstyp:

  • Överväg att Equals åsidosätta om typens semantik baseras på det faktum att typen representerar vissa värden.

  • De flesta referenstyper får inte överbelasta likhetsoperatorn, även om de åsidosätter Equals. Men om du implementerar en referenstyp som är avsedd att ha värdesemantik, till exempel en komplex taltyp, måste du åsidosätta likhetsoperatorn.

  • Du bör inte åsidosätta Equals en föränderlig referenstyp. Det beror på att åsidosätta Equals kräver att du också åsidosätter metoden GetHashCode, enligt beskrivningen i föregående avsnitt. Det innebär att hash-koden för en instans av en föränderlig referenstyp kan ändras under dess livslängd, vilket kan leda till att objektet går förlorat i en hash-tabell.

Riktlinjer för värdetyper

Följande riktlinjer gäller för åsidosättande Equals(Object) av en värdetyp:

  • Om du definierar en värdetyp som innehåller ett eller flera fält vars värden är referenstyper bör du åsidosätta Equals(Object). Implementeringen Equals(Object) som tillhandahålls av ValueType utför en byte-för-byte-jämförelse för värdetyper vars fält är alla värdetyper, men den använder reflektion för att utföra en jämförelse fält för fält av värdetyper vars fält innehåller referenstyper.

  • Om du åsidosätter Equals och ditt utvecklingsspråk stöder överlagring av operatorn måste du överbelasta likhetsoperatorn.

  • Du bör implementera IEquatable<T> gränssnittet. Om du anropar den starkt typade IEquatable<T>.Equals metoden undviker du att boxa obj argumentet.

Exempel

I följande exempel visas en Point klass som åsidosätter Equals metoden för att ge värdejämlikhet och en Point3D klass som härleds från Point. Eftersom Point åsidosätter Object.Equals(Object) för att testa likhet av värden, anropas inte metoden Object.Equals(Object). Dock anropar Point3D.EqualsPoint.Equals eftersom Point implementerar Object.Equals(Object) på ett sätt som ger värdejämlikhet.

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 HashCode.Combine(x, 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 HashCode.Combine(base.GetHashCode(), 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() =
        System.HashCode.Combine(x, 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() =
        System.HashCode.Combine(base.GetHashCode(), 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 HashCode.Combine(x, 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 HashCode.Combine(MyBase.GetHashCode(), 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

Metoden Point.Equals kontrollerar att obj argumentet inte är null och att det refererar till en instans av samma typ som det här objektet. Om någon av kontroller misslyckas returnerar falsemetoden .

Metoden Point.Equals anropar metoden GetType för att avgöra om de två objektens körtyper är identiska. Om metoden använde en kontroll av typen obj is Point i C# eller TryCast(obj, Point) i Visual Basic skulle kontrollen returnera true i fall där obj är en instans av en härledd klass av Point, även om obj och den aktuella instansen inte är av samma körningstyp. Efter att ha kontrollerat att båda objekten är av samma typ, typas `obj` om till `Point` och metoden returnerar resultatet av att jämföra instansfälten för de två objekten.

I Point3D.Equalsanropas den ärvda Point.Equals metoden, som åsidosätter Object.Equals(Object), innan något annat görs. Eftersom Point3D är en förseglad klass (NotInheritable i Visual Basic) är en kontroll i formuläret obj is Point i C# eller TryCast(obj, Point) Visual Basic tillräcklig för att säkerställa att det obj är ett Point3D objekt. Om det är ett Point3D objekt skickas det till ett Point objekt och skickas till basklassimplementeringen av Equals. Endast när den ärvda Point.Equals metoden returnerar true jämför metoden instansfälten z som introducerades i den härledda klassen.

I följande exempel definieras en Rectangle klass som internt implementerar en rektangel som två Point objekt. Klassen Rectangle åsidosätter Object.Equals(Object) också för att ange värdejämlikhet.

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

Vissa språk som C# och Visual Basic stöder överlagring av operatorer. När en typ överbelastar likhetsoperatorn måste den också åsidosätta Equals(Object)-metoden för att tillhandahålla samma funktionalitet. Detta uppnås vanligtvis genom att skriva Equals(Object) metoden i termer av den överbelastade likhetsoperatorn, som i följande exempel.

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

Eftersom Complex är en värdetyp kan den inte härledas från. Metodens åsidosättning Equals(Object) behöver därför inte anropa GetType för att fastställa den exakta körtidstypen för varje objekt, utan kan i stället använda operatorn is i C# eller operatorn TypeOf i Visual Basic för att kontrollera typen på parametern obj.

  • Last updated on