Exportieren (0) 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)

'Declaration
Public Overridable Function Equals ( _
	obj As Object _
) As Boolean

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.

    
    ' Define a reference type that does not override Equals.
    Public Class Person
       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 Example
       Public Sub Main()
          Dim person1a As New Person("John")
          Dim person1b As Person = person1a
          Dim person2 As 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()
    
          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
    
    
    
  • 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.

      
      Module Example
         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
      
      
      
    • 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.

      
      ' Define a value type that does not override Equals.
      Public Structure Person
         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 Example
         Public Sub Main()
            Dim p1 As New Person("John")
            Dim p2 As New Person("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
      
      
      

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(Of 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.


Imports System.Text

Module Example
   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


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.

interface

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 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 Example
   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


Zusätzlich zum Überschreiben von Equals, können Sie die IEquatable(Of 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 Nothing 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(Of T) implementieren, um stark typisierte Tests für Gleichheit zu unterstützen. Ihre IEquatable(Of 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(Of T)-Schnittstelle implementieren. Das Aufrufen der stark typisierten IEquatable(Of 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.


Class Point
    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 Point = DirectCast(obj, Point)
           Return x = p.x AndAlso y = p.y
        End If
    End Function 

    Public Overrides Function GetHashCode() As Integer 
        Return (x << 2) XOr y
    End Function

    Public Overrides Function ToString() As String
        Return String.Format("Point({0}, {1})", x, y)
    End Function
End Class

Class Point3D : Inherits Point
    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, Point)) AndAlso z = pt3.Z  
        End If
    End Function

    Public Overrides Function GetHashCode() As Integer 
        Return (MyBase.GetHashCode() << 2) XOr z
    End Function 

    Public Overrides Function ToString() As String
        Return String.Format("Point({0}, {1}, {2})", x, y, z)
    End Function
End Class 

Module Example
    Public Sub Main() 
        Dim point2D As New Point(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
'       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.


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


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.


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 Example
   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


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:
© 2015 Microsoft