IStructuralEquatable IStructuralEquatable IStructuralEquatable IStructuralEquatable Interface

Definición

Define los métodos para admitir la comparación de objetos de igualdad estructural.Defines methods to support the comparison of objects for structural equality.

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 valores NaN 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 comparación de los valores de NaN sea la igualdad para devolver false, 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 IEqualityComparer .The following example defines a NanComparer class that implements the IEqualityComparer interface. Lo usa el tercer ejemplo como argumento para el método Equals(Object, IEqualityComparer) de la interfaz IStructuralEquatable que las tuplas implementan.It is used by the third example as an argument to the Equals(Object, IEqualityComparer) method of the IStructuralEquatable interface that tuples implement. Compara dos Double o dos valores Single 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 componentes están compuestos de tres valores Double.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 llama al método Tuple<T1,T2,T3>.Equals y llama al método IStructuralEquatable.Equals 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 propiedad EqualityComparer<T>.Default.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 propiedad StructuralComparisons.StructuralEqualityComparer.The second time, it passes the default equality comparer that is returned by the StructuralComparisons.StructuralEqualityComparer property. La tercera vez, pasa el objeto NanComparer personalizado.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 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

Comentarios

La igualdad estructural significa que dos objetos son iguales porque tienen los mismos valores.Structural equality means that two objects are equal because they have equal values. Difiere de la igualdad de referencia, lo que indica que dos referencias de objeto son iguales porque hacen referencia al mismo objeto físico.It differs from reference equality, which indicates that two object references are equal because they reference the same physical object. La interfaz IStructuralEquatable permite implementar comparaciones personalizadas para comprobar la igualdad estructural de objetos de colección.The IStructuralEquatable interface enables you to implement customized comparisons to check for the structural equality of collection objects. 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 interfaz IStructuralEquatable.That is, you can create your own definition of structural equality and specify that this definition be used with a collection type that accepts the IStructuralEquatable interface. La interfaz tiene dos miembros: Equals, que comprueba la igualdad mediante el uso de una implementación de IEqualityComparer especificada y GetHashCode, que devuelve códigos hash idénticos para los objetos que son iguales.The interface has two members: Equals, which tests for equality by using a specified IEqualityComparer implementation, and GetHashCode, which returns identical hash codes for objects that are equal.

Nota

La interfaz IStructuralEquatable solo admite comparaciones personalizadas para la igualdad estructural.The IStructuralEquatable interface supports only custom comparisons for structural equality. La interfaz IStructuralComparable admite comparaciones estructurales personalizadas para ordenar y ordenar.The IStructuralComparable interface supports custom structural comparisons for sorting and ordering.

El .NET Framework también proporciona comparadores de igualdad predeterminados, devueltos por las propiedades EqualityComparer<T>.Default y StructuralComparisons.StructuralEqualityComparer.The .NET Framework also provides default equality comparers, which are returned by the EqualityComparer<T>.Default and StructuralComparisons.StructuralEqualityComparer properties. Para obtener más información, vea el ejemplo.For more information, see the example.

Las clases de tupla genéricas (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3>, etc.) y la clase Array proporcionan implementaciones explícitas de la interfaz IStructuralEquatable.The generic tuple classes (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3>, and so on) and the Array class provide explicit implementations of the IStructuralEquatable interface. Mediante la conversión ( C#en) o la conversión (en Visual Basic) de la instancia actual de una matriz o tupla en un valor de interfaz IStructuralEquatable y proporcionando la implementación IEqualityComparer como argumento para el método Equals, puede definir una comparación de igualdad personalizada para el parámetro matriz o colección.By casting (in C#) or converting (in Visual Basic) the current instance of an array or tuple to an IStructuralEquatable interface value and providing your IEqualityComparer implementation as an argument to the Equals method, you can define a custom equality comparison for the array or collection.

Métodos

Equals(Object, IEqualityComparer) Equals(Object, IEqualityComparer) Equals(Object, IEqualityComparer) Equals(Object, IEqualityComparer)

Determina si un objeto es estructuralmente igual que la instancia actual.Determines whether an object is structurally equal to the current instance.

GetHashCode(IEqualityComparer) GetHashCode(IEqualityComparer) GetHashCode(IEqualityComparer) GetHashCode(IEqualityComparer)

Devuelve un código hash de la instancia actual.Returns a hash code for the current instance.

Se aplica a

Consulte también: