IStructuralEquatable IStructuralEquatable IStructuralEquatable IStructuralEquatable Interface

Definição

Define métodos para dar suporte à comparação de objetos para igualdade estrutural.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

Exemplos

O comparador de igualdade padrão, EqualityComparer<Object>.Default.Equals, considera que dois valores NaN sejam iguais.The default equality comparer, EqualityComparer<Object>.Default.Equals, considers two NaN values to be equal. No entanto, em alguns casos, talvez você queira a comparação dos valores NaN para igualdade para retornar false, o que indica que os valores não podem ser comparados.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. O exemplo a seguir define uma classe NanComparer que implementa a interface IEqualityComparer.The following example defines a NanComparer class that implements the IEqualityComparer interface. Ele é usado pelo terceiro exemplo como um argumento para o método Equals(Object, IEqualityComparer) da interface IStructuralEquatable que as tuplas implementam.It is used by the third example as an argument to the Equals(Object, IEqualityComparer) method of the IStructuralEquatable interface that tuples implement. Ele compara dois valores Double ou dois Single usando o operador de igualdade.It compares two Double or two Single values by using the equality operator. Ele passa valores de qualquer outro tipo para o comparador de igualdade padrão.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

O exemplo a seguir cria dois objetos de 3 tuplas idênticos cujos componentes consistem em três valores Double.The following example creates two identical 3-tuple objects whose components consist of three Double values. O valor do segundo componente é Double.NaN.The value of the second component is Double.NaN. Em seguida, o exemplo chama o método Tuple<T1,T2,T3>.Equals e chama o método IStructuralEquatable.Equals três vezes.The example then calls the Tuple<T1,T2,T3>.Equals method, and it calls the IStructuralEquatable.Equals method three times. Na primeira vez, ele passa o comparador de igualdade padrão que é retornado pela propriedade EqualityComparer<T>.Default.The first time, it passes the default equality comparer that is returned by the EqualityComparer<T>.Default property. Na segunda vez, ele passa o comparador de igualdade padrão que é retornado pela propriedade StructuralComparisons.StructuralEqualityComparer.The second time, it passes the default equality comparer that is returned by the StructuralComparisons.StructuralEqualityComparer property. Na terceira vez, ele passa o objeto NanComparer personalizado.The third time, it passes the custom NanComparer object. Como a saída do exemplo mostra, as três primeiras chamadas de método retornam true, enquanto a quarta chamada retorna 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

Comentários

A igualdade estrutural significa que dois objetos são iguais porque têm valores iguais.Structural equality means that two objects are equal because they have equal values. Ele difere da igualdade de referência, o que indica que duas referências de objeto são iguais porque fazem referência ao mesmo objeto físico.It differs from reference equality, which indicates that two object references are equal because they reference the same physical object. A interface IStructuralEquatable permite que você implemente comparações personalizadas para verificar a igualdade estrutural dos objetos de coleção.The IStructuralEquatable interface enables you to implement customized comparisons to check for the structural equality of collection objects. Ou seja, você pode criar sua própria definição de igualdade estrutural e especificar que essa definição seja usada com um tipo de coleção que aceita a interface 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. A interface tem dois membros: Equals, que testa a igualdade usando uma implementação especificada de IEqualityComparer e GetHashCode, que retorna códigos de hash idênticos para objetos que são iguais.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.

Observação

A interface IStructuralEquatable dá suporte apenas a comparações personalizadas para igualdade estrutural.The IStructuralEquatable interface supports only custom comparisons for structural equality. A interface IStructuralComparable dá suporte a comparações estruturais personalizadas para classificação e ordenação.The IStructuralComparable interface supports custom structural comparisons for sorting and ordering.

O .NET Framework também fornece os comparadores de igualdade padrão, que são retornados pelas propriedades EqualityComparer<T>.Default e StructuralComparisons.StructuralEqualityComparer.The .NET Framework also provides default equality comparers, which are returned by the EqualityComparer<T>.Default and StructuralComparisons.StructuralEqualityComparer properties. Para obter mais informações, consulte o exemplo.For more information, see the example.

As classes de tupla genéricas (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3> e assim por diante) e a classe Array fornecem implementações explícitas da interface 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. Convertendo (in C#) ou convertendo (em Visual Basic) a instância atual de uma matriz ou tupla em um valor de interface IStructuralEquatable e fornecendo a implementação de @no__t 2 como um argumento para o método Equals, você pode definir uma comparação de igualdade Personalizada para o matriz ou coleção.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 se um objeto é estruturalmente igual à instância atual.Determines whether an object is structurally equal to the current instance.

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

Retorna um código hash para a instância atual.Returns a hash code for the current instance.

Aplica-se a

Veja também