IStructuralEquatable.Equals(Object, IEqualityComparer) Metodo

Definizione

Determina se un oggetto è uguale all'istanza corrente dal punto di vista strutturale.Determines whether an object is structurally equal to the current instance.

public:
 bool Equals(System::Object ^ other, System::Collections::IEqualityComparer ^ comparer);
public bool Equals (object other, System.Collections.IEqualityComparer comparer);
abstract member Equals : obj * System.Collections.IEqualityComparer -> bool
Public Function Equals (other As Object, comparer As IEqualityComparer) As Boolean

Parametri

other
Object

Oggetto da confrontare con l'istanza corrente.The object to compare with the current instance.

comparer
IEqualityComparer

Oggetto che determina se l'istanza corrente e other sono uguali.An object that determines whether the current instance and other are equal.

Restituisce

true se i due oggetti sono uguali; in caso contrario, false.true if the two objects are equal; otherwise, false.

Esempio

L'operatore di confronto di uguaglianza predefinito, EqualityComparer<Object>.Default.Equals, considera uguali due valori NaN.The default equality comparer, EqualityComparer<Object>.Default.Equals, considers two NaN values to be equal. In alcuni casi, tuttavia, potrebbe essere necessario che il confronto dei valori di NaN per l'uguaglianza restituisca false, che indica che i valori non possono essere confrontati.However, in some cases, you may want the comparison of NaN values for equality to return false, which indicates that the values cannot be compared. Nell'esempio seguente viene definita una classe NanComparer che implementa l'interfaccia IStructuralEquatable .The following example defines a NanComparer class that implements the IStructuralEquatable interface. Confronta due Double o due valori Single utilizzando l'operatore di uguaglianza.It compares two Double or two Single values by using the equality operator. Passa i valori di qualsiasi altro tipo all'operatore di confronto di uguaglianza predefinito.It passes values of any other type to the default equality comparer.

using System;
using System.Collections;
using System.Collections.Generic;

public class NanComparer : IEqualityComparer
{
   public new bool Equals(object x, object y)
   {
      if (x is float)
         return (float) x == (float) y;
      else if (x is double)
         return (double) x == (double) y;
      else
         return EqualityComparer<object>.Default.Equals(x, y);
   }
   
   public int GetHashCode(object obj)
   {
      return EqualityComparer<object>.Default.GetHashCode(obj);
   }
}
Imports System.Collections
Imports System.Collections.Generic

Public Class NanComparer : Implements IEqualityComparer
   Public Overloads Function Equals(x As Object, y As Object) As Boolean _
          Implements IEqualityComparer.Equals
      If TypeOf x Is Single Then
         Return CSng(x) = CSng(y)
      ElseIf TypeOf x Is Double Then
         Return CDbl(x) = CDbl(y)
      Else
         Return EqualityComparer(Of Object).Default.Equals(x, y)
      End If
   End Function
   
   Public Overloads Function GetHashCode(obj As Object) As Integer _
          Implements IEqualityComparer.GetHashCode
      Return EqualityComparer(Of Object).Default.GetHashCode(obj)
   End Function
End Class

Nell'esempio seguente vengono creati due oggetti con 3 tupla identici i cui componenti sono costituiti da tre valori Double.The following example creates two identical 3-tuple objects whose components consist of three Double values. Il valore del secondo componente viene Double.NaN.The value of the second component is Double.NaN. Nell'esempio viene quindi chiamato il metodo Tuple<T1,T2,T3>.Equals e viene chiamato il metodo IStructuralEquatable.Equals tre volte.The example then calls the Tuple<T1,T2,T3>.Equals method, and it calls the IStructuralEquatable.Equals method three times. La prima volta passa l'operatore di confronto di uguaglianza predefinito restituito dalla proprietà EqualityComparer<T>.Default.The first time, it passes the default equality comparer that is returned by the EqualityComparer<T>.Default property. La seconda volta passa l'operatore di confronto di uguaglianza predefinito restituito dalla proprietà StructuralComparisons.StructuralEqualityComparer.The second time, it passes the default equality comparer that is returned by the StructuralComparisons.StructuralEqualityComparer property. La terza volta passa l'oggetto NanComparer personalizzato.The third time, it passes the custom NanComparer object. Come illustrato nell'output dell'esempio, le prime tre chiamate al metodo restituiscono true, mentre la quarta chiamata restituisce false.As the output from the example shows, the first three method calls return true, whereas the fourth call returns false.

public class Example
{
   public static void Main()
   {
      var t1 = Tuple.Create(12.3, Double.NaN, 16.4);
      var t2 = Tuple.Create(12.3, Double.NaN, 16.4);
      
      // Call default Equals method.
      Console.WriteLine(t1.Equals(t2));
      
      IStructuralEquatable equ = t1;
      // Call IStructuralEquatable.Equals using default comparer.
      Console.WriteLine(equ.Equals(t2, EqualityComparer<object>.Default));
      
      // Call IStructuralEquatable.Equals using 
      // StructuralComparisons.StructuralEqualityComparer.
      Console.WriteLine(equ.Equals(t2, 
                        StructuralComparisons.StructuralEqualityComparer));
      
      // Call IStructuralEquatable.Equals using custom comparer.
      Console.WriteLine(equ.Equals(t2, new NanComparer()));
   }
}
// The example displays the following output:
//       True
//       True
//       True
//       False
Module Example
   Public Sub Main()
      Dim t1 = Tuple.Create(12.3, Double.NaN, 16.4)
      Dim t2 = Tuple.Create(12.3, Double.NaN, 16.4)
      
      ' Call default Equals method.
      Console.WriteLine(t1.Equals(t2))
      
      Dim equ As IStructuralEquatable = t1
      ' Call IStructuralEquatable.Equals using default comparer.
      Console.WriteLine(equ.Equals(t2, EqualityComparer(Of Object).Default))
      
      ' Call IStructuralEquatable.Equals using 
      ' StructuralComparisons.StructuralEqualityComparer.
      Console.WriteLine(equ.Equals(t2, 
                        StructuralComparisons.StructuralEqualityComparer))
      
      ' Call IStructuralEquatable.Equals using custom comparer.
      Console.WriteLine(equ.Equals(t2, New NanComparer))
   End Sub
End Module
' The example displays the following output:
'       True
'       True
'       True
'       False

Commenti

Il metodo Equals supporta il confronto strutturale personalizzato di oggetti Array e Tuple.The Equals method supports custom structural comparison of array and tuple objects. Questo metodo chiama a sua volta il metodo di IEqualityComparer.Equals dell'oggetto comparer per confrontare singoli elementi della matrice o componenti di tupla, a partire dal primo elemento o componente.This method in turn calls the comparer object's IEqualityComparer.Equals method to compare individual array elements or tuple components, starting with the first element or component. Le singole chiamate a IEqualityComparer.Equals end e il metodo IStructuralEquatable.Equals restituiscono un valore quando una chiamata al metodo restituisce false o dopo che sono stati confrontati tutti gli elementi della matrice o i componenti della tupla.The individual calls to IEqualityComparer.Equals end and the IStructuralEquatable.Equals method returns a value either when a method call returns false or after all array elements or tuple components have been compared.

Si applica a

Vedi anche