IStructuralEquatable Interface

Definitie

public interface class IStructuralEquatable

public interface IStructuralEquatable

type IStructuralEquatable = interface

Public Interface IStructuralEquatable

Afgeleid

System.Array

System.Collections.Immutable.ImmutableArray<T>

System.Tuple<T1>

System.Tuple<T1,T2>

System.Tuple<T1,T2,T3>

Meer…

Voorbeelden

De standaard gelijkheidsgelijker, EqualityComparer<Object>.Default.Equalsbeschouwt twee NaN waarden als gelijk. In sommige gevallen wilt u echter mogelijk dat de vergelijking van NaN waarden voor gelijkheid wordt geretourneerd false, wat aangeeft dat de waarden niet kunnen worden vergeleken. In het volgende voorbeeld wordt een NanComparer klasse gedefinieerd waarmee de IEqualityComparer interface wordt geïmplementeerd. Het wordt door het derde voorbeeld gebruikt als argument voor de methode van de Equals(Object, IEqualityComparer)IStructuralEquatable interface die tuples implementeren. Er worden twee Double of twee Single waarden vergeleken met behulp van de gelijkheidsoperator. Hiermee worden waarden van elk ander type doorgegeven aan de standaard gelijkheidsgelijker.

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

In het volgende voorbeeld worden twee identieke 3 tuple-objecten gemaakt waarvan de onderdelen uit drie Double waarden bestaan. De waarde van het tweede onderdeel is Double.NaN. In het voorbeeld wordt de Tuple<T1,T2,T3>.Equals methode vervolgens drie keer aangeroepen en wordt de IStructuralEquatable.Equals methode drie keer aangeroepen. De eerste keer wordt de standaard gelijkheidsgelijker doorgegeven die door de EqualityComparer<T>.Default eigenschap wordt geretourneerd. De tweede keer wordt de standaard gelijkheidsgelijker doorgegeven die door de StructuralComparisons.StructuralEqualityComparer eigenschap wordt geretourneerd. De derde keer wordt het aangepaste NanComparer object doorgegeven. Zoals in de uitvoer van het voorbeeld wordt weergegeven, worden de eerste drie methode-aanroepen geretourneerd true, terwijl de vierde aanroep retourneert 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

Opmerkingen

Structurele gelijkheid betekent dat twee objecten gelijk zijn omdat ze gelijke waarden hebben. Het verschilt van verwijzings gelijkheid, wat aangeeft dat twee objectverwijzingen gelijk zijn omdat ze verwijzen naar hetzelfde fysieke object. Met de IStructuralEquatable interface kunt u aangepaste vergelijkingen implementeren om te controleren op de structurele gelijkheid van verzamelingsobjecten. Dat wil zeggen, u kunt uw eigen definitie van structurele gelijkheid maken en opgeven dat deze definitie wordt gebruikt met een verzamelingstype dat de IStructuralEquatable interface accepteert. De interface heeft twee leden: Equals, die test op gelijkheid met behulp van een opgegeven IEqualityComparer implementatie en GetHashCode, die identieke hash-codes retourneert voor objecten die gelijk zijn.

Het .NET Framework biedt ook standaard gelijkheids comparers, die worden geretourneerd door de eigenschappen EqualityComparer<T>.Default en StructuralComparisons.StructuralEqualityComparer. Zie het voorbeeld voor meer informatie.

De algemene tuple-klassen (Tuple<T1>, Tuple<T1,T2>enzovoort Tuple<T1,T2,T3>) en de Array klasse bieden expliciete implementaties van de IStructuralEquatable interface. Door het gieten (in C#) of het converteren (in Visual Basic) van het huidige exemplaar van een matrix of tuple naar een IStructuralEquatable interfacewaarde en het leveren van uw IEqualityComparer-implementatie als argument aan de methode Equals kunt u een aangepaste gelijkheidsvergelijking definiëren voor de matrix of verzameling.

Zie ook

• IEqualityComparer
• IStructuralComparable
• StructuralEqualityComparer