IStructuralEquatable Interface

  • Referência

Definição

Namespace:
System.Collections
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Define métodos para dar suporte à comparação de objetos para igualdade estrutural.

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 dois NaN valores iguais. No entanto, em alguns casos, talvez você queira que a comparação de NaN valores para igualdade retorne false, o que indica que os valores não podem ser comparados. O exemplo a seguir define uma classe NanComparer que implementa a interface IEqualityComparer. Ele é usado pelo terceiro exemplo como um argumento para o Equals(Object, IEqualityComparer) método da interface que as IStructuralEquatable tuplas implementam. Ele compara dois Double ou dois Single valores usando o operador de igualdade. Ele passa valores de qualquer outro tipo para o comparador de igualdade padrão.

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 idênticos de três tuplas cujos componentes consistem em três Double valores. O valor do segundo componente é Double.NaN. Em seguida, o exemplo chama o Tuple<T1,T2,T3>.Equals método e chama o IStructuralEquatable.Equals método três vezes. Na primeira vez, ele passa o comparador de igualdade padrão retornado pela EqualityComparer<T>.Default propriedade . Na segunda vez, ele passa o comparador de igualdade padrão retornado pela StructuralComparisons.StructuralEqualityComparer propriedade . Na terceira vez, ele passa o objeto personalizado NanComparer . Como mostra a saída do exemplo, as três primeiras chamadas de método retornam true, enquanto a quarta chamada retorna 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

Igualdade estrutural significa que dois objetos são iguais porque têm valores iguais. Ela difere da igualdade de referência, o que indica que duas referências de objeto são iguais porque referenciam o mesmo objeto físico. A IStructuralEquatable interface permite implementar comparações personalizadas para marcar para a igualdade estrutural de objetos de coleção. 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 aceite a IStructuralEquatable interface. A interface tem dois membros: Equals, que testa a igualdade usando uma implementação especificada IEqualityComparer e GetHashCode, que retorna códigos hash idênticos para objetos iguais.

Observação

A IStructuralEquatable interface dá suporte apenas a comparações personalizadas para igualdade estrutural. A IStructuralComparable interface dá suporte a comparações estruturais personalizadas para classificação e ordenação.

O .NET Framework também fornece comparadores de igualdade padrão, que são retornados pelas EqualityComparer<T>.Default propriedades e StructuralComparisons.StructuralEqualityComparer . Para obter mais informações, consulte os exemplos.

As classes de tupla genéricas (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3>e assim por diante) e a Array classe fornecem implementações explícitas da IStructuralEquatable interface . Convertendo (em C#) ou convertendo (no Visual Basic) a instância atual de uma matriz ou tupla em um IStructuralEquatable valor de interface e fornecendo sua IEqualityComparer implementação como um argumento para o Equals método , você pode definir uma comparação de igualdade personalizada para a matriz ou coleção.

Métodos

Equals(Object, IEqualityComparer)

Determina se um objeto é estruturalmente igual à instância atual.
GetHashCode(IEqualityComparer)

Retorna um código hash para a instância atual.

Aplica-se a

Confira também