IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer) Method

Definición

Determina si un objeto es estructuralmente igual que la instancia actual.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

Parámetros

other
Object Object Object Object

Objeto que se va a comparar con la instancia actual.The object to compare with the current instance.

comparer
IEqualityComparer IEqualityComparer IEqualityComparer IEqualityComparer

Un objeto que determina si la instancia actual y other son iguales.An object that determines whether the current instance and other are equal.

Devoluciones

Es true si los dos objetos son iguales; en caso contrario, es false.true if the two objects are equal; otherwise, false.

Ejemplos

El comparador de igualdad EqualityComparer<Object>.Default.Equalspredeterminado,, NaN considera que dos valores son iguales.The default equality comparer, EqualityComparer<Object>.Default.Equals, considers two NaN values to be equal. Sin embargo, en algunos casos, puede que desee que la NaN comparación de valores de igualdad falsedevuelva, lo que indica que los valores no se pueden comparar.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. En el ejemplo siguiente se define una clase NanComparer que implementa la interfaz IStructuralEquatable .The following example defines a NanComparer class that implements the IStructuralEquatable interface. Compara dos Double o dos Single valores mediante el operador de igualdad.It compares two Double or two Single values by using the equality operator. Pasa valores de cualquier otro tipo al comparador de igualdad predeterminado.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

En el ejemplo siguiente se crean dos objetos de tres tuplas idénticos cuyos Double componentes están compuestos de tres valores.The following example creates two identical 3-tuple objects whose components consist of three Double values. El valor del segundo componente es Double.NaN.The value of the second component is Double.NaN. A continuación, el ejemplo Tuple<T1,T2,T3>.Equals llama al método y llama al IStructuralEquatable.Equals método tres veces.The example then calls the Tuple<T1,T2,T3>.Equals method, and it calls the IStructuralEquatable.Equals method three times. La primera vez, pasa el comparador de igualdad predeterminado devuelto por la EqualityComparer<T>.Default propiedad.The first time, it passes the default equality comparer that is returned by the EqualityComparer<T>.Default property. La segunda vez, pasa el comparador de igualdad predeterminado devuelto por la StructuralComparisons.StructuralEqualityComparer propiedad.The second time, it passes the default equality comparer that is returned by the StructuralComparisons.StructuralEqualityComparer property. La tercera vez, pasa el objeto personalizado NanComparer .The third time, it passes the custom NanComparer object. Como muestra la salida del ejemplo, las tres primeras llamadas al método devuelven true, mientras que la cuarta llamada devuelve. falseAs 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

Comentarios

El Equals método admite la comparación estructural personalizada de los objetos de matriz y tupla.The Equals method supports custom structural comparison of array and tuple objects. Este método, a su vez comparer , llama IEqualityComparer.Equals al método del objeto para comparar elementos de matriz individuales o componentes de tupla, empezando por el primer 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. Las llamadas individuales a IEqualityComparer.Equals end y el IStructuralEquatable.Equals método devuelven un valor cuando una llamada al false método devuelve o después de que se hayan comparado todos los elementos de la matriz o los componentes de la 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.

Se aplica a

Consulte también: