(0) exportieren Drucken
Alle erweitern

Object.Equals-Methode (Object)

Bestimmt, ob das angegebene Object und das aktuelle Object gleich sind.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

public virtual bool Equals (
	Object obj
)
public boolean Equals (
	Object obj
)
public function Equals (
	obj : Object
) : boolean
Nicht zutreffend.

Parameter

obj

Das Object, das mit dem aktuellen Object verglichen werden soll.

Rückgabewert

true, wenn das angegebene Object gleich dem aktuellen Object ist, andernfalls false.

Die Standardimplementierung von Equals unterstützt Verweisgleichheit für Verweistypen und bitweise Gleichheit für Werttypen. Verweisgleichheit ist gegeben, wenn die zu vergleichenden Objektverweise auf dasselbe Objekt verweisen. Bitweise Gleichheit ist gegeben, wenn die binären Darstellungen der zu vergleichenden Objekte identisch sind.

Beachten Sie, dass ein abgeleiteter Typ die Equals-Methode u. U. überschreibt, um Wertgleichheit zu implementieren. Wertgleichheit ist gegeben, wenn die zu vergleichenden Objekte denselben Wert haben. Die binären Darstellungen müssen hierbei nicht unbedingt identisch sein. Betrachten Sie z. B. zwei Decimal-Objekte, die die Zahlen 1.10 und 1.1000 darstellen. Die Decimal-Objekte sind nicht bitweise gleich, da ihre binären Darstellungen durch die unterschiedliche Anzahl nachfolgender Nullen voneinander abweichen. Die Objekte sind jedoch wertgleich, da die Zahlen 1.10 und 1.1000 ungeachtet der nachfolgenden Nullen denselben Wert darstellen.

Hinweise zur Implementierung: Diese Methode kann von einer abgeleiteten Klasse überschrieben werden. Viele Basisdatentypen geben z. B. true zurück, wenn beide Objekte denselben Wert darstellen, andernfalls false. Diese Methode vergleicht nur primitive Datentypen und Objekte. Sie muss zum Vergleichen komplexerer Strukturen, z. B. Objektarrays, überschrieben werden. Die folgenden Aussagen müssen für jede Implementierung der Equals-Methode zutreffen. In der Liste bezeichnen x, y und z Objektverweise, die nicht NULL-Verweis (Nothing in Visual Basic) sind.

  • x.Equals(x) gibt true zurück, außer wenn Gleitkommatypen beteiligt sind. Siehe IEC 60559:1989, Binary Floating-point Arithmetic for Microprocessor Systems.

  • x.Equals(y) gibt denselben Wert wie y.Equals(x) zurück.

  • x.Equals(y) gibt true zurück, wenn sowohl x als auch y NaN sind.

  • (x.Equals(y) && y.Equals(z)) gibt dann und nur dann true zurück, wenn x.Equals(z) true zurückgibt.

  • Wiederholte Aufrufe von x.Equals(y) geben denselben Wert zurück, solange die Objekte, auf die x und y verweisen, nicht geändert werden.

  • x.Equals(NULL-Verweis (Nothing in Visual Basic)) gibt false zurück.

Informationen über weitere Erfordernisse bezüglich des Verhaltens der Equals-Methode finden Sie unter GetHashCode. Implementierungen von Equals dürfen keine Ausnahmen auslösen. Bei manchen Arten von Objekten ist es wünschenswert, dass der Test mit Equals die Werte und nicht die Verweisgleichheit vergleicht. Derartige Implementierungen von Equals geben true zurück, wenn zwei Objekte denselben "Wert" haben, auch wenn sie nicht dieselbe Instanz sind. Bei der Implementierung des Typs wird entschieden, worin der "Wert" eines Objekts besteht. Normalerweise besteht er aus allen oder einem Teil der Daten, die in den Instanzvariablen des Objekts gespeichert sind. Der Wert eines String bezieht sich z. B. auf die Zeichen der Zeichenfolge. Die Equals-Methode der String-Klasse gibt true zurück, wenn zwei Zeichenfolgeninstanzen dieselben Zeichen in derselben Reihenfolge enthalten. Typen, die IComparable implementieren, müssen Equals überschreiben. Typen, die Equals überschreiben, müssen auch GetHashCode überschreiben. Andernfalls könnte Hashtable möglicherweise falsche Ergebnisse liefern. Wenn die Programmiersprache das Überladen von Operatoren unterstützt und Sie den Gleichheitsoperator für einen bestimmten Typ überladen möchten, muss dieser Typ die Equals-Methode überschreiben. Solche Implementierungen der Equals-Methode müssen dasselbe Ergebnis wie der Gleichheitsoperator liefern. Durch Einhalten dieser Richtlinie ist sichergestellt, dass das Verhalten des Codes von Klassenbibliotheken, der Equals verwendet (z. B. ArrayList und Hashtable) konsistent ist mit der Art, in der Anwendungscode den Gleichheitsoperator verwendet. Im Folgenden sind Richtlinien für die Implementierung eines Werttyps aufgeführt:
  • Ziehen Sie das Überschreiben von Equals in Betracht. Hierdurch könnte eine Leistungssteigerung gegenüber der Standardimplementierung von Equals für ValueType erzielt werden.

  • Wenn Sie Equals überschreiben und die Programmiersprache das Überladen von Operatoren unterstützt, müssen Sie den Gleichheitsoperator für den Werttyp überladen.

Im Folgenden sind Richtlinien für die Implementierung eines Verweistyps aufgeführt:
  • Ziehen Sie das Überschreiben von Equals für einen Verweistyp in Betracht, wenn die Semantik dieses Typs darauf beruht, dass er Werte darstellt.

  • Verweistypen dürfen den Gleichheitsoperator i. d. R. auch dann nicht überladen, wenn sie Equals überschreiben. Wenn Sie allerdings einen Verweistyp implementieren, der Wertsemantik besitzen soll, z. B. einen Typ, der komplexe Zahlen darstellt, müssen Sie den Gleichheitsoperator überschreiben.

Im folgenden Codebeispiel wird die aktuelle Instanz mit einem anderen Objekt verglichen.

using System;

public class Sample {
    void Method() {
    Object Obj1 = new Object();
    Object Obj2 = new Object();
    Console.WriteLine(Obj1.Equals(Obj2)); //===> false
    Obj2 = Obj1;
    Console.WriteLine(Obj1.Equals(Obj2)); //===> true
    }
}

import System.*;

public class Sample
{
    void Method()
    {
        Object obj1 = new Object();
        Object obj2 = new Object();
        Console.WriteLine(obj1.Equals(obj2)); //===> false
        obj2 = obj1;
        Console.WriteLine(obj1.Equals(obj2)); //===> true
    } //Method
} //Sample

Das folgende Beispiel veranschaulicht eine Point-Klasse, in der die Equals-Methode zum Bereitstellen von Wertgleichheit überschrieben wird, sowie die Klasse Point3D, die von Point abgeleitet ist. Da das Überschreiben von Equals in Point als Erstes innerhalb der Vererbungskette die Wertgleichheit einführt, wird die Equals-Methode der Basisklasse (die von Object geerbt wurde und Verweisgleichheit prüft) nicht aufgerufen. Point3D.Equals ruft allerdings Point.Equals auf, da PointEquals in einer Weise implementiert, dass Wertgleichheit vorliegt.

using System;

class Point: Object {
   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 || GetType() != obj.GetType()) return false;
      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 MyClass {

  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("Likewise, point3Db does not equal point2D.");
     }
     if (point3Da.Equals(point3Db)) {
        Console.WriteLine("However, point3Da equals point3Db.");
     }
   
  } 
}
// ----------------------------------
// Output should be:
// 
// point2D does not equal point3Da.
// Likewise, point3Db does not equal point2D.
// However, point3Da equals point3Db.

Die Point.Equals-Methode überprüft, ob das obj-Argument nicht NULL-Verweis (Nothing in Visual Basic) ist und auf eine Instanz desselben Typs verweist, von dem auch dieses Objekt ist. Wenn eine dieser Überprüfungen negativ verläuft, gibt die Methode false zurück.

Die Equals-Methode stellt mithilfe von GetType fest, ob die Laufzeittypen der beiden Objekte identisch sind. (Beachten Sie, dass typeof hier nicht verwendet wird, da es den statischen Typ zurückgibt.) Bei einer Überprüfung der Form obj is Point durch die Methode würde die Überprüfung in Fällen, in denen obj eine Instanz einer von Point abgeleiteten Klasse ist, true zurückgeben, obwohl obj und die aktuelle Instanz nicht denselben Laufzeittyp haben. 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 Equals-Methode aufgerufen, bevor irgendeine andere Aktion erfolgt. Die geerbte Equals-Methode überprüft, ob obj nicht NULL-Verweis (Nothing in Visual Basic) ist, ob obj eine Instanz derselben Klasse wie dieses Objekt ist und ob die geerbten Instanzvariablen übereinstimmen. Nur wenn das geerbte Equalstrue zurückgibt, vergleicht die Methode die in der abgeleiteten Klasse hinzugekommenen Instanzvariablen. 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 oben stehenden Beispiel werden die einzelnen Instanzvariablen mit dem operator == (dem Gleichheitsoperator) verglichen. Wie das nächste Codebeispiel veranschaulicht, ist es angebracht, in einer Equals-Implementierung die Equals-Methode zum Vergleich von Instanzvariablen zu verwenden.

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 added for clean compile
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 MyClass {
   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.");
      }
   }
}
// ------------------------------
// Output should be:
// Rectangle r1 equals rectangle r2!
// But rectangle r2 does not equal rectangle r3.

Einige Programmiersprachen wie C# unterstützen das Überladen von Operatoren. Wenn ein Typ operator == überlädt, muss er auch die Equals-Methode überladen, um dort dieselben Funktionen bereitzustellen. Dies wird i. d. R. dadurch erreicht, dass die Equals-Methode wie im folgenden Codebeispiel mittels des überladenen operator == formuliert 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.");
    }

    cmplx2.re = 4.0;

    if (cmplx1 == cmplx2) {
      Console.WriteLine("The two objects are now equal!");
    }
  }
}
// ---------------------------------
// Output should be:
//
// The two objects are not equal.
// The two objects are now equal!

Da Complex eine C#-Struktur ist (ein Werttyp), können hiervon keine Klassen abgeleitet werden. Daher muss die Equals-Methode nicht die GetType-Ergebnisse für alle Objekte vergleichen, sondern kann stattdessen den is-Operator zum Überprüfen des Typs des obj-Parameters verwenden.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 wird unter Windows Vista, Microsoft Windows XP SP2 und Windows Server 2003 SP1 unterstützt.

.NET Framework

Unterstützt in: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

XNA Framework

Unterstützt in: 1.0
Anzeigen:
© 2014 Microsoft