Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

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

 

Data di pubblicazione: ottobre 2016

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

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

bool IStructuralEquatable.Equals(
	object other,
	IEqualityComparer comparer
)

Parametri

other
Type: System.Object

Oggetto da confrontare con questa istanza.

comparer
Type: System.Collections.IEqualityComparer

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

Valore restituito

Type: System.Boolean

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

Questo membro è un'implementazione esplicita di un membro di interfaccia. e può essere utilizzato solo quando si esegue il cast dell'istanza di Tuple<T1, T2> su un'interfaccia IStructuralEquatable.

Il IStructuralEquatable.Equals implementazione viene chiamato solo se other non null, e se può essere correttamente il cast (in c#) o convertire (in Visual Basic) per un Tuple<T1, T2> oggetto i cui componenti sono dello stesso tipo dell'istanza corrente. Il IStructuralEquatable.Equals passa primo metodo di Item1 valori del Tuple<T1, T2> oggetti da confrontare con il IEqualityComparer.Equals implementazione. Se questa chiamata al metodo restituisce true, il metodo viene chiamato nuovamente e passato il Item2 i valori dei due Tuple<T1, T2> oggetti.

L'esempio seguente definisce un Item2Comparer classe che implementa il IEqualityComparer l'interfaccia e cambia il modo in cui Tuple<T1, T2> gli oggetti vengono valutati per verificarne l'uguaglianza. Il metodo restituisce sempre true quando viene passato il Item1 i valori delle due proprietà Tuple<T1, T2> oggetti e chiama il IStructuralEquatable.Equals metodo per valutare le Item2 i valori delle proprietà. Di conseguenza, il metodo verifica l'uguaglianza solo in base al valore della Item2 proprietà. L'output viene illustrato il risultato per un set di dati di Tuple<T1, T2> gli oggetti che registrano i nomi dei canali e le distanze percorse.

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 4.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 4.0
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: