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

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: Tuple.cs

Origem:: Tuple.cs

Origem:: Tuple.cs

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 a um 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

O objeto a ser comparado com essa instância.

Retornos

Boolean

true caso a instância atual seja igual ao objeto especificado; do contrário, false.

Exemplos

O exemplo a seguir chama o Tuple<T1,T2,T3>.Equals(Object) método para determinar se algum dos objetos em uma matriz de Tuple<T1,T2,T3> objetos é igual um ao outro. A saída reflete o fato de que o Equals(Object) método retorna true ao comparar Tuple<T1,T2,T3> objetos cujos componentes têm valores iguais.

using System;

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("Ed", 71.2, 9),
                        Tuple.Create("Sam", 91.7, 8), 
                        Tuple.Create("Ed", 71.2, 5),
                        Tuple.Create("Penelope", 82.9, 8),
                        Tuple.Create("Ed", 71.2, 9),
                        Tuple.Create("Judith", 84.3, 9) };

      // Test each tuple object for equality with every other tuple.
      for (int ctr = 0; ctr < scores.Length; ctr++)
      {
         var currentTuple = scores[ctr];
         for (int ctr2 = ctr + 1; ctr2 < scores.Length; ctr2++)
            Console.WriteLine("{0} = {1}: {2}", currentTuple, scores[ctr2], 
                                                currentTuple.Equals(scores[ctr2]));      

         Console.WriteLine();
      }   
   }
}
// The example displays the following output;
//    (Ed, 78.8, 8) = (Abbey, 92.1, 9): False
//    (Ed, 78.8, 8) = (Ed, 71.2, 9): False
//    (Ed, 78.8, 8) = (Sam, 91.7, 8): False
//    (Ed, 78.8, 8) = (Ed, 71.2, 5): False
//    (Ed, 78.8, 8) = (Penelope, 82.9, 8): False
//    (Ed, 78.8, 8) = (Ed, 71.2, 9): False
//    (Ed, 78.8, 8) = (Judith, 84.3, 9): False
//    
//    (Abbey, 92.1, 9) = (Ed, 71.2, 9): False
//    (Abbey, 92.1, 9) = (Sam, 91.7, 8): False
//    (Abbey, 92.1, 9) = (Ed, 71.2, 5): False
//    (Abbey, 92.1, 9) = (Penelope, 82.9, 8): False
//    (Abbey, 92.1, 9) = (Ed, 71.2, 9): False
//    (Abbey, 92.1, 9) = (Judith, 84.3, 9): False
//    
//    (Ed, 71.2, 9) = (Sam, 91.7, 8): False
//    (Ed, 71.2, 9) = (Ed, 71.2, 5): False
//    (Ed, 71.2, 9) = (Penelope, 82.9, 8): False
//    (Ed, 71.2, 9) = (Ed, 71.2, 9): True
//    (Ed, 71.2, 9) = (Judith, 84.3, 9): False
//    
//    (Sam, 91.7, 8) = (Ed, 71.2, 5): False
//    (Sam, 91.7, 8) = (Penelope, 82.9, 8): False
//    (Sam, 91.7, 8) = (Ed, 71.2, 9): False
//    (Sam, 91.7, 8) = (Judith, 84.3, 9): False
//    
//    (Ed, 71.2, 5) = (Penelope, 82.9, 8): False
//    (Ed, 71.2, 5) = (Ed, 71.2, 9): False
//    (Ed, 71.2, 5) = (Judith, 84.3, 9): False
//    
//    (Penelope, 82.9, 8) = (Ed, 71.2, 9): False
//    (Penelope, 82.9, 8) = (Judith, 84.3, 9): False
//    
//    (Ed, 71.2, 9) = (Judith, 84.3, 9): False

open System

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

// Test each tuple object for equality with every other tuple.
for ctr = 0 to scores.Length - 1 do
    let currentTuple = scores[ctr]
    for ctr2 = ctr + 1 to scores.Length - 1 do
        printfn $"{currentTuple} = {scores[ctr2]}: {currentTuple.Equals scores[ctr2]}"
    printfn ""

