Compartir a través de

IStructuralEquatable Interfaz

  • Referencia

Definición

Espacio de nombres:
System.Collections
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Define los métodos para admitir la comparación de objetos de igualdad estructural.

public interface class IStructuralEquatable
public interface IStructuralEquatable
type IStructuralEquatable = interface
Public Interface IStructuralEquatable
Derivado

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 NaN valores de 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 IEqualityComparer . El tercer ejemplo lo usa como argumento para el Equals(Object, IEqualityComparer) método de la interfaz que implementan las IStructuralEquatable tuplas. 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

La igualdad estructural significa que dos objetos son iguales porque tienen valores iguales. Difiere de la igualdad de referencia, que indica que dos referencias de objeto son iguales porque hacen referencia al mismo objeto físico. La IStructuralEquatable interfaz permite implementar comparaciones personalizadas para comprobar la igualdad estructural de los objetos de colección. Es decir, puede crear su propia definición de igualdad estructural y especificar que esta definición se use con un tipo de colección que acepte la IStructuralEquatable interfaz. La interfaz tiene dos miembros: Equals, que comprueba la igualdad mediante una implementación especificada IEqualityComparer y GetHashCode, que devuelve códigos hash idénticos para los objetos que son iguales.

Nota

La IStructuralEquatable interfaz solo admite comparaciones personalizadas para la igualdad estructural. La IStructuralComparable interfaz admite comparaciones estructurales personalizadas para ordenar y ordenar.

.NET Framework también proporciona comparadores de igualdad predeterminados, que devuelven las EqualityComparer<T>.Default propiedades y StructuralComparisons.StructuralEqualityComparer . Para obtener más información, vea el ejemplo.

Las clases de tupla genéricas (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3>, etc.) y la Array clase proporcionan implementaciones explícitas de la IStructuralEquatable interfaz. Al convertir (en C#) o convertir (en Visual Basic) la instancia actual de una matriz o tupla en un IStructuralEquatable valor de interfaz y proporcionar la IEqualityComparer implementación como argumento al Equals método, puede definir una comparación de igualdad personalizada para la matriz o colección.

Métodos

Equals(Object, IEqualityComparer)

Determina si un objeto es estructuralmente igual que la instancia actual.
GetHashCode(IEqualityComparer)

Devuelve un código hash de la instancia actual.

Se aplica a

Consulte también