IStructuralEquatable Interfaccia

Riferimento

Definizione

Spazio dei nomi:: System.Collections

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Definisce i metodi per supportare il confronto di oggetti allo scopo di verificarne l'uguaglianza strutturale.

public interface class IStructuralEquatable

public interface IStructuralEquatable

type IStructuralEquatable = interface

Public Interface IStructuralEquatable

Derivato: System.Array

System.Collections.Immutable.ImmutableArray<T>

System.Tuple<T1>

System.Tuple<T1,T2>

System.Tuple<T1,T2,T3>

Altro…

Esempio

Il comparer di uguaglianza predefinito, , EqualityComparer<Object>.Default.Equalsconsidera due NaN valori uguali. Tuttavia, in alcuni casi, è possibile che il confronto di valori per NaN l'uguaglianza restituisca false, che indica che i valori non possono essere confrontati. Nell'esempio seguente viene definita una classe NanComparer che implementa l'interfaccia IEqualityComparer . Viene usato dal terzo esempio come argomento per il Equals(Object, IEqualityComparer) metodo dell'interfaccia IStructuralEquatable implementata dalla tupla. Confronta due o due Double Single valori usando l'operatore di uguaglianza. Passa i valori di qualsiasi altro tipo al comparer di uguaglianza predefinito.

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 3-tuple identici i cui componenti sono costituiti da tre Double valori. Il valore del secondo componente è Double.NaN. L'esempio chiama quindi il metodo e chiama il Tuple<T1,T2,T3>.Equals IStructuralEquatable.Equals metodo tre volte. La prima volta, passa il comparer di uguaglianza predefinito restituito dalla EqualityComparer<T>.Default proprietà. La seconda volta, passa il comparer di uguaglianza predefinito restituito dalla StructuralComparisons.StructuralEqualityComparer proprietà. La terza volta, passa l'oggetto personalizzato NanComparer . Come illustrato dall'output dell'esempio, le prime tre chiamate al metodo restituiscono true, mentre la quarta chiamata restituisce 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. È diverso dall'uguaglianza dei riferimenti, che indica che due riferimenti a oggetti sono uguali perché fanno riferimento allo stesso oggetto fisico. L'interfaccia IStructuralEquatable consente di implementare confronti personalizzati per verificare l'uguaglianza strutturale degli oggetti raccolta. Vale a dire, è possibile creare una definizione personalizzata di uguaglianza strutturale e specificare che questa definizione venga usata con un tipo di raccolta che accetta l'interfaccia IStructuralEquatable . L'interfaccia include due membri: Equals, che verifica l'uguaglianza usando un'implementazione specificata IEqualityComparer e GetHashCode, che restituisce codici hash identici per gli oggetti uguali.

Nota

L'interfaccia supporta solo confronti personalizzati per l'uguaglianza IStructuralEquatable strutturale. L'interfaccia IStructuralComparable supporta confronti strutturali personalizzati per l'ordinamento e l'ordinamento.

.NET Framework fornisce anche i comparer di uguaglianza predefiniti, restituiti dalle EqualityComparer<T>.Default proprietà e StructuralComparisons.StructuralEqualityComparer . Per altre informazioni, vedere l'esempio.

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

Metodi

Equals(Object, IEqualityComparer)	Determina se un oggetto è uguale all'istanza corrente dal punto di vista strutturale.
GetHashCode(IEqualityComparer)	Restituisce un codice hash per l'istanza corrente.

Si applica a

Condividi tramite