Object.Equals-Methode (Object)

Der Typ des Vergleichs zwischen der aktuellen Instanz und dem obj-Parameter hängt davon ab, ob die aktuelle Instanz ein Verweistyp oder ein Werttyp ist. Wenn die aktuelle Instanz ein Verweistyp ist, ist die Equals(Object)-Methodentests für Verweisgleichheit und ein Aufruf der - Equals(Object)-Methode zu einem Aufruf der - Methode. ReferenceEquals Verweisgleichheit bedeutet, dass die Objektvariablen, die verglichen werden, das gleiche Objekt verweisen. Das folgende Beispiel veranschaulicht das Ergebnis eines solchen Vergleichs. Es definiert eine Klasse Person, die ein Verweistyp ist, und ruft den Person-Klassenkonstruktor auf, um zwei neue Person-Objekte, person1a und person2, zu instanziieren, die denselben Wert haben. Sie weist auch person1a zu einer anderen Objektvariablen, person1b zu. Wie die Ausgabe im Beispiel zeigt, person1a und person1b sind gleich, da sie auf dasselbe Objekt verweisen. Allerdings sind person1a und person2 nicht gleich, obwohl sie denselben Wert haben.

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 Example
{
   public static void Main()
   {
      Person person1a = new Person("John");
      Person person1b = person1a;
      Person person2 = new Person(person1a.ToString());

      Console.WriteLine("Calling Equals:"); 
      Console.WriteLine("person1a and person1b: {0}", person1a.Equals(person1b));               
      Console.WriteLine("person1a and person2: {0}", person1a.Equals(person2));  

      Console.WriteLine("\nCasting to an Object and calling Equals:");
      Console.WriteLine("person1a and person1b: {0}", ((object) person1a).Equals((object) person1b));
      Console.WriteLine("person1a and person2: {0}", ((object) person1a).Equals((object) person2)); 
   }
}
// The example displays the following output:
//       person1a and person1b: True
//       person1a and person2: False
//       
//       Casting to an Object and calling Equals:
//       person1a and person1b: True
//       person1a and person2: False

Wenn die aktuelle Instanz ein Werttyp ist, dann testet die Equals(Object)-Methode auf Wertgleichheit. Wertgleichheit bedeutet Folgendes:

• Die beiden Objekte sind vom gleichen Typ.

  Wie das folgende Beispiel zeigt, entspricht ein Byte Objekt, das einen Wert von 12 hat nicht einem

  Int32 Objekt, das ebenfalls einen Wert von 12 hat, da die beiden Objekte verschiedene Laufzeittypen haben.

  C#

  VB

  Kopieren

  
  using System;
  
  public class Example
  {
     public static void Main()
     {
        byte value1 = 12;
        int value2 = 12;
  
        object object1 = value1;
        object object2 = value2;
  
        Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                          object1, object1.GetType().Name,
                          object2, object2.GetType().Name,
                          object1.Equals(object2));
     }
  }
  // The example displays the following output:
  //        12 (Byte) = 12 (Int32): False
  
  
  

• Die Werte der öffentlichen und privaten Felder der beiden Objekte sind gleich. Im folgenden Beispiel wird die Wertgleichheit überprüft. Sie definiert eine Person-Struktur, die ein Werttyp ist, und ruft den Person-Klassenkonstruktor auf, um zwei neue Person-Objekte, person1 und person2, zu instanziieren, die denselben Wert haben. Wie die Ausgabe im Beispiel zeigt, obwohl die zwei Objektvariablen verschiedene Objekte verweisen, person1 und person2 gleich sind, da sie den gleichen Wert für das private personName Feld verfügen.

  C#

  VB

  Kopieren

  
  using System;
  
  // Define a value type that does not override Equals.
  public struct Person
  {
     private string personName;
  
     public Person(string name)
     {
        this.personName = name;
     }
  
     public override string ToString()
     {
        return this.personName;
     }
  }
  
  public struct Example
  {
     public static void Main()
     {
        Person person1 = new Person("John");
        Person person2 = new Person("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
  
  
  

Da die Object-Klasse ist, die Basisklasse für alle Typen in .NET Framework, die Object.Equals(Object)-Methode zur Verfügung stellt den Standardgleichheitsvergleich für alle anderen Typen. jedoch überschreiben Typen häufig die Equals-Methode, um Wertgleichheit zu implementieren. Weitere Informationen finden Sie in den Hinweisen für Aufrufer und die Hinweise für Erbenabschnitte.

Hinweise für Aufrufer

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb1 = new StringBuilder("building a string...");
      StringBuilder sb2 = new StringBuilder("building a string...");

      Console.WriteLine("sb1.Equals(sb2): {0}", sb1.Equals(sb2));
      Console.WriteLine("((Object) sb1).Equals(sb2): {0}", 
                        ((Object) sb1).Equals(sb2));
      Console.WriteLine("Object.Equals(sb1, sb2): {0}",
                        Object.Equals(sb1, sb2));      

      Object sb3 = new StringBuilder("building a string...");
      Console.WriteLine("\nsb3.Equals(sb2): {0}", sb3.Equals(sb2));                              
   }
}
// The example displays the following output:
//       sb1.Equals(sb2): True
//       ((Object) sb1).Equals(sb2): False
//       Object.Equals(sb1, sb2): False
//
//       sb3.Equals(sb2): False

Hinweise zur Vererbung

public class Person
{
   private string idNumber;
   private string personName;

   public Person(string name, string id)
   {
      this.personName = name;
      this.idNumber = id;
   }

   public override bool Equals(Object obj)
   {
      Person personObj = obj as Person; 
      if (personObj == null)
         return false;
      else
         return idNumber.Equals(personObj.idNumber);
   }

   public override int GetHashCode()
   {
      return this.idNumber.GetHashCode(); 
   }
}

public class Example
{
   public static void Main()
   {
      Person p1 = new Person("John", "63412895");
      Person p2 = new Person("Jack", "63412895");
      Console.WriteLine(p1.Equals(p2));
      Console.WriteLine(Object.Equals(p1, p2));
   }
}
// The example displays the following output:
//       True
//       True

Im folgenden Beispiel wird eine Point-Klasse, die die Equals-Methode überschreibt, um Wertgleichheit bereitzustellen, und eine Point3D-Klasse an, die von Point abgeleitet wird. Da PointObject.Equals(Object) überschreibt, um der Wertgleichheit zu testen, wird die Object.Equals(Object)-Methode nicht aufgerufen. Es ruft Point3D.EqualsPoint.Equals auf, da PointObject.Equals(Object) in ähnlicher Weise implementiert, das Wertgleichheit bereitstellt.

using System;

class Point
{
   protected int x, y;

   public Point() {
     this.x = 0;
     this.y = 0;
   }

   public Point(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() != obj.GetType()) { 
         return false;
      }   
      else {
      Point p = (Point) obj;
      return (x == p.x) && (y == p.y);
      }
   }

   public override int GetHashCode() {
      return x ^ y;
   }
}

class Point3D: Point 
{
   int z;

   public Point3D(int X, int Y, int Z) {
      this.x = X;
      this.y = Y;
      this.z = Z; 
   }

   public override bool Equals(Object obj) {
      return base.Equals(obj) && z == ((Point3D)obj).z;
   }

   public override int GetHashCode() {
      return base.GetHashCode() ^ z;
   }
}

class Example 
{
  public static void Main() 
  {
     Point point2D = new Point(5, 5);
     Point3D point3Da = new Point3D(5, 5, 2);
     Point3D point3Db = new Point3D(5, 5, 2);

     if (!point2D.Equals(point3Da)) {
        Console.WriteLine("point2D does not equal point3Da");
     }
     if (!point3Db.Equals(point2D)) {
        Console.WriteLine("point3Db does not equal point2D");
     }
     if (point3Da.Equals(point3Db)) {
        Console.WriteLine("point3Da equals point3Db");
     }

  } 
}
// The example displays the following output:
//       point2D does not equal point3Da
//       point3Db does not equal point2D
//       point3Da equals point3Db

Die Point.Equals-Methodenüberprüfungen, sicherzustellen, dass das obj-Argument nicht NULL ist und ob es eine Instanz des gleichen Typs wie dieses Objekt verweist. Wenn jede Überprüfung fehlschlägt, gibt die Methode false zurück.

