IStructuralEquatable Gränssnitt

Definition

public interface class IStructuralEquatable

public interface IStructuralEquatable

type IStructuralEquatable = interface

Public Interface IStructuralEquatable

Härledda

System.Array

System.Collections.Immutable.ImmutableArray<T>

System.Tuple<T1>

System.Tuple<T1,T2>

System.Tuple<T1,T2,T3>

Mer…

Exempel

Standardjämförlikningsjämföraren, EqualityComparer<Object>.Default.Equals, anser att två NaN värden är lika med. Men i vissa fall kanske du vill att jämförelsen av NaN värden för likhet ska returnera false, vilket indikerar att värdena inte kan jämföras. I följande exempel definieras en NanComparer klass som implementerar IEqualityComparer gränssnittet. Det används av det tredje exemplet som ett argument till Equals(Object, IEqualityComparer) metoden IStructuralEquatable för gränssnittet som tupplar implementerar. Den jämför två Double eller två Single värden med hjälp av likhetsoperatorn. Den skickar värden av någon annan typ till standardjämförlikningsjämföraren.

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

I följande exempel skapas två identiska 3-tuppeln-objekt vars komponenter består av tre Double värden. Värdet för den andra komponenten är Double.NaN. Exemplet anropar Tuple<T1,T2,T3>.Equals sedan metoden och anropar IStructuralEquatable.Equals metoden tre gånger. Första gången skickas standardjämlikhetsjämförlikningsjämföraren som returneras av EqualityComparer<T>.Default egenskapen. Den andra gången skickas standardjämlikhetsjämföraren som returneras av StructuralComparisons.StructuralEqualityComparer egenskapen. Den tredje gången skickas det anpassade NanComparer objektet. Som utdata från exemplet visar returnerar truede tre första metodanropen , medan det fjärde anropet returnerar 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

Kommentarer

Strukturell likhet innebär att två objekt är lika eftersom de har lika värden. Den skiljer sig från referensjämlikhet, vilket indikerar att två objektreferenser är lika eftersom de refererar till samma fysiska objekt. Med IStructuralEquatable gränssnittet kan du implementera anpassade jämförelser för att söka efter strukturell likhet mellan samlingsobjekt. Du kan alltså skapa en egen definition av strukturell likhet och ange att den här definitionen ska användas med en samlingstyp IStructuralEquatable som accepterar gränssnittet. Gränssnittet har två medlemmar: Equals, som testar för likhet med hjälp av en angiven IEqualityComparer implementering, och GetHashCode, som returnerar identiska hash-koder för objekt som är lika.

.NET Framework tillhandahåller också standardjämlikhetsjämförlikningsjämförlikning som returneras av egenskaperna EqualityComparer<T>.Default och StructuralComparisons.StructuralEqualityComparer. Mer information finns i exemplet.

De generiska tupppelklasserna (, , och så vidare) och Array klassen tillhandahåller explicita implementeringar av IStructuralEquatable gränssnittet. Tuple<T1,T2,T3>Tuple<T1,T2>Tuple<T1> Genom att konvertera (i C#) eller konvertera (i Visual Basic) den aktuella instansen av en matris eller tuppeln till ett IStructuralEquatable gränssnittsvärde och ange din IEqualityComparer implementering som ett argument till metoden Equals kan du definiera en anpassad likhetsjämförelse för matrisen eller samlingen.

Se även

• IEqualityComparer
• IStructuralComparable
• StructuralEqualityComparer