IStructuralEquatable IStructuralEquatable IStructuralEquatable IStructuralEquatable Interface

Definición

Define métodos para admitir la comparación de objetos y comprobar su 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 NaN valores son iguales.The default equality comparer, EqualityComparer<Object>.Default.Equals, considers two NaN values to be equal. Sin embargo, en algunos casos, es posible que desee que la comparación de NaN los valores de igualdad devolviera el valor false, lo que indica que no se pueden comparar los valores.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 objetos Double o dos Single valores mediante el operador de igualdad.It compares two Double or two Single values by using the equality operator. Pasa los 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

El ejemplo siguiente crea dos objetos de tupla de 3 idénticos que se componen de tres Double 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. El ejemplo llama a la Tuple<T1,T2,T3>.Equals llama al método y el 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 personalizado NanComparer objeto.The third time, it passes the custom NanComparer object. Como se muestra el resultado del ejemplo, el método tres primeros llama devuelto true, mientras que devuelve la llamada cuarta 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

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, 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. El IStructuralEquatable interfaz le 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 usa con un tipo de colección que acepta el IStructuralEquatable interfaz.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 un determinado IEqualityComparer implementación, y GetHashCode, que devuelve los 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

El IStructuralEquatable interfaz admite solo las comparaciones personalizadas para comprobar su igualdad estructural.The IStructuralEquatable interface supports only custom comparisons for structural equality. El IStructuralComparable interfaz admite comparaciones estructurales personalizadas para ordenar y clasificar.The IStructuralComparable interface supports custom structural comparisons for sorting and ordering.

.NET Framework también proporciona predeterminada comparadores de igualdad, que son devueltos por la EqualityComparer<T>.Default y StructuralComparisons.StructuralEqualityComparer propiedades.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 Array clase proporcione implementaciones explícitas de la IStructuralEquatable interfaz.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. Conversión (en C#) o convirtiendo (en Visual Basic) de la instancia actual de una matriz o una tupla a un IStructuralEquatable valor de la interfaz y proporcionar su IEqualityComparer implementación como argumento a la Equals método, puede definir una igualdad personalizada comparación de la 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: