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

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Restituisce un valore che indica se l'oggetto Tuple<T1> corrente è uguale a un oggetto specificato in base a un metodo di confronto specificato.

 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

Parametri

other: Object

Oggetto da confrontare con questa istanza.

comparer: IEqualityComparer

Oggetto che definisce il metodo da usare per valutare se i due oggetti sono uguali.

Restituisce

Boolean

true se l'istanza corrente è uguale all'oggetto specificato; in caso contrario, false.

Implementazioni

Equals(Object, IEqualityComparer)

Esempio

Nell'esempio seguente viene definita un'implementazione IEqualityComparer che considera uguali due valori a virgola mobile se sono approssimativamente uguali l'uno all'altro, ovvero se un valore è compreso nell'01% dell'altro.

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

Commenti

Questo membro è un’implementazione esplicita di un membro di interfaccia. Può essere utilizzato solo quando si esegue il cast dell'istanza Tuple<T1> a un'interfaccia IStructuralEquatable.

L'implementazione IEqualityComparer.Equals viene chiamata solo se other non nullè e se può essere eseguito correttamente il cast (in C#) o la conversione (in Visual Basic) in un Tuple<T1> oggetto il cui singolo componente è dello stesso tipo dell'istanza corrente. Il metodo viene passato al Item1 componente dell'istanza corrente e al Item1 componente dell'oggetto Tuple<T1> rappresentato dal other parametro .

Si applica a

Vedi anche

IEqualityComparer