IStructuralEquatable Interfész

Definíció

Névtér:

System.Collections

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

IStructuralEquatable.cs

A szerkezeti egyenlőség objektumainak összehasonlítását támogató módszereket határoz meg.

public interface class IStructuralEquatable

public interface IStructuralEquatable

type IStructuralEquatable = interface

Public Interface IStructuralEquatable

Származtatott

System.Array

System.Collections.Immutable.ImmutableArray<T>

System.Tuple<T1>

System.Tuple<T1,T2>

System.Tuple<T1,T2,T3>

System.Tuple<T1,T2,T3,T4>

System.Tuple<T1,T2,T3,T4,T5>

System.Tuple<T1,T2,T3,T4,T5,T6>

System.Tuple<T1,T2,T3,T4,T5,T6,T7>

System.Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>

System.ValueTuple

System.ValueTuple<T1>

System.ValueTuple<T1,T2>

System.ValueTuple<T1,T2,T3>

System.ValueTuple<T1,T2,T3,T4>

System.ValueTuple<T1,T2,T3,T4,T5>

System.ValueTuple<T1,T2,T3,T4,T5,T6>

System.ValueTuple<T1,T2,T3,T4,T5,T6,T7>

System.ValueTuple<T1,T2,T3,T4,T5,T6,T7,TRest>

Példák

Az alapértelmezett egyenlőség-összehasonlító EqualityComparer<Object>.Default.Equalskét NaN értéket tekint egyenlőnek. Bizonyos esetekben azonban érdemes lehet az egyenlőség értékeinek összehasonlítását NaN visszaadni false, ami azt jelzi, hogy az értékek nem hasonlíthatók össze. Az alábbi példa egy olyan osztályt NanComparer határoz meg, amely implementálja az interfészt IEqualityComparer . A harmadik példa a implementálandó felület metódusának Equals(Object, IEqualityComparer) argumentumaként IStructuralEquatable használja. Két Double vagy két Single értéket hasonlít össze az egyenlőség operátorral. Bármilyen más típusú értéket átad az alapértelmezett egyenlőség-összehasonlítónak.

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

Az alábbi példa két azonos, három vonásból álló objektumot hoz létre, amelyek összetevői három Double értékből állnak. A második összetevő értéke .Double.NaN A példa ezután meghívja a Tuple<T1,T2,T3>.Equals metódust, és háromszor hívja meg a IStructuralEquatable.Equals metódust. Az első alkalommal átadja a tulajdonság által visszaadott alapértelmezett egyenlőség-összehasonlítót EqualityComparer<T>.Default . A második alkalommal a tulajdonság által StructuralComparisons.StructuralEqualityComparer visszaadott alapértelmezett egyenlőség-összehasonlítót adja vissza. A harmadik alkalommal átadja az egyéni NanComparer objektumot. Ahogy a példa kimenete is mutatja, az első három metódushívás ad vissza true, míg a negyedik hívás ad vissza 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

Megjegyzések

A szerkezeti egyenlőség azt jelenti, hogy két objektum egyenlő, mert egyenlő értékekkel rendelkeznek. Ez eltér a hivatkozási egyenlőségtől, ami azt jelzi, hogy két objektumhivatkozás egyenlő, mert ugyanarra a fizikai objektumra hivatkoznak. Az IStructuralEquatable interfész lehetővé teszi, hogy testre szabott összehasonlításokat implementáljon a gyűjteményobjektumok szerkezeti egyenlőségének ellenőrzéséhez. Ez azt jelzi, hogy létrehozhatja a strukturális egyenlőség saját definícióját, és megadhatja, hogy ezt a definíciót olyan gyűjteménytípussal használja, amely elfogadja a IStructuralEquatable felületet. Az interfésznek két tagja van: Equalsegy adott IEqualityComparer implementációval teszteli az egyenlőséget, és GetHashCodeazonos kivonatkódokat ad vissza az egyenlő objektumokhoz.

Note

A IStructuralEquatable felület csak egyéni összehasonlításokat támogat a strukturális egyenlőség érdekében. Az IStructuralComparable interfész támogatja az egyéni szerkezeti összehasonlításokat a rendezéshez és a rendezéshez.

A .NET-keretrendszer alapértelmezett egyenlőség-összehasonlítókat is biztosít, amelyeket a EqualityComparer<T>.Default és StructuralComparisons.StructuralEqualityComparer tulajdonságok adnak vissza. További információkért lásd a példát.

Az általános rekordosztályok (Tuple<T1>, Tuple<T1,T2>, , Tuple<T1,T2,T3>stb.) és az Array osztály explicit implementációkat biztosítanak a IStructuralEquatable felülethez. Ha egy tömb vagy rekord aktuális példányát (C#-ban) vagy átalakítja (Visual Basic) egy IStructuralEquatable felületi értékre, és a IEqualityComparer implementációt a Equals metódus argumentumaként adja meg, egyéni egyenlőségi összehasonlítást határozhat meg a tömbhöz vagy gyűjteményhez.

Metódusok

Name	Description
Equals(Object, IEqualityComparer)	Meghatározza, hogy egy objektum szerkezetileg megegyezik-e az aktuális példánnyal.
GetHashCode(IEqualityComparer)	Az aktuális példány kivonatkódját adja vissza.

Lásd még

• IEqualityComparer
• IStructuralComparable
• StructuralEqualityComparer