Tuple<T1,T2,T3>.IStructuralEquatable.Equals Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Retorna um valor que indica se o objeto Tuple<T1,T2,T3> 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

Equals(Object, IEqualityComparer)

Exemplos

O exemplo a seguir define uma Item2Comparer classe que implementa a IEqualityComparer interface e altera a maneira como Tuple<T1,T2,T3> os objetos são avaliados quanto à igualdade. O método sempre retorna true quando é passado os Item1 valores de propriedade de dois Tuple<T1,T2,T3> objetos e chama o Tuple<T1,T2,T3>.IStructuralEquatable.Equals método para avaliar seus Item2 valores de propriedade. Se essa chamada de método retornar true, seus Item3 valores de propriedade serão passados para o método, que sempre retorna true. Como resultado, o método testa a igualdade com base apenas no valor da Item2 propriedade. A saída ilustra o resultado de um conjunto de dados de Tuple<T1,T2,T3> objetos que registram os nomes, a pontuação média do teste e o número de testes de alunos em uma classe.

using System;
using System.Collections;

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

public class Example
{
   public static void Main()
   {
      Tuple<string, double, int>[] scores = 
           { Tuple.Create("Ed", 78.8, 8),
             Tuple.Create("Abbey", 92.1, 9), 
             Tuple.Create("Jim", 71.2, 9),
             Tuple.Create("Sam", 91.7, 8), 
             Tuple.Create("Sandy", 71.2, 5),
             Tuple.Create("Penelope", 82.9, 8),
             Tuple.Create("Serena", 71.2, 9),
             Tuple.Create("Judith", 84.3, 9) };

      for (int ctr = 0; ctr < scores.Length; ctr++)
      {
         IStructuralEquatable score = scores[ctr];
         for (int ctr2 = ctr + 1; ctr2 < scores.Length; ctr2++)
         {
            Console.WriteLine("{0} = {1}: {2}", score, 
                              scores[ctr2], 
                              score.Equals(scores[ctr2], 
                                           new Item2Comparer<string, double, int>()));
         }
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//      (Ed, 78.8, 8) = (Abbey, 92.1, 9): False
//      (Ed, 78.8, 8) = (Jim, 71.2, 9): False
//      (Ed, 78.8, 8) = (Sam, 91.7, 8): False
//      (Ed, 78.8, 8) = (Sandy, 71.2, 5): False
//      (Ed, 78.8, 8) = (Penelope, 82.9, 8): False
//      (Ed, 78.8, 8) = (Serena, 71.2, 9): False
//      (Ed, 78.8, 8) = (Judith, 84.3, 9): False
//
//      (Abbey, 92.1, 9) = (Jim, 71.2, 9): False
//      (Abbey, 92.1, 9) = (Sam, 91.7, 8): False
//      (Abbey, 92.1, 9) = (Sandy, 71.2, 5): False
//      (Abbey, 92.1, 9) = (Penelope, 82.9, 8): False
//      (Abbey, 92.1, 9) = (Serena, 71.2, 9): False
//      (Abbey, 92.1, 9) = (Judith, 84.3, 9): False
//      
//      (Jim, 71.2, 9) = (Sam, 91.7, 8): False
//      (Jim, 71.2, 9) = (Sandy, 71.2, 5): True
//      (Jim, 71.2, 9) = (Penelope, 82.9, 8): False
//      (Jim, 71.2, 9) = (Serena, 71.2, 9): True
//      (Jim, 71.2, 9) = (Judith, 84.3, 9): False
//
//      (Sam, 91.7, 8) = (Sandy, 71.2, 5): False
//      (Sam, 91.7, 8) = (Penelope, 82.9, 8): False
//      (Sam, 91.7, 8) = (Serena, 71.2, 9): False
//      (Sam, 91.7, 8) = (Judith, 84.3, 9): False
//
//      (Sandy, 71.2, 5) = (Penelope, 82.9, 8): False
//      (Sandy, 71.2, 5) = (Serena, 71.2, 9): True
//      (Sandy, 71.2, 5) = (Judith, 84.3, 9): False
//
//      (Penelope, 82.9, 8) = (Serena, 71.2, 9): False
//      (Penelope, 82.9, 8) = (Judith, 84.3, 9): False
//
//      (Serena, 71.2, 9) = (Judith, 84.3, 9): False

open System
open System.Collections

type Item2Comparer<'T1, 'T2, 'T3 when 'T1: equality and 'T2: equality and 'T3: equality>() =
    interface IEqualityComparer with
        member _.Equals(x: obj, y: obj) =
            // Return true for all values of Item1.
            match x with
            | :? 'T1 ->
                true
            | :? 'T2 ->
                x.Equals y
            | _ -> true
   
        member _.GetHashCode(obj: obj) =
            match obj with
            | :? 'T1 as obj->
                obj.GetHashCode()
            | :? 'T2 as obj ->
                obj.GetHashCode()
            | _ ->
                (obj :?> 'T3).GetHashCode()

let scores = 
    [| Tuple.Create("Ed", 78.8, 8)
       Tuple.Create("Abbey", 92.1, 9) 
       Tuple.Create("Jim", 71.2, 9)
       Tuple.Create("Sam", 91.7, 8)
       Tuple.Create("Sandy", 71.2, 5)
       Tuple.Create("Penelope", 82.9, 8)
       Tuple.Create("Serena", 71.2, 9)
       Tuple.Create("Judith", 84.3, 9) |]

for ctr = 0 to scores.Length - 1 do
    let score : IStructuralEquatable = scores[ctr]
    for ctr2 = ctr + 1 to scores.Length - 1 do
        printfn $"{score} = {scores[ctr2]}: {score.Equals(scores[ctr2], Item2Comparer<string, double, int>())}"
    printfn ""
// The example displays the following output:
//      (Ed, 78.8, 8) = (Abbey, 92.1, 9): False
//      (Ed, 78.8, 8) = (Jim, 71.2, 9): False
//      (Ed, 78.8, 8) = (Sam, 91.7, 8): False
//      (Ed, 78.8, 8) = (Sandy, 71.2, 5): False
//      (Ed, 78.8, 8) = (Penelope, 82.9, 8): False
//      (Ed, 78.8, 8) = (Serena, 71.2, 9): False
//      (Ed, 78.8, 8) = (Judith, 84.3, 9): False
//
//      (Abbey, 92.1, 9) = (Jim, 71.2, 9): False
//      (Abbey, 92.1, 9) = (Sam, 91.7, 8): False
//      (Abbey, 92.1, 9) = (Sandy, 71.2, 5): False
//      (Abbey, 92.1, 9) = (Penelope, 82.9, 8): False
//      (Abbey, 92.1, 9) = (Serena, 71.2, 9): False
//      (Abbey, 92.1, 9) = (Judith, 84.3, 9): False
//      
//      (Jim, 71.2, 9) = (Sam, 91.7, 8): False
//      (Jim, 71.2, 9) = (Sandy, 71.2, 5): True
//      (Jim, 71.2, 9) = (Penelope, 82.9, 8): False
//      (Jim, 71.2, 9) = (Serena, 71.2, 9): True
//      (Jim, 71.2, 9) = (Judith, 84.3, 9): False
//
//      (Sam, 91.7, 8) = (Sandy, 71.2, 5): False
//      (Sam, 91.7, 8) = (Penelope, 82.9, 8): False
//      (Sam, 91.7, 8) = (Serena, 71.2, 9): False
//      (Sam, 91.7, 8) = (Judith, 84.3, 9): False
//
//      (Sandy, 71.2, 5) = (Penelope, 82.9, 8): False
//      (Sandy, 71.2, 5) = (Serena, 71.2, 9): True
//      (Sandy, 71.2, 5) = (Judith, 84.3, 9): False
//
//      (Penelope, 82.9, 8) = (Serena, 71.2, 9): False
//      (Penelope, 82.9, 8) = (Judith, 84.3, 9): False
//
//      (Serena, 71.2, 9) = (Judith, 84.3, 9): False

Imports System.Collections

Public Class Item2Comparer(Of T1, T2, T3) : 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
      ElseIf TypeOf x Is T2 Then
         Return x.Equals(y)
      Else
         Return True
      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()
      ElseIf TypeOf obj Is T2 Then
         Return CType(obj, T2).GetHashCode()
      Else	
         Return CType(obj, T3).GetHashCode()
      End If   
   End Function                
End Class

Module Example
   Public Sub Main()
      Dim scores() = 
                { Tuple.Create("Ed", 78.8, 8),
                  Tuple.Create("Abbey", 92.1, 9), 
                  Tuple.Create("Jim", 71.2, 9),
                  Tuple.Create("Sam", 91.7, 8), 
                  Tuple.Create("Sandy", 71.2, 5),
                  Tuple.Create("Penelope", 82.9, 8),
                  Tuple.Create("Serena", 71.2, 9),
                  Tuple.Create("Judith", 84.3, 9) }

      For ctr As Integer = 0 To scores.Length - 1
         Dim score As IStructuralEquatable = scores(ctr)
         For ctr2 As Integer = ctr + 1 To scores.Length - 1
            Console.WriteLine("{0} = {1}: {2}", score, 
                              scores(ctr2), 
                              score.Equals(scores(ctr2), 
                                           new Item2Comparer(Of String, Double, Integer)))
         Next
         Console.WriteLine()
      Next                     
   End Sub
End Module
' The example displays the following output:
'      (Ed, 78.8, 8) = (Abbey, 92.1, 9): False
'      (Ed, 78.8, 8) = (Jim, 71.2, 9): False
'      (Ed, 78.8, 8) = (Sam, 91.7, 8): False
'      (Ed, 78.8, 8) = (Sandy, 71.2, 5): False
'      (Ed, 78.8, 8) = (Penelope, 82.9, 8): False
'      (Ed, 78.8, 8) = (Serena, 71.2, 9): False
'      (Ed, 78.8, 8) = (Judith, 84.3, 9): False
'      
'      (Abbey, 92.1, 9) = (Jim, 71.2, 9): False
'      (Abbey, 92.1, 9) = (Sam, 91.7, 8): False
'      (Abbey, 92.1, 9) = (Sandy, 71.2, 5): False
'      (Abbey, 92.1, 9) = (Penelope, 82.9, 8): False
'      (Abbey, 92.1, 9) = (Serena, 71.2, 9): False
'      (Abbey, 92.1, 9) = (Judith, 84.3, 9): False
'
'      (Jim, 71.2, 9) = (Sam, 91.7, 8): False
'      (Jim, 71.2, 9) = (Sandy, 71.2, 5): True
'      (Jim, 71.2, 9) = (Penelope, 82.9, 8): False
'      (Jim, 71.2, 9) = (Serena, 71.2, 9): True
'      (Jim, 71.2, 9) = (Judith, 84.3, 9): False
'
'      (Sam, 91.7, 8) = (Sandy, 71.2, 5): False
'      (Sam, 91.7, 8) = (Penelope, 82.9, 8): False
'      (Sam, 91.7, 8) = (Serena, 71.2, 9): False
'      (Sam, 91.7, 8) = (Judith, 84.3, 9): False
'
'      (Sandy, 71.2, 5) = (Penelope, 82.9, 8): False
'      (Sandy, 71.2, 5) = (Serena, 71.2, 9): True
'      (Sandy, 71.2, 5) = (Judith, 84.3, 9): False
'
'      (Penelope, 82.9, 8) = (Serena, 71.2, 9): False
'      (Penelope, 82.9, 8) = (Judith, 84.3, 9): False
'
'      (Serena, 71.2, 9) = (Judith, 84.3, 9): False

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,T2,T3> é 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,T2,T3> objeto cujos componentes são dos mesmos tipos que a instância atual. Primeiro Tuple<T1,T2,T3>.IStructuralEquatable.Equals , o método passa os Item1 valores dos Tuple<T1,T2,T3> objetos a serem comparados à IEqualityComparer.Equals implementação. Se essa chamada de método retornar true, o método será chamado novamente e passará os Item2 valores dos dois Tuple<T1,T2,T3> objetos. Se essa chamada de método retornar true novamente, o método será chamado pela terceira vez e passa os Item3 valores dos dois Tuple<T1,T2,T3> objetos.

Aplica-se a

Partilhar via