Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Object.Equals-Methode: (Object)

 

Veröffentlicht: Oktober 2016

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
Type: System.Object

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

Rückgabewert

Type: System.Boolean

true, wenn das angegebene Objekt und das aktuelle Objekt gleich sind, andernfalls false.

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

  • Wenn die aktuelle Instanz ein Verweistyp ist die Equals(Object) Methode Tests hinsichtlich ihrer Verweisgleichheit und einem Aufruf von der Equals(Object) Methode ist äquivalent zu einem Aufruf von der ReferenceEquals Methode. Verweisgleichheit bedeutet, dass die Objektvariablen, die verglichen werden auf dasselbe Objekt verweisen. Das folgende Beispiel veranschaulicht das Ergebnis von einem solchen Vergleich werden. Definiert eine Person Klasse, die ein Verweistyp ist, und ruft die Person Klassenkonstruktor zwei neue instanziieren Person Objekte person1a und person2, die den gleichen Wert aufweisen. Außerdem weist er person1a auf einem anderen Objektvariable person1b. Wie die Ausgabe des Beispiels zeigt person1a und person1b gleich sind, da sie dasselbe Objekt verweisen. Allerdings person1a und person2 ungleich sind, obwohl sie den gleichen Wert aufweisen.

    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, ist die Equals(Object) Methode Wertgleichheit. Wertgleichheit bedeutet Folgendes:

    • Die beiden Objekte sind vom gleichen Typ. Wie im folgenden Beispiel wird gezeigt, eine Byte -Objekt, das den Wert 12 hat stimmt nicht mit einer Int32 -Objekt, das den Wert 12, aufweist, da die beiden Objekte zur Laufzeit verschiedene verfügen.

      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. Das folgende Beispiel testet Wertgleichheit. Definiert eine Person -Struktur, die ein Werttyp ist, und ruft die Person Klassenkonstruktor zwei neue instanziieren Person Objekte person1 und person2, die den gleichen Wert aufweisen. Wie die Ausgabe des Beispiels zeigt, obwohl die beiden Objektvariablen auf unterschiedliche Objekte verweisen, person1 und person2 gleich sind, da sie den gleichen Wert für die Private aufweisen personName Feld.

      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 bietet die Standard-Gleichheitsvergleich für alle anderen Typen. Typen jedoch häufig überschreiben die Equals Methode für die Implementierung der Wertgleichheit. Weitere Informationen finden Sie unter die Anmerkungen zu dieser Aufrufer und Hinweise für Vererber Abschnitte.

Beim Aufrufen der Equals(Object) methodenüberladung für eine Klasse in der Windows-Runtime, es stellt das Standardverhalten für Klassen, die nicht außer Kraft setzen Equals(Object). Dies ist Teil der Unterstützung von .NET Framework für die Windows-Runtime (siehe .NET Framework-Unterstützung für Windows Store-Apps und Windows-Runtime). Klassen in der Windows-Runtime erben nicht Object, und zurzeit nicht implementieren eine Equals(Object)Methode. Allerdings sie angezeigt werden, damit ToString, Equals(Object), und GetHashCode Methoden, wenn Sie in c# oder Visual Basic-Code werden verwendet, und die .NET Framework das Standardverhalten für diese Methoden bietet.

System_CAPS_noteHinweis

Windows-RuntimeKlassen, die in c# oder Visual Basic geschrieben sind, können außer Kraft setzen die Equals(Object) -methodenüberladung.

Abgeleitete Klassen überschreiben, die häufig die Object.Equals(Object) Methode für die Implementierung der Wertgleichheit. Darüber hinaus auch häufig bieten eine zusätzliche stark typisierte Überladung für die Equals Methode, in der Regel durch die Implementierung der IEquatable<T> Schnittstelle. Beim Aufrufen der Equals Methode auf Gleichheit, sollten Sie wissen, ob die aktuelle Instanz überschreibt Object.Equals und zu verstehen, wie ein bestimmter Aufruf eine Equals Methode aufgelöst wird. Hingegen Sie werden einen Test durchführen, Gleichheit unterscheidet sich von was Sie beabsichtigt haben, und die Methode kann einen unerwarteten Wert zurückgeben.

Dies wird im folgenden Beispiel veranschaulicht. Drei instanziiert StringBuilder Objekte mit Zeichenfolgen identisch, und stellt anschließend vier Aufrufe zu Equals Methoden. Die erste Methode aufrufen, gibt true, und die verbleibenden drei Rückgabe false.

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, die stark typisierte StringBuilder.Equals(StringBuilder) -methodenüberladung, der Wertgleichheit getestet wird, aufgerufen wird. Da die beiden Zeichenfolgen zugewiesen StringBuilder -Objekte gleich sind, gibt die Methode zurück true. Allerdings StringBuilder überschreibt nicht Object.Equals(Object). Aus diesem Grund beim der StringBuilder Objekt umgewandelt wird ein Object, wenn eine StringBuilder Instanz einer Variablen vom Typ zugewiesen Object, und wann die Object.Equals(Object, Object) Methode werden zwei übergeben StringBuilder Objekte, die Standardeinstellung Object.Equals(Object) Methode wird aufgerufen. Da StringBuilder ist ein Verweistyp, dies entspricht dem Übergeben der beiden StringBuilder -Objekte und die ReferenceEquals Methode. Obwohl alle drei StringBuilder Objekte enthalten identische Zeichenfolgen, die sie auf drei unterschiedliche Objekte verweisen. Daher diese drei Methodenaufrufe return false.

Sie können das aktuelle Objekt einem anderen Objekt auf Verweisgleichheit vergleichen, durch Aufrufen der ReferenceEquals Methode. In Visual Basic können Sie auch die is Schlüsselwort (z. B. If Me Is otherObject Then ...).

Wenn Sie einen eigenen Typ definieren, erbt dieses Typs Funktionen, die definiert die Equals Methode des Basistyps. Die folgende Tabelle enthält die standardmäßige Implementierung des der Equals Methode für die Hauptkategorien von Typen in .NET Framework.

Typkategorie

Gleichheit definiert durch

Kommentare

Direkte abgeleitete KlasseObject

Object.Equals(Object)

Verweisgleichheit; entspricht dem Aufruf 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 den gleichen zugrunde liegenden Wert aufweisen.

delegate

MulticastDelegate.Equals

Delegaten müssen den gleichen Typ mit identischen Aufruflisten besitzen.

interface

Object.Equals(Object)

Verweisgleichheit.

Für einen Werttyp aufweist, sollten Sie immer überschreiben Equals, da Tests Gleichheit, die auf Reflektion beruhen, denen eine schlechte Leistung bieten. Sie können auch die standardmäßige Implementierung des überschreiben Equals für Verweistypen, um Wertgleichheit statt Verweisgleichheit zu testen und um die genaue Bedeutung der Wertgleichheit zu definieren. Solche Implementierungen von Equals zurückgeben true , wenn die beiden Objekte den gleichen Wert verfügen, auch wenn sie nicht dieselbe Instanz sind. Der Implementierung des Typs entscheidet, woraus sich der Wert eines Objekts zusammensetzt, aber es ist in der Regel einige oder alle Daten in den Instanzvariablen des Objekts gespeichert. Beispielsweise den Wert der eine String Objekt wird anhand der Zeichen der Zeichenfolge; der String.Equals(Object) methodenüberschreibungen der Object.Equals(Object) -Methode zur Rückgabe true für eine beliebige Zeichenfolge zwei Instanzen, die die gleichen Zeichen in der gleichen Reihenfolge enthalten.

Das folgende Beispiel veranschaulicht das Überschreiben der Object.Equals(Object) Methode zum Testen Wertgleichheit. Es überschreibt die Equals Methode für die Person Klasse. Wenn Person seiner Basisklasse-Implementierung von Gleichheit, akzeptiert zwei Person Objekte wäre nur gleich, wenn sie ein einzelnes Objekt, auf die verwiesen wird. In diesem Fall jedoch zwei Person Objekte sind gleich, wenn sie den gleichen Wert für die Person.Id Eigenschaft.

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

Neben dem Außerkraftsetzen von Equals, können Sie implementieren die IEquatable<T> Schnittstelle, um eine stark typisierte Test auf Gleichheit bereitzustellen.

Die folgenden Anweisungen müssen für alle Implementierungen von "true" werden die Equals(Object) Methode. In der Liste x, y, und z darstellen von Objektverweisen, die nicht null.

  • x.Equals(x)Gibt true, es sei denn, die Gleitkommatypen einschließen. Finden Sie unter ISO/IEC/IEEE 60559:2011, Informationstechnologie--Mikroprozessor Systeme--Gleitkommazahlen.

  • x.Equals(y)Gibt den gleichen Wert wie y.Equals(x).

  • x.Equals(y)Gibt true Wenn beide x und y sind NaN.

  • Wenn (x.Equals(y) && y.Equals(z)) gibt true, klicken Sie dann x.Equals(z) gibt true.

  • Aufeinander folgende Aufrufe von x.Equals(y) zurückgeben, denselben Wert, solange die Objekte verweist x und y werden nicht geändert.

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

Implementierungen von Equals darf keine Ausnahmen auslösen, sollten sie stets einen Wert zurückgeben. Z. B. wenn obj ist null, Equals -Methode zurückgeben sollte false statt einer ArgumentNullException.

Befolgen Sie diese Richtlinien zum Überschreiben Equals(Object):

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

  • Diese Außerkraftsetzung Typen Equals(Object) müssen auch überschreiben GetHashCodeist, andernfalls Hashtabellen funktionieren eventuell nicht richtig.

  • Sie sollten erwägen, implementieren die IEquatable<T> -Schnittstelle zur Unterstützung von stark typisierten Gleichheit. Ihre IEquatable<T>.Equals Implementierung sollten Ergebnisse zurück, die mit konsistent sind Equals.

  • Wenn Ihre Programmiersprache unterstützt Überladen von Operatoren und Sie den Gleichheitsoperator für einen angegebenen Typ überladen, müssen Sie auch überschreiben die Equals(Object) Methode, um das gleiche Ergebnis wie den Gleichheitsoperator zurückzugeben. So kann sichergestellt werden, die verwendet diese Klassenbibliothekscode Equals (z. B. ArrayList und Hashtable) verhält sich in einer Weise, die konsistent mit der Funktionsweise des Gleichheitsoperators wird vom Anwendungscode verwendet.

Die folgenden Richtlinien gelten für überschreiben Equals(Object) für einen Referenztyp darstellt:

  • Betrachten Sie überschreiben Equals , wenn die Semantik des Typs ist, basiert sowohl, dass der Typ einige Werte darstellt.

  • Die meisten Verweistypen müssen nicht den Gleichheitsoperator überladen, auch wenn sie außer Kraft setzen Equals. Wenn Sie einen Verweistyp implementieren, der Wertsemantik, z. B. eine komplexe Zahl Typ besitzen müssen Sie den Gleichheitsoperator überschreiben.

  • Sie sollten nicht überschreiben Equals auf einen änderbaren Referenztyp. Dies ist, da überschreiben Equals erfordert, dass Sie auch überschreiben die GetHashCode -Methode, wie im vorherigen Abschnitt erläutert. Dies bedeutet, dass der Hashcode für eine Instanz des einen änderbaren Referenztyp während seiner Lebensdauer ändern kann, die das Objekt, das verloren geht, werden in einer Hashtabelle verursachen können.

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

  • Wenn Sie einen Werttyp definieren, die eine oder mehrere Felder enthält, deren Werte Verweistypen sind, sollten Sie überschreiben Equals(Object). Die Equals(Object) Implementierung, die ValueType führt einen Byte-pro-Byte-Vergleich für, deren Werttypen Felder sind alle Werttypen, aber es verwendet Reflektion, um ein Feld-nach-Feld-Vergleich von Werttypen durchgeführt werden, deren Felder enthalten, Referenztypen sind.

  • Wenn Sie außer Kraft setzen Equals und Ihre Entwicklungssprache unterstützt Operatoren überladen, müssen Sie den Gleichheitsoperator überladen.

  • Implementieren Sie die IEquatable<T> Schnittstelle. Aufrufen der stark typisierten IEquatable<T>.Equals Methode wird vermieden, Boxing der obj Argument.

Das folgende Beispiel zeigt eine Point -Klasse, überschreibt die Equals Methode, um Wertgleichheit, bereitzustellen und eine Point3D -Klasse, die abgeleitet ist Point. Da Point überschreibt Object.Equals(Object) Wertgleichheit, Testen der Object.Equals(Object) Methode wird nicht aufgerufen. Allerdings Point3D.Equals Aufrufe Point.Equals da Point implementiert Object.Equals(Object) in einer Weise, die Wertgleichheit bereitstellt.

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

The Point.Equals method checks to make sure that the obj argument is not null and that it references an instance of the same type as this object. If either check fails, the method returns false.

The Point.Equals method calls the M:System.Object.GetType method to determine whether the run-time types of the two objects are identical. If the method used a check of the form obj is Point in C# or TryCast(obj, Point) in Visual Basic, the check would return true in cases where obj is an instance of a derived class of Point, even though obj and the current instance are not of the same run-time type. Having verified that both objects are of the same type, the method casts obj to type Point and returns the result of comparing the instance fields of the two objects.

In Point3D.Equals, the inherited Point.Equals method, which overrides M:System.Object.Equals(System.Object), is invoked before anything else is done. Because Point3D is a sealed class (NotInheritable in Visual Basic), a check in the form obj is Point in C# or TryCast(obj, Point) in Visual Basic is adequate to ensure that obj is a Point3D object. If it is a Point3D object, it is cast to a Point object and passed to the base class implementation of M:System.Object.Equals(System.Object). Only when the inherited Point.Equals method returns true does the method compare the z instance fields introduced in the derived class.

Das folgende Beispiel definiert eine Rectangle Klasse, die intern ein Rechteck als zwei implementiert Point Objekte. Die Rectangle -Klasse überschreibt außerdem Object.Equals(Object) Wertgleichheit bereit.

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

In einigen Sprachen wie c# und Visual Basic unterstützt Operatoren überladen. Wenn ein Typ den Gleichheitsoperator überlädt, muss er auch überschreiben die Equals(Object) Methode, um die gleiche Funktionalität bereitzustellen. Dies erfolgt in der Regel durch Schreiben der Equals(Object) Methode im Hinblick auf den überladenen Gleichheitsoperator, wie im folgenden Beispiel gezeigt.

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

Because Complex is a value type, it cannot be derived from. Therefore, the override to M:System.Object.Equals(System.Object) method need not call M:System.Object.GetType to determine the precise run-time type of each object, but can instead use the is operator in C# or the TypeOf operator in Visual Basic to check the type of the obj parameter.

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: