Tuple<T1,T2,T3>.Equals(Object) Methode

Definitie

Naamruimte:: System

Assembly's:: mscorlib.dll, System.Runtime.dll

Assembly's:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Bron:: Tuple.cs

Bron:: Tuple.cs

Bron:: Tuple.cs

Bron:: Tuple.cs

Bron:: Tuple.cs

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Retourneert een waarde die aangeeft of het huidige Tuple<T1,T2,T3> object gelijk is aan een opgegeven object.

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

Parameters

obj: Object

Het object dat moet worden vergeleken met dit exemplaar.

Retouren

Boolean

true als het huidige exemplaar gelijk is aan het opgegeven object; anders, false.

Voorbeelden

In het volgende voorbeeld wordt de Tuple<T1,T2,T3>.Equals(Object) methode aangeroepen om te bepalen of een van de objecten in een matrix met Tuple<T1,T2,T3> objecten gelijk is aan elkaar. De uitvoer weerspiegelt het feit dat de methode retourneert Equals(Object) bij het true vergelijken van Tuple<T1,T2,T3> objecten waarvan de onderdelen gelijke waarden hebben.

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

Opmerkingen

De obj parameter wordt beschouwd als gelijk aan het huidige exemplaar onder de volgende omstandigheden:

Het is een Tuple<T1,T2,T3> object.
De drie onderdelen zijn van dezelfde typen als het huidige exemplaar.
De drie onderdelen zijn gelijk aan die van het huidige exemplaar. Gelijkheid wordt bepaald door de standaard object gelijkheidsvergelijker voor elk onderdeel.

Van toepassing op

Feedback

Is deze pagina nuttig?