IStructuralEquatable.Equals(Object, IEqualityComparer) Método

Definición

Espacio de nombres:

System.Collections

Ensamblado:

System.Runtime.dll

Determina si un objeto es estructuralmente igual que la instancia actual.

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

Objeto que se va a comparar con la instancia actual.

comparer

IEqualityComparer

Un objeto que determina si la instancia actual y other son iguales.

Devoluciones

Boolean

Es true si los dos objetos son iguales; en caso contrario, es false.

Ejemplos

El comparador de igualdad predeterminado, EqualityComparer<Object>.Default.Equals, considera que dos NaN valores son iguales. Sin embargo, en algunos casos, es posible que desee que la comparación de valores de NaN igualdad devuelva false, lo que indica que no se pueden comparar los valores. En el ejemplo siguiente se define una clase NanComparer que implementa la interfaz IStructuralEquatable . Compara dos o dos DoubleSingle valores mediante el operador de igualdad. Pasa valores de cualquier otro tipo al comparador de igualdad predeterminado.

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 tupla 3 idénticos cuyos componentes constan de tres Double valores. El valor del segundo componente es Double.NaN. A continuación, el ejemplo llama al Tuple<T1,T2,T3>.Equals método y llama al IStructuralEquatable.Equals método tres veces. La primera vez, pasa el comparador de igualdad predeterminado devuelto por la EqualityComparer<T>.Default propiedad . La segunda vez, pasa el comparador de igualdad predeterminado devuelto por la StructuralComparisons.StructuralEqualityComparer propiedad . La tercera vez, pasa el objeto personalizado NanComparer . Como se muestra en la salida del ejemplo, las tres primeras llamadas al método devuelven true, mientras que la cuarta llamada devuelve 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 objetos de matriz y tupla. A su vez, este método llama al comparer método del IEqualityComparer.Equals objeto para comparar elementos individuales de matriz o componentes de tupla, empezando por el primer elemento o componente. Las llamadas individuales al IEqualityComparer.Equals final y el IStructuralEquatable.Equals método devuelve un valor cuando una llamada de método devuelve false o después de que se hayan comparado todos los elementos de matriz o componentes de tupla.

Consulte también

• StructuralEqualityComparer