Tuple<T1,T2>.IStructuralEquatable.Equals(Object, IEqualityComparer) Tuple<T1,T2>.IStructuralEquatable.Equals(Object, IEqualityComparer) Tuple<T1,T2>.IStructuralEquatable.Equals(Object, IEqualityComparer) Method

Definição

Retorna um valor que indica se o objeto Tuple<T1,T2> atual é igual ao objeto especificado com base em um determinado método de comparação.Returns a value that indicates whether the current Tuple<T1,T2> object is equal to a specified object based on a specified comparison method.

 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);
Function Equals (other As Object, comparer As IEqualityComparer) As Boolean Implements IStructuralEquatable.Equals

Parâmetros

other
Object Object Object

O objeto a ser comparado com essa instância.The object to compare with this instance.

comparer
IEqualityComparer IEqualityComparer IEqualityComparer

Um objeto que define o método a ser usado para avaliar se dois objetos são iguais.An object that defines the method to use to evaluate whether the two objects are equal.

Retornos

true caso a instância atual seja igual ao objeto especificado; do contrário, false.true if the current instance is equal to the specified object; otherwise, false.

Implementações

Exemplos

O exemplo a seguir define Item2Comparer uma classe que implementa IEqualityComparer a interface e altera a maneira na Tuple<T1,T2> qual os objetos são avaliados quanto à igualdade.The following example defines an Item2Comparer class that implements the IEqualityComparer interface and changes the way in which Tuple<T1,T2> objects are evaluated for equality. O método sempre retorna true quando é passado os Item1 valores de propriedade de dois Tuple<T1,T2> objetos e chama o IStructuralEquatable.Equals método para avaliar seus Item2 valores de propriedade.The method always returns true when it is passed the Item1 property values of two Tuple<T1,T2> objects, and it calls the IStructuralEquatable.Equals method to evaluate their Item2 property values. Como resultado, o método testa a igualdade com base apenas no valor da Item2 propriedade.As a result, the method tests for equality based only on the value of the Item2 property. A saída ilustra o resultado de um conjunto de dados Tuple<T1,T2> de objetos que registram os nomes dos executores e as distâncias que eles executaram.The output illustrates the result for a data set of Tuple<T1,T2> objects that record the names of runners and the distances that they ran.

using System;
using System.Collections;

public class Item2Comparer<T1, T2> : IEqualityComparer
{
   new public bool Equals(object x, object y)
   {
      // Return true for all values of Item1.
      if (x is T1)
      //if (typeof(x) is string) 
         return true;
      else
         return x.Equals(y);
   }
   
   public int GetHashCode(object obj)
   {
      if (obj is T1)
         return ((T1) obj).GetHashCode();
      else
         return ((T2) obj).GetHashCode();
   }                
}

public class Example
{
   public static void Main()
   {
      Tuple<string, double>[] distancesWalked = {
                        Tuple.Create("Jan", Double.NaN), 
                        Tuple.Create("Joe", Double.NaN), 
                        Tuple.Create("Adam", 1.36), 
                        Tuple.Create("Selena", 2.01),
                        Tuple.Create("Jake", 1.36) };
      for (int ctr = 0; ctr < distancesWalked.Length; ctr++)
      {
         Tuple<string, double> distanceWalked = distancesWalked[ctr];
         for (int ctr2 = ctr + 1; ctr2 < distancesWalked.Length; ctr2++)
         {
            Console.WriteLine("{0} = {1}: {2}", distanceWalked, 
                              distancesWalked[ctr2], 
                              ((IStructuralEquatable)distanceWalked).Equals(distancesWalked[ctr2], 
                                                    new Item2Comparer<string, double>()));
         }
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       (Jan, NaN) = (Joe, NaN): True
//       (Jan, NaN) = (Adam, 1.36): False
//       (Jan, NaN) = (Selena, 2.01): False
//       (Jan, NaN) = (Jake, 1.36): False
//       
//       (Joe, NaN) = (Adam, 1.36): False
//       (Joe, NaN) = (Selena, 2.01): False
//       (Joe, NaN) = (Jake, 1.36): False
//       
//       (Adam, 1.36) = (Selena, 2.01): False
//       (Adam, 1.36) = (Jake, 1.36): True
//       
//       (Selena, 2.01) = (Jake, 1.36): False
Imports System.Collections

Public Class Item2Comparer(Of T1, T2) : Implements IEqualityComparer
   
   Public Overloads Function Equals(x As Object, y As Object) As Boolean _
                   Implements IEqualityComparer.Equals
      ' Return true for all values of Item1.
      If TypeOf x Is T1 Then
         Return True
      Else
         Return x.Equals(y)
      End If
   End Function
   
   Public Overloads Function GetHashCode(obj As Object) As Integer _
                    Implements IEqualityComparer.GetHashCode
      If TypeOf obj Is T1 Then
         Return CType(obj, T1).GetHashCode()
      Else
         Return CType(obj, T2).GetHashCode()
      End If   
   End Function                
End Class

Module Example
   Public Sub Main()
      Dim distancesWalked() = {
                        Tuple.Create("Jan", Double.NaN), 
                        Tuple.Create("Joe", Double.NaN), 
                        Tuple.Create("Adam", 1.36), 
                        Tuple.Create("Selena", 2.01),
                        Tuple.Create("Jake", 1.36) }
      For ctr As Integer = 0 To distancesWalked.Length - 1
         Dim distanceWalked As Tuple(Of String, Double) = distancesWalked(ctr)
         For ctr2 As Integer = ctr + 1 To distancesWalked.Length - 1
            Console.WriteLine("{0} = {1}: {2}", distanceWalked, 
                              distancesWalked(ctr2), 
                              DirectCast(distanceWalked, IStructuralEquatable).Equals(distancesWalked(ctr2), 
                                                    new Item2Comparer(Of String, Double)))
         Next
         Console.WriteLine()
      Next                     
   End Sub
End Module
' The example displays the following output:
'       (Jan, NaN) = (Joe, NaN): True
'       (Jan, NaN) = (Adam, 1.36): False
'       (Jan, NaN) = (Selena, 2.01): False
'       (Jan, NaN) = (Jake, 1.36): False
'       
'       (Joe, NaN) = (Adam, 1.36): False
'       (Joe, NaN) = (Selena, 2.01): False
'       (Joe, NaN) = (Jake, 1.36): False
'       
'       (Adam, 1.36) = (Selena, 2.01): False
'       (Adam, 1.36) = (Jake, 1.36): True
'       
'       (Selena, 2.01) = (Jake, 1.36): False

Comentários

Este membro é uma implementação do membro de interface explícita.This member is an explicit interface member implementation. Ele só pode ser usado quando a instância de Tuple<T1,T2> é convertida em uma interface de IStructuralEquatable.It can be used only when the Tuple<T1,T2> instance is cast to an IStructuralEquatable interface.

A IStructuralEquatable.Equals implementação é chamada somente se other não nullfor, e se ela puder ser convertida com êxito ( C#in) ou convertido (em Visual Basic) em Tuple<T1,T2> um objeto cujos componentes são dos mesmos tipos que a instância atual.The IStructuralEquatable.Equals implementation is called only if other is not null, and if it can be successfully cast (in C#) or converted (in Visual Basic) to a Tuple<T1,T2> object whose components are of the same types as the current instance. O IStructuralEquatable.Equals método primeiro passa os Item1 valores dos Tuple<T1,T2> objetos para serem comparados com IEqualityComparer.Equals a implementação.The IStructuralEquatable.Equals method first passes the Item1 values of the Tuple<T1,T2> objects to be compared to the IEqualityComparer.Equals implementation. Se essa chamada de método trueretornar, o método será chamado novamente e passará os Item2 valores dos Tuple<T1,T2> dois objetos.If this method call returns true, the method is called again and passed the Item2 values of the two Tuple<T1,T2> objects.

Aplica-se a

Veja também