IStructuralEquatable Interface

Definição

public interface class IStructuralEquatable

public interface IStructuralEquatable

type IStructuralEquatable = interface

Public Interface IStructuralEquatable

Derivado

System.Array

System.Collections.Immutable.ImmutableArray<T>

System.Tuple<T1>

System.Tuple<T1,T2>

System.Tuple<T1,T2,T3>

Mais…

Exemplos

O comparador EqualityComparer<Object>.Default.Equalsde igualdade padrão considera dois NaN valores iguais. No entanto, em alguns casos, talvez você queira que a comparação de NaN valores de 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 IStructuralEquatable interface que 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 3 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 que é 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

A igualdade estrutural significa que dois objetos são iguais porque têm valores iguais. Ela difere da igualdade de referência, que indica que duas referências de objeto são iguais porque fazem referência ao mesmo objeto físico. A IStructuralEquatable interface permite que você implemente comparações personalizadas para verificar 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 de hash idênticos para objetos iguais.

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

As classes de tupla genérica (, e assim por diante) e a Array classe fornecem implementações explícitas da IStructuralEquatable interface. Tuple<T1,T2,T3>Tuple<T1,T2>Tuple<T1> Ao converter (em C#) ou converter (no Visual Basic) a instância atual de uma matriz ou tupla em um IStructuralEquatable valor de interface e fornecer 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.

Confira também

• IEqualityComparer
• IStructuralComparable
• StructuralEqualityComparer