IStructuralEquatable Interfaccia

Definizione

Definisce i metodi per supportare il confronto di oggetti allo scopo di verificarne l'uguaglianza strutturale.Defines methods to support the comparison of objects for structural equality.

public interface class IStructuralEquatable
public interface IStructuralEquatable
type IStructuralEquatable = interface
Public Interface IStructuralEquatable
Derivato

Esempi

L'operatore di confronto di uguaglianza predefinito, EqualityComparer<Object>.Default.Equals, considera uguali due valori NaN.The default equality comparer, EqualityComparer<Object>.Default.Equals, considers two NaN values to be equal. In alcuni casi, tuttavia, potrebbe essere necessario che il confronto dei valori NaN per l'uguaglianza restituisca false, a indicare che i valori non possono essere confrontati.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. Nell'esempio seguente viene definita una classe NanComparer che implementa l'interfaccia IEqualityComparer .The following example defines a NanComparer class that implements the IEqualityComparer interface. Viene usato dal terzo esempio come argomento per il metodo Equals(Object, IEqualityComparer) dell'interfaccia IStructuralEquatable che le tuple implementano.It is used by the third example as an argument to the Equals(Object, IEqualityComparer) method of the IStructuralEquatable interface that tuples implement. Vengono confrontati due valori Double o due Single utilizzando l'operatore di uguaglianza.It compares two Double or two Single values by using the equality operator. Passa i valori di qualsiasi altro tipo all'operatore di confronto di uguaglianza predefinito.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

Nell'esempio seguente vengono creati due oggetti con 3 tupla identici i cui componenti sono costituiti da tre valori Double.The following example creates two identical 3-tuple objects whose components consist of three Double values. Il valore del secondo componente è Double.NaN.The value of the second component is Double.NaN. Viene quindi chiamato il metodo Tuple<T1,T2,T3>.Equals e viene chiamato il metodo IStructuralEquatable.Equals tre volte.The example then calls the Tuple<T1,T2,T3>.Equals method, and it calls the IStructuralEquatable.Equals method three times. La prima volta passa l'operatore di confronto di uguaglianza predefinito restituito dalla proprietà EqualityComparer<T>.Default.The first time, it passes the default equality comparer that is returned by the EqualityComparer<T>.Default property. La seconda volta passa l'operatore di confronto di uguaglianza predefinito restituito dalla proprietà StructuralComparisons.StructuralEqualityComparer.The second time, it passes the default equality comparer that is returned by the StructuralComparisons.StructuralEqualityComparer property. La terza volta passa l'oggetto personalizzato NanComparer.The third time, it passes the custom NanComparer object. Come illustrato nell'output dell'esempio, le prime tre chiamate al metodo restituiscono true, mentre la quarta chiamata restituisce 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

Commenti

L'uguaglianza strutturale significa che due oggetti sono uguali perché hanno valori uguali.Structural equality means that two objects are equal because they have equal values. Si differenzia dall'uguaglianza dei riferimenti, che indica che due riferimenti a oggetti sono uguali perché fanno riferimento allo stesso oggetto fisico.It differs from reference equality, which indicates that two object references are equal because they reference the same physical object. L'interfaccia IStructuralEquatable consente di implementare confronti personalizzati per verificare l'uguaglianza strutturale degli oggetti della raccolta.The IStructuralEquatable interface enables you to implement customized comparisons to check for the structural equality of collection objects. Ovvero è possibile creare una definizione personalizzata di uguaglianza strutturale e specificare che questa definizione verrà utilizzata con un tipo di raccolta che accetta l'interfaccia 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. L'interfaccia dispone di due membri: Equals, che verifica l'uguaglianza utilizzando un'implementazione IEqualityComparer specificata e GetHashCode, che restituisce codici hash identici per gli oggetti uguali.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

L'interfaccia IStructuralEquatable supporta solo i confronti personalizzati per l'uguaglianza strutturale.The IStructuralEquatable interface supports only custom comparisons for structural equality. L'interfaccia IStructuralComparable supporta confronti strutturali personalizzati per l'ordinamento e l'ordinamento.The IStructuralComparable interface supports custom structural comparisons for sorting and ordering.

Il .NET Framework fornisce anche gli operatori di confronto di uguaglianza predefiniti, restituiti dalle proprietà 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. Per ulteriori informazioni, vedere l'esempio.For more information, see the example.

Le classi di tuple generiche (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3> e così via) e la classe Array forniscono implementazioni esplicite dell'interfaccia 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. Eseguendo il cast ( C#in) o convertendo (in Visual Basic) l'istanza corrente di una matrice o di una tupla in un valore di interfaccia IStructuralEquatable e fornendo l'implementazione di IEqualityComparer come argomento al metodo Equals, è possibile definire un confronto di uguaglianza personalizzato per matrice o raccolta.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.

Metodi

Equals(Object, IEqualityComparer)

Determina se un oggetto è uguale all'istanza corrente dal punto di vista strutturale.Determines whether an object is structurally equal to the current instance.

GetHashCode(IEqualityComparer)

Restituisce un codice hash per l'istanza corrente.Returns a hash code for the current instance.

Si applica a

Vedi anche