Udostępnij za pośrednictwem


Tuple<T1,T2,T3>.IStructuralEquatable.Equals Metoda

Definicja

Zwraca wartość wskazującą, czy bieżący Tuple<T1,T2,T3> obiekt jest równy określonemu obiektowi na podstawie określonej metody porównania.

 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

Parametry

other
Object

Obiekt, który ma zostać porównany z tym wystąpieniem.

comparer
IEqualityComparer

Obiekt definiujący metodę służącą ocenie, czy dwa obiekty są sobie równe.

Zwraca

Boolean

true jeśli bieżące wystąpienie jest równe określonemu obiektowi; w przeciwnym razie , false.

Implementuje

Przykłady

W poniższym przykładzie zdefiniowano klasę Item2Comparer , która implementuje IEqualityComparer interfejs i zmienia sposób Tuple<T1,T2,T3> oceniania obiektów pod kątem równości. Metoda zawsze zwraca true wartość po przekazaniu Item1 wartości właściwości dwóch Tuple<T1,T2,T3> obiektów i wywołuje metodę Tuple<T1,T2,T3>.IStructuralEquatable.Equals w celu obliczenia ich Item2 wartości właściwości. Jeśli to wywołanie metody zwraca truewartość , Item3 ich wartości właściwości są przekazywane do metody , która zawsze zwraca wartość true. W rezultacie metoda sprawdza równość tylko na podstawie wartości Item2 właściwości . Dane wyjściowe ilustrują wynik zestawu Tuple<T1,T2,T3> danych obiektów, które rejestrują nazwy, średni wynik testu i liczbę testów uczniów w klasie.

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

Uwagi

Ten element jest jawną implementacją członków. Można go używać tylko wtedy, gdy Tuple<T1,T2,T3> wystąpienie jest rzutowe do interfejsu IStructuralEquatable .

Implementacja IEqualityComparer.Equals jest wywoływana tylko wtedy, gdy other nie nulljest , i jeśli można ją pomyślnie rzutować (w języku C#) lub przekonwertować (w Visual Basic) na Tuple<T1,T2,T3> obiekt, którego składniki są tego samego typu co bieżące wystąpienie. Metoda Tuple<T1,T2,T3>.IStructuralEquatable.Equals najpierw przekazuje Item1 wartości Tuple<T1,T2,T3> obiektów do porównania z implementacją IEqualityComparer.Equals . Jeśli to wywołanie metody zwraca truemetodę , metoda jest wywoływana ponownie i przekazuje Item2 wartości dwóch Tuple<T1,T2,T3> obiektów. Jeśli to wywołanie metody zwraca true się ponownie, metoda jest wywoływana po raz trzeci i przekazuje Item3 wartości dwóch Tuple<T1,T2,T3> obiektów.

Dotyczy