// The example displays the following output
//    (Ed, 78.8, 8) = (Abbey, 92.1, 9): False
//    (Ed, 78.8, 8) = (Ed, 71.2, 9): False
//    (Ed, 78.8, 8) = (Sam, 91.7, 8): False
//    (Ed, 78.8, 8) = (Ed, 71.2, 5): False
//    (Ed, 78.8, 8) = (Penelope, 82.9, 8): False
//    (Ed, 78.8, 8) = (Ed, 71.2, 9): False
//    (Ed, 78.8, 8) = (Judith, 84.3, 9): False
//    
//    (Abbey, 92.1, 9) = (Ed, 71.2, 9): False
//    (Abbey, 92.1, 9) = (Sam, 91.7, 8): False
//    (Abbey, 92.1, 9) = (Ed, 71.2, 5): False
//    (Abbey, 92.1, 9) = (Penelope, 82.9, 8): False
//    (Abbey, 92.1, 9) = (Ed, 71.2, 9): False
//    (Abbey, 92.1, 9) = (Judith, 84.3, 9): False
//    
//    (Ed, 71.2, 9) = (Sam, 91.7, 8): False
//    (Ed, 71.2, 9) = (Ed, 71.2, 5): False
//    (Ed, 71.2, 9) = (Penelope, 82.9, 8): False
//    (Ed, 71.2, 9) = (Ed, 71.2, 9): True
//    (Ed, 71.2, 9) = (Judith, 84.3, 9): False
//    
//    (Sam, 91.7, 8) = (Ed, 71.2, 5): False
//    (Sam, 91.7, 8) = (Penelope, 82.9, 8): False
//    (Sam, 91.7, 8) = (Ed, 71.2, 9): False
//    (Sam, 91.7, 8) = (Judith, 84.3, 9): False
//    
//    (Ed, 71.2, 5) = (Penelope, 82.9, 8): False
//    (Ed, 71.2, 5) = (Ed, 71.2, 9): False
//    (Ed, 71.2, 5) = (Judith, 84.3, 9): False
//    
//    (Penelope, 82.9, 8) = (Ed, 71.2, 9): False
//    (Penelope, 82.9, 8) = (Judith, 84.3, 9): False
//    
//    (Ed, 71.2, 9) = (Judith, 84.3, 9): False

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

      ' Test each tuple object for equality with every other tuple.
      For ctr As Integer = 0 To scores.Length - 1
         Dim currentTuple = scores(ctr)
         For ctr2 As Integer = ctr + 1 To scores.Length - 1
            Console.WriteLine("{0} = {1}: {2}", currentTuple, scores(ctr2), 
                                                currentTuple.Equals(scores(ctr2)))      
         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) = (Ed, 71.2, 9): False
'    (Ed, 78.8, 8) = (Sam, 91.7, 8): False
'    (Ed, 78.8, 8) = (Ed, 71.2, 5): False
'    (Ed, 78.8, 8) = (Penelope, 82.9, 8): False
'    (Ed, 78.8, 8) = (Ed, 71.2, 9): False
'    (Ed, 78.8, 8) = (Judith, 84.3, 9): False
'    
'    (Abbey, 92.1, 9) = (Ed, 71.2, 9): False
'    (Abbey, 92.1, 9) = (Sam, 91.7, 8): False
'    (Abbey, 92.1, 9) = (Ed, 71.2, 5): False
'    (Abbey, 92.1, 9) = (Penelope, 82.9, 8): False
'    (Abbey, 92.1, 9) = (Ed, 71.2, 9): False
'    (Abbey, 92.1, 9) = (Judith, 84.3, 9): False
'    
'    (Ed, 71.2, 9) = (Sam, 91.7, 8): False
'    (Ed, 71.2, 9) = (Ed, 71.2, 5): False
'    (Ed, 71.2, 9) = (Penelope, 82.9, 8): False
'    (Ed, 71.2, 9) = (Ed, 71.2, 9): True
'    (Ed, 71.2, 9) = (Judith, 84.3, 9): False
'    
'    (Sam, 91.7, 8) = (Ed, 71.2, 5): False
'    (Sam, 91.7, 8) = (Penelope, 82.9, 8): False
'    (Sam, 91.7, 8) = (Ed, 71.2, 9): False
'    (Sam, 91.7, 8) = (Judith, 84.3, 9): False
'    
'    (Ed, 71.2, 5) = (Penelope, 82.9, 8): False
'    (Ed, 71.2, 5) = (Ed, 71.2, 9): False
'    (Ed, 71.2, 5) = (Judith, 84.3, 9): False
'    
'    (Penelope, 82.9, 8) = (Ed, 71.2, 9): False
'    (Penelope, 82.9, 8) = (Judith, 84.3, 9): False
'    
'    (Ed, 71.2, 9) = (Judith, 84.3, 9): False

Comentários

O parâmetro obj deve ser considerado igual à instância atual nas seguintes circunstâncias:

É um Tuple<T1,T2,T3> objeto .
Seus três componentes são dos mesmos tipos que a instância atual.
Seus três componentes são iguais aos da instância atual. A igualdade é determinada pela comparação de igualdade do objeto padrão para cada componente.

Aplica-se a

Partilhar via