Die Point.Equals-Methode ruft die - Methode, GetType zu bestimmen, ob die Laufzeittypen der zwei Objekte identisch sind. Wenn die - Methode eine Überprüfung des Formulars obj is Point in C# oder des TryCast(obj, Point) in Visual Basic verwendet wird, wird die Überprüfung true zurückgeben, wenn obj eine Instanz einer abgeleiteten Klasse Point ist, obwohl obj und die aktuelle Instanz nicht vom gleichen Laufzeittyp sind. Nachdem bestätigt wurde, dass beide Objekte denselben Typ haben, wandelt diese Methode obj in den Typ Point um und gibt das Ergebnis des Vergleichs der Instanzvariablen der beiden Objekte zurück.

In Point3D.Equals wird die geerbte - Methode Point.Equals, die Object.Equals(Object) überschreibt, aufgerufen, bevor sonstige erfolgt. Die geerbten Point.Equals-Methodenüberprüfungen, sicherzustellen, dass obj nicht NULL ist, dass obj eine Instanz der gleichen Klasse wie dieses Objekt ist und dass die geerbten Instanzvariablen übereinstimmen. Nur wenn die geerbte Point.Equals-Methode zurückgibt, wird die - Methode true vergleichen die Instanzvariablen, die in der abgeleiteten Klasse eingegeben werden. Genauer gesagt wird die Umwandlung in Point3D nur dann ausgeführt, wenn festgestellt wurde, dass obj den Typ Point3D aufweist oder eine von Point3D abgeleitete Klasse ist.

Im folgenden Beispiel wird eine Rectangle-Klasse, die intern ein Rechteck als zwei Point-Objekte implementiert. Die Rectangle-Klasse überschreibt auch Object.Equals(Object), um der Wertgleichheit bereitzustellen.

using System;

class Rectangle 
{
   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) {
     // Performs an equality check on two rectangles (Point object pairs).
      if (obj == null || GetType() != obj.GetType()) 
          return false;
      Rectangle r = (Rectangle)obj;
      //Uses Equals to compare variables.
      return a.Equals(r.a) && b.Equals(r.b);
   }

   public override int GetHashCode() {
      return a.GetHashCode() ^ b.GetHashCode();
   }
}

class Point 
{
  private int x;
  private 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 x.GetHashCode() ^ 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);

      if (r1.Equals(r2)) {
         Console.WriteLine("Rectangle r1 equals rectangle r2!");
      }
      if (!r2.Equals(r3)) {
         Console.WriteLine("But rectangle r2 does not equal rectangle r3.");
      }
   }
}
// The example displays the following output:
//       Rectangle r1 equals rectangle r2!
//       But rectangle r2 does not equal rectangle r3.

Einige Sprachen wie C# und Visual Basic unterstützen Operatorüberladung. Wenn ein Typ den Gleichheitsoperator überlädt, muss er auch dieEquals(Object)-Methode außer Kraft setzen, um dort dieselben Funktionen bereitzustellen. Dies geschieht i. d. R., indem die Equals(Object)-Methode wie im folgenden Beispiel als überladener Gleichheitsoperator geschrieben wird.

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 re.GetHashCode() ^ 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);
   }
}

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;

    if (cmplx1 != cmplx2)
      Console.WriteLine("The two objects are not equal.");
    if (! cmplx1.Equals(cmplx2))
      Console.WriteLine("The two objects are not equal.");

    cmplx2.re = 4.0;

    if (cmplx1 == cmplx2) 
      Console.WriteLine("The two objects are now equal!");
    if (cmplx1.Equals(cmplx2)) 
      Console.WriteLine("The two objects are now equal!");
  }
}
// The example displays the following output:
//       The two objects are not equal.
//       The two objects are not equal.
//       The two objects are now equal!
//       The two objects are now equal!

Da Complex ein Werttyp ist, kann nicht von abgeleitet werden. Daher muss die Überschreibung zu Equals(Object) Möglichkeit, nicht GetType aufzurufen, um den genauen Laufzeittyp jedes Objekts zu bestimmen, und kann den is-Operator in C# oder den TypeOf-Operator in Visual Basic stattdessen verwenden, um den Typ des Parameters obj zu überprüfen.

.NET Framework

.NET Framework Client Profile

Portable Klassenbibliothek

.NET für Windows Store-Apps

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

Referenz