IStructuralEquatable IStructuralEquatable IStructuralEquatable IStructuralEquatable Interface

Definice

Definuje metody pro podporu porovnání objektů pro strukturální rovnost.Defines methods to support the comparison of objects for structural equality.

public interface class IStructuralEquatable
public interface IStructuralEquatable
type IStructuralEquatable = interface
Public Interface IStructuralEquatable
Odvozené

Příklady

Výchozí porovnávání rovnosti, EqualityComparer<Object>.Default.Equals,,, NaN má za předpokladu, že dvě hodnoty budou stejné.The default equality comparer, EqualityComparer<Object>.Default.Equals, considers two NaN values to be equal. V některých případech však můžete chtít NaN porovnat hodnoty rovnosti, která se má vrátit false, což znamená, že hodnoty nelze porovnat.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. Následující příklad definuje NanComparer třídu, která IStructuralEquatable implementuje rozhraní.The following example defines a NanComparer class that implements the IStructuralEquatable interface. Porovná dvě Double nebo dvě Single hodnoty pomocí operátoru rovnosti.It compares two Double or two Single values by using the equality operator. Předá hodnoty jakéhokoliv jiného typu pro výchozí porovnávání rovnosti.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

Následující příklad vytvoří dva identické tři objekty řazené kolekce členů, jejichž komponenty Double se skládají ze tří hodnot.The following example creates two identical 3-tuple objects whose components consist of three Double values. Hodnota druhé součásti je Double.NaN.The value of the second component is Double.NaN. Příklad pak zavolá Tuple<T1,T2,T3>.Equals metodu a IStructuralEquatable.Equals zavolá metodu třikrát.The example then calls the Tuple<T1,T2,T3>.Equals method, and it calls the IStructuralEquatable.Equals method three times. Poprvé předá výchozí porovnávání rovnosti, které je vráceno EqualityComparer<T>.Default vlastností.The first time, it passes the default equality comparer that is returned by the EqualityComparer<T>.Default property. Druhý čas předá výchozí porovnávání rovnosti, které je vráceno StructuralComparisons.StructuralEqualityComparer vlastností.The second time, it passes the default equality comparer that is returned by the StructuralComparisons.StructuralEqualityComparer property. Třetí čas předá vlastní NanComparer objekt.The third time, it passes the custom NanComparer object. Jak ukazuje výstup z příkladu, první tři volání metody vrátí true, zatímco čtvrté volání vrátí. falseAs 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

Poznámky

Strukturální rovnost znamená, že dva objekty jsou stejné, protože mají stejné hodnoty.Structural equality means that two objects are equal because they have equal values. Liší se od rovnosti odkazů, což znamená, že dva odkazy na objekty jsou stejné, protože odkazují na stejný fyzický objekt.It differs from reference equality, which indicates that two object references are equal because they reference the same physical object. IStructuralEquatable Rozhraní umožňuje implementovat přizpůsobené porovnání pro kontrolu strukturální rovnosti objektů kolekce.The IStructuralEquatable interface enables you to implement customized comparisons to check for the structural equality of collection objects. To znamená, že můžete vytvořit vlastní definici strukturální rovnost a určit, že tato definice bude použita s typem kolekce, který přijímá IStructuralEquatable rozhraní.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. Rozhraní má dva členy: Equals, které testuje rovnost pomocí zadané IEqualityComparer implementace, a GetHashCode, která vrací identické kódy hash pro objekty, které jsou stejné.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.

Poznámka

IStructuralEquatable Rozhraní podporuje pouze vlastní porovnání pro strukturální rovnost.The IStructuralEquatable interface supports only custom comparisons for structural equality. IStructuralComparable Rozhraní podporuje vlastní strukturální porovnání pro řazení a řazení.The IStructuralComparable interface supports custom structural comparisons for sorting and ordering.

.NET Framework také poskytuje výchozí porovnávače rovnosti, které jsou vráceny EqualityComparer<T>.Default vlastnostmi a. StructuralComparisons.StructuralEqualityComparerThe .NET Framework also provides default equality comparers, which are returned by the EqualityComparer<T>.Default and StructuralComparisons.StructuralEqualityComparer properties. Další informace najdete v příkladu.For more information, see the example.

Obecné třídy řazené kolekceTuple<T1>členů Tuple<T1,T2>( Tuple<T1,T2,T3>,, a tak dále) IStructuralEquatable a Array třídu poskytují explicitní implementace rozhraní.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. Přetypováním ( C#v) nebo převodem (v Visual Basic) aktuální instance pole nebo řazené kolekce členů IStructuralEquatable na IEqualityComparer hodnotu rozhraní a poskytnutím implementace jako argumentu Equals metody můžete definovat vlastní rovnost. porovnání pro pole nebo kolekci.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.

Metody

Equals(Object, IEqualityComparer) Equals(Object, IEqualityComparer) Equals(Object, IEqualityComparer) Equals(Object, IEqualityComparer)

Určuje, zda je objekt strukturně stejný jako aktuální instance.Determines whether an object is structurally equal to the current instance.

GetHashCode(IEqualityComparer) GetHashCode(IEqualityComparer) GetHashCode(IEqualityComparer) GetHashCode(IEqualityComparer)

Vrátí kód hodnoty hash aktuální instance.Returns a hash code for the current instance.

Platí pro

Viz také