Compartilhar via


Tuple<T1>.IStructuralEquatable.Equals(Object, IEqualityComparer) Método

Definição

Retorna um valor que indica se o objeto Tuple<T1> atual é igual ao objeto especificado com base em um determinado método de comparação.

 virtual bool System.Collections.IStructuralEquatable.Equals(System::Object ^ other, System::Collections::IEqualityComparer ^ comparer) = System::Collections::IStructuralEquatable::Equals;
bool IStructuralEquatable.Equals (object other, System.Collections.IEqualityComparer comparer);
abstract member System.Collections.IStructuralEquatable.Equals : obj * System.Collections.IEqualityComparer -> bool
override this.System.Collections.IStructuralEquatable.Equals : obj * System.Collections.IEqualityComparer -> bool
Function Equals (other As Object, comparer As IEqualityComparer) As Boolean Implements IStructuralEquatable.Equals

Parâmetros

other
Object

O objeto a ser comparado com essa instância.

comparer
IEqualityComparer

Um objeto que define o método a ser usado para avaliar se dois objetos são iguais.

Retornos

Boolean

true caso a instância atual seja igual ao objeto especificado; do contrário, false.

Implementações

Exemplos

O exemplo a seguir define uma IEqualityComparer implementação que considera dois valores de ponto flutuante iguais se forem aproximadamente iguais uns aos outros (ou seja, se um valor estiver dentro de 0,01% do outro).

using System;
using System.Collections;

public class Tuple1Comparer : IEqualityComparer
{
   new public bool Equals(object x, object y)
   {
      // Check if x is a floating point type. If x is, then y is.
      if (x is double | x is float)
      {   
         // Convert to Double values.
         double dblX = (double) x;
         double dblY = (double) y;
         if (Double.IsNaN(dblX) | Double.IsInfinity(dblX) |
             Double.IsNaN(dblY) | Double.IsInfinity(dblY)) 
            return dblX.Equals(dblY);   
         else
            return Math.Abs(dblX - dblY) <= dblX * .0001;
      }
      else
      {
         return x.Equals(y);
      }
   }
   
   public int GetHashCode(object obj)
   {
      return obj.GetHashCode();
   }
}

public class Example
{
   public static void Main()
   {
      var doubleTuple1 = Tuple.Create(12.3455);

      var doubleTuple2 = Tuple.Create(16.8912);
      var doubleTuple3 = Tuple.Create(12.3449599);

      // Compare first tuple with a Tuple<double> with a different value.
      TestEquality(doubleTuple1, doubleTuple2);
      //Compare first tuple with a Tuple<double> with the same value.
      TestEquality(doubleTuple1, doubleTuple3);
   }

   private static void TestEquality(Tuple<double> tuple, object obj)
   {
      Console.WriteLine("{0} = {1}: {2}", tuple.ToString(),
                                             obj.ToString(),
                                             ((IStructuralEquatable)tuple).Equals(obj, new Tuple1Comparer()));
   }
}
// The example displays the following output:
//       (12.3455) = (16.8912): False
//       (12.3455) = (12.3449599): True
open System
open System.Collections

type Tuple1Comparer() =
    interface IEqualityComparer with
        member _.Equals(x: obj, y: obj) =
            match x with
            | :? double as dblX -> 
                // Convert to Double values.
                let dblY = y :?> double
                if Double.IsNaN dblX || Double.IsInfinity dblX ||
                    Double.IsNaN dblY || Double.IsInfinity dblY then
                    dblX.Equals dblY
                else
                    abs (dblX - dblY) <= dblX * 0.0001
            | _ ->
                x.Equals y
                
        member _.GetHashCode(obj: obj) =
            obj.GetHashCode()

let testEquality (tuple: Tuple<double>) (obj: obj) =
    printfn $"{tuple} = {obj}: {(tuple :> IStructuralEquatable).Equals(obj, Tuple1Comparer())}"

let doubleTuple1 = Tuple.Create 12.3455
let doubleTuple2 = Tuple.Create 16.8912
let doubleTuple3 = Tuple.Create 12.3449599

// Compare first tuple with a Tuple<double> with a different value.
testEquality doubleTuple1 doubleTuple2
//Compare first tuple with a Tuple<double> with the same value.
testEquality doubleTuple1 doubleTuple3

// The example displays the following output:
//       (12.3455) = (16.8912): False
//       (12.3455) = (12.3449599): True
Imports System.Collections

Public Class Tuple1Comparer : Implements IEqualityComparer
   Public Overloads Function Equals(x As Object, y As Object) As Boolean _
                   Implements IEqualityComparer.Equals
      ' Check if x is a floating point type. If x is, then y is.
      If TypeOf x Is Double Or TypeOf x Is Single Then   
         ' Convert to Double values.
         Dim dblX As Double = CDbl(x)
         Dim dblY As Double = CDbl(y)
         If Double.IsNan(dblX) Or Double.IsInfinity(dblX) Or _
            Double.IsNan(dblY) Or Double.IsInfinity(dblY) Then
            Return dblX.Equals(dblY)   
         Else
            Return Math.Abs(dblX - dblY) <= dblY * .0001
         End If
      Else
         Return x.Equals(y)
      End If                    
   End Function
   
   Public Overloads Function GetHashCode(obj As Object) As Integer _
                   Implements IEqualityComparer.GetHashCode
      Return obj.GetHashCode()
   End Function
End Class

Module Example
   Public Sub Main()
      Dim doubleTuple1 = Tuple.Create(12.3455)

      Dim doubleTuple2 = Tuple.Create(16.8912)
      Dim doubleTuple3 = Tuple.Create(12.3449599)

      ' Compare first tuple with a Tuple(Of Double) with a different value.
      TestEquality(doubleTuple1, doubleTuple2)
      ' Compare first tuple with a Tuple(Of Double) with the same value.
      TestEquality(doubleTuple1, doubleTuple3)
   End Sub

   Private Sub TestEquality(tuple As Tuple(Of Double), obj As Object)
      Try
         Console.WriteLine("{0} = {1}: {2}", tuple.ToString(),
                                             obj.ToString,
                                             DirectCAst(tuple, IStructuralEquatable).Equals(obj, New Tuple1Comparer()))
      
      Catch e As ArgumentException
         If obj.GetType.IsGenericType Then 
            If obj.GetType().Name = "Tuple`1" Then 
               Console.WriteLine("Cannot compare a Tuple(Of {0}) with a Tuple(Of {1}).", 
                              tuple.Item1.GetType().Name, obj.Item1.GetType().Name)
            Else
               Console.WriteLine("Cannot compare a {0} with a {1}.", tuple.GetType().Name, 
                                                                     obj.GetType().Name)
            End If
         Else
            Console.WriteLine("Cannot compare a {0} with a {1}.", tuple.GetType().Name,
                                                                  obj.GetType().Name)
         End If
      End Try
   End Sub
End Module
' The example displays the following output:
'       (12.3455) = (16.8912): False
'       (12.3455) = (12.3449599): True

Comentários

Este membro é uma implementação do membro de interface explícita. Ele só pode ser usado quando a instância de Tuple<T1> é convertida em uma interface de IStructuralEquatable.

A IEqualityComparer.Equals implementação é chamada somente se other não nullfor , e se puder ser convertida com êxito (em C#) ou convertida (em Visual Basic) em um Tuple<T1> objeto cujo único componente é do mesmo tipo que a instância atual. O método é passado o Item1 componente da instância atual e o Item1 componente do Tuple<T1> objeto representado pelo other parâmetro.

Aplica-se a

Confira também