(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Object.Equals-Methode (Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.

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

public virtual bool Equals(
	Object obj
)

Parameter

obj
Typ: System.Object
Das Objekt, das mit dem aktuellen Objekt verglichen werden soll.

Rückgabewert

Typ: System.Boolean
true , wenn das angegebene Objekt und das aktuelle Objekt gleich sind, andernfalls false.

Der Typ des Vergleichs zwischen der aktuellen Instanz und dem Parameter obj hängt davon ab, ob die aktuelle Instanz ein Verweistyp oder ein Werttyp ist.

  • Wenn die aktuelle Instanz ein Verweistyp ist, tested die Equals(Object)-Methode auf Verweisgleichheit; der Aufruf der Equals(Object)-Methode entspricht damit einem Aufruf der ReferenceEquals-Methode. Verweisgleichheit bedeutet, dass die Objektvariablen, die verglichen werden, auf das selbe Objekt verweisen. Das folgende Beispiel zeigt 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. Auserdem wird person1a einer anderen Objektvariablen person1b zugewiesen.
    Wie die Ausgabe im Beispiel zeigt, person1a und person1b sind gleich, da sie auf dasselbe Objekt verweisen. person1a und person2 sind jedoch nicht gleich, obwohl sie denselben Wert besitzen.

    
    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 impliziert 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.

      
      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 einen Werttyp darstellt, und ruft den Klassenkonstruktor Person auf, um zwei neue Person-Objekte, person1 und person2 zu instanziieren, die denselben Wert haben. Wie die Ausgabe des Beispiels sind zeigt, sind person1 und person2 gleich, obwohl die beiden Objektvariablen auf verschiedene Objekte verweisen, da sie den gleichen Wert in dem privaten Feld personName aufweisen.

      
      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 Klasse Object die Basisklasse für alle Typen des .NET Framework darstellt, ist ihre Object.Equals(Object)-Methode der Standardvergleich für alle anderen (abgeleiteten) Typen. Allerdings überschreiben Typen oftmals die Equals-Methode, um den Verglech auf Wertgleichheit zu implementieren. Weitere Informationen finden Sie auf dieser Seite unter Hinweise für Aufrufer und die
Hinweise zur Vererbung.

Hinweise für Windows-Runtime

Wenn Sie die überladbare Equals(Object)-Methoden einer Klasse der Windows-Runtime aufrufen, ist das Standardverhalten, dass Equals(Object) nicht überschreiben wurde. Dies ist Teil der Unterstützung, die .NET Framework für Windows-Runtime bietet (siehe .NET Framework-Unterstützung für Windows Store-Apps und Windows-Runtime). Klassen der Windows-Runtime erben nicht von Object und implementieren dadurch zurzeit keine Equals(Object)-Methode. Diese Klassen werden jedoch ToString, Equals(Object) und GetHashCode-Methoden aufweisen, wenn Sie diese in ihrem C#- oder Visual Basic-Code verwenden, und das .NET Framework wird das Standardverhalten für diese Methoden bereitstellen.

HinweisHinweis

Windows-Runtime-Klassen, die in C# oder Visual Basic geschrieben werden, können die Equals(Object)-Methodenüberladung überschreiben.

Hinweise für Aufrufer

Abgeleitete Klassen überschreiben häufig die Object.Equals(Object)-Methode, um Wertgleichheit zu implementieren. Außerdem stellen Typen häufig als eine zusätzliche Überladung eine stark typisierte Equals-Methode, in der Regel durch Implementierung der Schnittstelle IEquatable<T>, bereit. Wenn Sie die Equals-Methode für eine Überprüfung auf Gleichheit aufrufen, sollten Sie wissen, ob die aktuelle Instanz Object.Equals überschreibt und verstehen, wie ein bestimmter Aufruf einer Equals-Methode aufgelöst wird. Andernfalls führen Sie einen Test auf Gleichheit aus, der anders als von Ihnen beabsichtigt ausfällt, und die Methode kann einen unerwarteten Wert zurückgeben.

Dies wird im folgenden Beispiel veranschaulicht. Er instanziiert drei StringBuilder-Objekte mit identischen Zeichenfolgen und ruft dann viermal die Equals-Methode auf. Der erste Methodenaufruf ergibt true und die restlichen drei geben false zurück.


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


Im ersten Fall wird die stark typisierte StringBuilder.Equals(StringBuilder)-Methodenüberladung, die die Wertgleichheit testet, aufgerufen. Da die Zeichenfolgen, die den zwei StringBuilder-Objekte zugewiesen wurden, gleich sind, gibt die Methode true zurück. Jedoch überschreibt StringBuilder nicht Object.Equals(Object). Deswegen wird, wenn das StringBuilder-Objekt in den Typ Object umgewandelt wird, oder wenn eine StringBuilder-Instanz einer Variablen dem Typ Object zugewiesen wird oder wenn der Object.Equals(Object, Object)-Methode zwei StringBuilder-Objekte übergeben werden, die Standard Object.Equals(Object)-Methode aufgerufen. Da StringBuilder ein Verweistyp ist, entspricht dies der Übergabe der zwei StringBuilder-Objekte zur ReferenceEquals-Methode. Obwohl alle drei StringBuilder-Objekte identische Zeichenfolgen enthalten, referenzieren sie drei unterschiedlichen Objekte. Daher geben diese drei Methode den Wert false zurück.

Sie können das aktuelle Objekt mit einem anderen Objekt auf Verweisgleichheit prüfen, indem Sie die ReferenceEquals-Methode aufrufen. In Visual Basic können Sie auch das is-Schlüsselwort (z. B. If Me Is otherObject Then ...) verwenden.

Hinweise zur Vererbung

Wenn Sie einen eigenen Typ definieren, erbt dieser Typ die Funktionalität, die durch die Equals-Methode des Basistyps definiert wird. In der folgenden Tabelle wird die Standardimplementierung der Equals-Methode für die Kategorien von Typen des .NET Frameworks aufgelistet.

Typkategorie

Gleichheit definiert durch

Kommentare

Klasse direkt von Object abgeleitet

Object.Equals(Object)

Verweisgleichheit; Entsprechung zum Aufrufen von Object.ReferenceEquals.

Struktur

ValueType.Equals

Wertgleichheit; entweder direkter Vergleich auf Byteebene oder Feld-durch Feldvergleich mit Reflektion.

Enumeration

Enum.Equals

Werte müssen den gleichen Enumerationstyp und die gleichen zugrunde liegenden Wert haben.

delegate

MulticastDelegate.Equals

Delegaten müssen denselben Typ mit identischen Aufruflisten haben.

Schnittstelle

Object.Equals(Object)

Verweisgleichheit.

Für einen Werttyp sollten Sie immer Equals überschreiben, da Tests auf Gleichheit, die auf Reflektion basieren, eine schlechte Performance aufweisen. Sie können auch die Standardimplementierung von Equals für Referenz-Typen überschreiben, um auf Wertgleichheit statt auf Verweisgleichheit zu testen und die konkrete Bedingung der Wertgleichheit festzulegen. Solche Implementierungen von Equals geben true zurück, wenn die beiden Objekte den gleichen Wert haben, auch wenn sie nicht die gleiche Instanz sind. Die Implementierung des Typs entscheidet, was den Wert eines Objekts ausmacht, es sind aber in der Regel einige oder alle Daten der Objektinstanz. Zum Beispiel basiert der Wert eines String-Objekts auf den Zeichen der Zeichenfolge; die String.Equals(Object)-Methode überschreibt die Object.Equals(Object)-Methode, um true zurückzugeben, wenn zwei Zeichenfolgeninstanzen die gleiche Zeichen in der gleichen Reihenfolge enthalten.

Das folgende Beispiel zeigt, wie die Object.Equals(Object)-Methode überschrieben wird, um auf Wertgleichheit zu testen. Es überschreibt die Equals-Methode für die Klasse Person. Wenn Person die Basisklassenimplementierung der Gleichheit anwenden würde, würden zwei Person-Objekte nur gleich sein, wenn sie auf dasselbe Objekt verweisen. In diesem Fall sind zwei Person-Objekte gleich, wenn sie den gleichen Wert in der Person.Id-Eigenschaft haben.


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


Zusätzlich zum Überschreiben von Equals, können Sie die IEquatable<T>-Schnittstelle implementieren, um einen stark typisierten Übereinstimmungstest bereitzustellen.

Die folgenden Aussagen müssen für jede Implementierung der Equals(Object)-Methode zutreffen. In der Liste stellen x, y und z Objektverweise dar, die nicht NULL sind.

  • x.Equals(x) gibt true zurück, es sei denn, es handelt sich um Gleitkommatypen. Siehe ISO-/IEC/IEEE 60559:2011, Informationstechnologie – Mikroprozessor-Systeme – Gleitkommaarithmetik.

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

  • x.Equals(y) gibt true zurück, wenn x und y beide NaN sind.

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

  • Aufeinander folgende Aufrufe von x.Equals(y) geben den gleichen Wert zurück, solange die Objekte, die x und y zugewiesen sind, nicht geändert werden.

  • x.Equals(null) gibt false zurück.

Implementierungen von Equals dürfen keine Ausnahmen auslösen; sie sollten immer einen Wert zurückgeben. Wenn z.B. obj null ist, sollte die Equals-Methode false zurückgeben, anstatt ArgumentNullException auszulösen.

Beachten Sie folgende Richtlinien, wenn Equals(Object) überschrieben werden:

  • Typen, die IComparable implementieren, müssen Equals(Object) überschreiben.

  • Typen, die Equals(Object) überschreiben müssen auch GetHashCode überschreiben; andernfalls funktionieren Hashtabellen ggf. nicht ordnungsgemäß.

  • Sie sollten die Schnittstelle IEquatable<T> implementieren, um stark typisierte Tests für Gleichheit zu unterstützen. Ihre IEquatable<T>.Equals Implementierung sollte Ergebnisse zurückgeben, die mit Equals konsistent sind.

  • Wenn Ihre Programmiersprache Operatorüberladung unterstützt und Sie den Gleichheitsoperator für einen angegebenen Typ überladen, müssen Sie die Equals(Object)-Methode auch überschreiben, um das gleiche Ergebnis wie der Gleichheitsoperator zurückzugeben. Dies hilft sicherzustellen, dass Klassenbibliotheks-Code, der Equals verwendet (wie ArrayList und Hashtable) sich konsistent zum Gleichheitsoperator im Anwendungscode verhalten.

bsc2ak47.collapse_all(de-de,VS.110).gifRichtlinien für Verweistypen

Die folgenden Richtlinien gelten für das Überschreiben von Equals(Object) für einen Verweistyp:

  • Sie sollten erwägen, Equals zu überschreiben, wenn die Semantik des Typs darauf basiert, einen oder mehrere Werte darzustellen.

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

  • Sie sollten Equals für einen änderbaren Referenztyp nicht überschreiben. Der Grund dafür ist, dass das Überschreiben von Equals erfordert, dass Sie auch die GetHashCode-Methode überschreiben, wie im vorherigen Abschnitt erläutert. Dies bedeutet, dass sich der Hashcode einer Instanz eines änderbaren Referenztyps während der Lebensdauer ändern kann, mit der Folge, dass das Objekt in einer Hashtabelle verloren geht.

bsc2ak47.collapse_all(de-de,VS.110).gifRichtlinien für Werttypen

Die folgenden Richtlinien gelten für das Überschreiben von Equals(Object) für einen Werttyp:

  • Wenn Sie einen Werttyp definieren, der ein oder mehrere Felder enthält, deren Werte Verweistypen sind, sollten Sie Equals(Object) überschreiben. Die Equals(Object)-Implementierung, die von ValueType bereitgestellt wird, führt einen Vergleich auf Byteebene für Werttypen aus, deren Felder alle Werttypen sind, aber verwendet Reflektion, um einen Feld-zu-Feldvergleich von Werttypen auszuführen, wenn deren Felder Verweistypen enthalten.

  • Wenn Sie Equals überschreiben und ihre Entwicklungssprache Operatorüberladung erlaubt, müssen Sie den Gleichheitsoperator überladen.

  • Sie sollten die IEquatable<T>-Schnittstelle implementieren. Das Aufrufen der stark typisierten IEquatable<T>.Equals-Methode vermeidet das Boxing des obj Arguments.

Im folgenden Beispiel wird eine Point-Klasse, die die Equals-Methode überschreibt, um Wertgleichheit bereitzustellen, und eine Point3D-Klasse veranschaulicht, die von Point abgeleitet wird. Da Point die Object.Equals(Object) überschreibt, um auf Wertgleichheit zu testen, wird die Object.Equals(Object)-Methode nicht aufgerufen. Jedoch ruft Point3D.Equals die Funktion Point.Equals auf, da Point Object.Equals(Object) so implementiert, dass auf Wertgleichheit geprüft wird.


using System;

class Point
{
   protected int x, y;

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

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

    public override string ToString()
    {
        return String.Format("Point({0}, {1})", x, y);
    }
}

sealed class Point3D: Point 
{
   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((Point)obj) && z == pt3.z;
   }

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

   public override String ToString() 
   {
        return String.Format("Point({0}, {1}, {2})", x, y, 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);
     Point3D point3Dc = 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));
  } 
}
// 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


Die Point.Equals-Methode überprüft, dass das obj-Argument nicht null ist und dass es auf eine Instanz des gleichen Typs wie das Objekt verweist. Wenn die Überprüfung fehlschlägt, gibt die Methode false zurück.

Die Point.Equals-Methode ruft die GetType-Methode auf, um zu bestimmen, ob die Laufzeittypen der beiden Objekte identisch sind. Wenn die Methode eine Überprüfung der Form obj is Point in C# oder TryCast(obj, Point) in Visual Basic verwendet, gibt die Überprüfung true zurück, wenn obj eine Instanz einer abgeleiteten Klasse von Point ist, obwohl obj und die aktuelle Instanz nicht vom gleichen Laufzeittyp sind. Nach der Überprüfung der Typgleichheit der Objekte wandelt die Methode obj in den Typ Point um und gibt das Ergebnis des Vergleichs der Instanzfelder der beiden Objekte zurück.

In Point3D.Equals wird die geerbte Point.Equals-Methode, die die Object.Equals(Object) überschreibt, vor allem anderen aufgerufen.
Da Point3D eine versiegelte Klasse (NotInheritable in Visual Basic) ist, ist ein Test in der Form obj is Point in C# oder TryCast(obj, Point) in Visual Basic zweckdienlich, um sicherzustellen, dass obj ein Point3D-Objekt ist. Wenn es ein Point3D-Objekt ist, wird es zu einem Point-Objekt umgewandelt und an die Basisklassenimplementierung von Equals angepasst. Nur wenn die geerbte Point.Equals-Methode true zurückgibt, vergleicht die Methode die z-Instanzfelder, die in der abgeleiteten Klasse erstellt wurden.

Im folgenden Beispiel wird eine Rectangle-Klasse definiert, die intern ein Rechteck als ein zwei Point-Objekte implementiert. Die Rectangle-Klasse überschreibt ebenfalls das Object.Equals(Object), um die Wertgleichheit zu bestimmen.


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("{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));
   }
}
// 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


Einige Sprachen wie C# und Visual Basic unterstützen Operatorüberladung. Wenn ein Typ den Gleichheitsoperator überlädt, muss er auch die Equals(Object)-Methode außer Kraft setzen, um dort dieselbe Funktionalität 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 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("{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));          
  }
}
// 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


Da Complex ein Werttyp ist, kann er nicht abgeleitet werden. Daher kann die Überschreibung der Equals(Object)-Methode nicht GetType aufzurufen, um der präzisen Laufzeittyp jedes Objekts zu bestimmen, sondern muss den Operator is in C# oder den Operator TypeOf in Visual Basic anstattdessen verwenden, um den Typ des Parameters obj zu überprüfen.

.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

.NET für Windows Phone-Apps

Unterstützt in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, 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)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft