Tuple<T1,T2>.Equals(Object) Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Ensamblado:

mscorlib.dll

Ensamblado:

netstandard.dll

Devuelve un valor que indica si el objeto Tuple<T1,T2> actual es igual que el objeto especificado.

public:
 override bool Equals(System::Object ^ obj);

public override bool Equals (object obj);

public override bool Equals (object? obj);

override this.Equals : obj -> bool

Public Overrides Function Equals (obj As Object) As Boolean

Parámetros

obj

Object

Objeto que se va a comparar con esta instancia.

Devoluciones

Boolean

true si la instancia actual es igual que el objeto especificado; en caso contrario, false.

Ejemplos

En el ejemplo siguiente se llama al Tuple<T1,T2>.Equals(Object) método para determinar si alguno de los objetos de una matriz de Tuple<T1,T2> objetos es igual entre sí. La salida refleja el hecho de que el Equals(Object) método devuelve true al comparar Tuple<T1,T2> objetos cuyos componentes tienen valores iguales.

using System;

public class Example
{
   public static void Main()
   {
      Tuple<string, Nullable<int>>[] scores = 
                      { new Tuple<string, Nullable<int>>("Dan", 90),
                        new Tuple<string, Nullable<int>>("Ernie", null),
                        new Tuple<string, Nullable<int>>("Jill", 88),
                        new Tuple<string, Nullable<int>>("Ernie", null), 
                        new Tuple<string, Nullable<int>>("Nancy", 88), 
                        new Tuple<string, Nullable<int>>("Dan", 90) };

      // Compare the Tuple objects
      for (int ctr = 0; ctr < scores.Length; ctr++)
      {
         for (int innerCtr = ctr + 1; innerCtr < scores.Length; innerCtr++)
         {
            Console.WriteLine("{0} = {1}: {2}", 
                              scores[ctr], scores[innerCtr], 
                              scores[ctr].Equals(scores[innerCtr]));
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       (Dan, 90) = (Ernie, ): False
//       (Dan, 90) = (Jill, 88): False
//       (Dan, 90) = (Ernie, ): False
//       (Dan, 90) = (Nancy, 88): False
//       (Dan, 90) = (Dan, 90): True
//       
//       (Ernie, ) = (Jill, 88): False
//       (Ernie, ) = (Ernie, ): True
//       (Ernie, ) = (Nancy, 88): False
//       (Ernie, ) = (Dan, 90): False
//       
//       (Jill, 88) = (Ernie, ): False
//       (Jill, 88) = (Nancy, 88): False
//       (Jill, 88) = (Dan, 90): False
//       
//       (Ernie, ) = (Nancy, 88): False
//       (Ernie, ) = (Dan, 90): False
//       
//       (Nancy, 88) = (Dan, 90): False

open System

let scores = 
    [| Tuple<string, Nullable<int>>("Dan", 90)
       Tuple<string, Nullable<int>>("Ernie", Nullable())
       Tuple<string, Nullable<int>>("Jill", 88)
       Tuple<string, Nullable<int>>("Ernie", Nullable()) 
       Tuple<string, Nullable<int>>("Nancy", 88)
       Tuple<string, Nullable<int>>("Dan", 90) |]

// Compare the Tuple objects
for ctr = 0 to scores.Length - 1 do
    for innerCtr = ctr + 1 to scores.Length - 1 do
        printfn $"{scores[ctr]} = {scores[innerCtr]}: {scores[ctr].Equals scores[innerCtr]}"
    printfn ""
// The example displays the following output:
//       (Dan, 90) = (Ernie, ): False
//       (Dan, 90) = (Jill, 88): False
//       (Dan, 90) = (Ernie, ): False
//       (Dan, 90) = (Nancy, 88): False
//       (Dan, 90) = (Dan, 90): True
//       
//       (Ernie, ) = (Jill, 88): False
//       (Ernie, ) = (Ernie, ): True
//       (Ernie, ) = (Nancy, 88): False
//       (Ernie, ) = (Dan, 90): False
//       
//       (Jill, 88) = (Ernie, ): False
//       (Jill, 88) = (Nancy, 88): False
//       (Jill, 88) = (Dan, 90): False
//       
//       (Ernie, ) = (Nancy, 88): False
//       (Ernie, ) = (Dan, 90): False
//       
//       (Nancy, 88) = (Dan, 90): False

Module Example
   Public Sub Main()
      Dim scores() As Tuple(Of String, Nullable(Of Integer)) = 
                      { New Tuple(Of String, Nullable(Of Integer))("Dan", 90),
                        New Tuple(Of String, Nullable(Of Integer))("Ernie", Nothing),
                        New Tuple(Of String, Nullable(Of Integer))("Jill", 88),
                        New Tuple(Of String, Nullable(Of Integer))("Ernie", Nothing), 
                        New Tuple(Of String, Nullable(Of Integer))("Nancy", 88), 
                        New Tuple(Of String, Nullable(Of Integer))("Dan", 90) }

      ' Compare the Tuple objects
      For ctr As Integer = 0 To scores.Length - 1
         For innerCtr As Integer = ctr + 1 To scores.Length - 1
            Console.WriteLine("{0} = {1}: {2}", 
                              scores(ctr), scores(innerCtr), 
                              scores(ctr).Equals(scores(innerCtr)))
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       (Dan, 90) = (Ernie, ): False
'       (Dan, 90) = (Jill, 88): False
'       (Dan, 90) = (Ernie, ): False
'       (Dan, 90) = (Nancy, 88): False
'       (Dan, 90) = (Dan, 90): True
'       
'       (Ernie, ) = (Jill, 88): False
'       (Ernie, ) = (Ernie, ): True
'       (Ernie, ) = (Nancy, 88): False
'       (Ernie, ) = (Dan, 90): False
'       
'       (Jill, 88) = (Ernie, ): False
'       (Jill, 88) = (Nancy, 88): False
'       (Jill, 88) = (Dan, 90): False
'       
'       (Ernie, ) = (Nancy, 88): False
'       (Ernie, ) = (Dan, 90): False
'       
'       (Nancy, 88) = (Dan, 90): False

Comentarios

El obj parámetro se considera igual que la instancia actual en las condiciones siguientes:

• Es un Tuple<T1,T2> objeto .

• Sus dos componentes son de los mismos tipos que la instancia actual.

• Sus dos componentes son iguales a los de la instancia actual. La igualdad viene determinada por el comparador de igualdad de objetos predeterminado para cada componente.