Tuple<T1,T2,T3,T4>.IStructuralEquatable.Equals Método
Definição
Importante
Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.
Devolve um valor que indica se o objeto atual Tuple<T1,T2,T3,T4> é igual a um objeto especificado com base num método de comparação especificado.
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 -> boolFunction Equals (other As Object, comparer As IEqualityComparer) As Boolean Implements IStructuralEquatable.EqualsParâmetros
- other
- Object
O objetivo a comparar com este caso.
- comparer
- IEqualityComparer
Um objeto que define o método a usar para avaliar se os dois objetos são iguais.
Devoluções
true se a instância atual for igual ao objeto especificado; caso contrário, false.
Implementações
Exemplos
O exemplo seguinte define uma Item3And4Comparer classe que implementa a IEqualityComparer interface e altera a forma como Tuple<T1,T2,T3,T4> os objetos são avaliados quanto à igualdade. O método devolve true sempre, quando é ultrapassado o Item1 valor das propriedades e Item2 de dois Tuple<T1,T2,T3,T4> objetos, e chama o obj.Equals método para avaliar os seus Item3 valores de propriedade. Se este método chama os retornos true, também chama o obj.Equals método para avaliar os valores das propriedades das Item4 tuplas. Como resultado, o método testa a igualdade apenas com base nos valores das Item3 propriedades e.Item4 O resultado ilustra o resultado para um conjunto de dados de Tuple<T1,T2,T3,T4> objetos que registam o nome de uma cidade dos EUA, o mês de um ano e a temperatura média máxima e mínima desse mês.
using System;
using System.Collections;
public class Item3And4Comparer<T1, T2, T3, T4> : IEqualityComparer
{
private int argument = 0;
new public bool Equals(object x, object y)
{
argument++;
// Return true for all values of Item1, Item2.
if (argument <= 2)
return true;
else
return x.Equals(y);
}
public int GetHashCode(object obj)
{
if (obj is T1)
return ((T1) obj).GetHashCode();
else if (obj is T2)
return ((T2) obj).GetHashCode();
else if (obj is T3)
return ((T3) obj).GetHashCode();
else
return ((T4) obj).GetHashCode();
}
}
public class Example
{
public static void Main()
{
Tuple<string, int, double, double>[] temperatures =
{ Tuple.Create("New York, NY", 4, 61.0, 43.0),
Tuple.Create("Chicago, IL", 2, 34.0, 18.0),
Tuple.Create("Newark, NJ", 4, 61.0, 43.0),
Tuple.Create("Boston, MA", 6, 77.0, 59.0),
Tuple.Create("Detroit, MI", 9, 74.0, 53.0),
Tuple.Create("Minneapolis, MN", 8, 81.0, 61.0) };
// Compare each item with every other item for equality.
for (int ctr = 0; ctr < temperatures.Length; ctr++)
{
IStructuralEquatable temperatureInfo = temperatures[ctr];
for (int ctr2 = ctr + 1; ctr2 < temperatures.Length; ctr2++)
Console.WriteLine("{0} = {1}: {2}",
temperatureInfo, temperatures[ctr2],
temperatureInfo.Equals(temperatures[ctr2],
new Item3And4Comparer<string, int, double, double>()));
Console.WriteLine();
}
}
}
// The example displays the following output:
// (New York, NY, 4, 61, 43) = (Chicago, IL, 2, 34, 18): False
// (New York, NY, 4, 61, 43) = (Newark, NJ, 4, 61, 43): True
// (New York, NY, 4, 61, 43) = (Boston, MA, 6, 77, 59): False
// (New York, NY, 4, 61, 43) = (Detroit, MI, 9, 74, 53): False
// (New York, NY, 4, 61, 43) = (Minneapolis, MN, 8, 81, 61): False
//
// (Chicago, IL, 2, 34, 18) = (Newark, NJ, 4, 61, 43): False
// (Chicago, IL, 2, 34, 18) = (Boston, MA, 6, 77, 59): False
// (Chicago, IL, 2, 34, 18) = (Detroit, MI, 9, 74, 53): False
// (Chicago, IL, 2, 34, 18) = (Minneapolis, MN, 8, 81, 61): False
//
// (Newark, NJ, 4, 61, 43) = (Boston, MA, 6, 77, 59): False
// (Newark, NJ, 4, 61, 43) = (Detroit, MI, 9, 74, 53): False
// (Newark, NJ, 4, 61, 43) = (Minneapolis, MN, 8, 81, 61): False
//
// (Boston, MA, 6, 77, 59) = (Detroit, MI, 9, 74, 53): False
// (Boston, MA, 6, 77, 59) = (Minneapolis, MN, 8, 81, 61): False
//
// (Detroit, MI, 9, 74, 53) = (Minneapolis, MN, 8, 81, 61): False
open System
open System.Collections
type Item3And4Comparer<'T1, 'T2, 'T3, 'T4 when 'T1: equality and 'T2: equality and 'T3: equality and 'T4: equality>() =
let mutable argument = 0
interface IEqualityComparer with
member _.Equals(x: obj, y: obj) =
argument <- argument + 1
// Return true for all values of Item1, Item2.
if argument <= 2 then
true
else
x.Equals y
member _.GetHashCode(obj: obj) =
match obj with
| :? 'T1 as obj ->
obj.GetHashCode()
| :? 'T2 as obj ->
obj.GetHashCode()
| :? 'T3 as obj ->
obj.GetHashCode()
| _ ->
(obj :?> 'T4).GetHashCode()
let temperatures =
[| Tuple.Create("New York, NY", 4, 61.0, 43.0)
Tuple.Create("Chicago, IL", 2, 34.0, 18.0)
Tuple.Create("Newark, NJ", 4, 61.0, 43.0)
Tuple.Create("Boston, MA", 6, 77.0, 59.0)
Tuple.Create("Detroit, MI", 9, 74.0, 53.0)
Tuple.Create("Minneapolis, MN", 8, 81.0, 61.0) |]
// Compare each item with every other item for equality.
for ctr = 0 to temperatures.Length - 1 do
let temperatureInfo: IStructuralEquatable = temperatures[ctr]
for ctr2 = ctr + 1 to temperatures.Length - 1 do
printfn $"{temperatureInfo} = {temperatures[ctr2]}: {temperatureInfo.Equals(temperatures[ctr2], Item3And4Comparer<string, int, double, double>())}"
printfn ""
// The example displays the following output:
// (New York, NY, 4, 61, 43) = (Chicago, IL, 2, 34, 18): False
// (New York, NY, 4, 61, 43) = (Newark, NJ, 4, 61, 43): True
// (New York, NY, 4, 61, 43) = (Boston, MA, 6, 77, 59): False
// (New York, NY, 4, 61, 43) = (Detroit, MI, 9, 74, 53): False
// (New York, NY, 4, 61, 43) = (Minneapolis, MN, 8, 81, 61): False
//
// (Chicago, IL, 2, 34, 18) = (Newark, NJ, 4, 61, 43): False
// (Chicago, IL, 2, 34, 18) = (Boston, MA, 6, 77, 59): False
// (Chicago, IL, 2, 34, 18) = (Detroit, MI, 9, 74, 53): False
// (Chicago, IL, 2, 34, 18) = (Minneapolis, MN, 8, 81, 61): False
//
// (Newark, NJ, 4, 61, 43) = (Boston, MA, 6, 77, 59): False
// (Newark, NJ, 4, 61, 43) = (Detroit, MI, 9, 74, 53): False
// (Newark, NJ, 4, 61, 43) = (Minneapolis, MN, 8, 81, 61): False
//
// (Boston, MA, 6, 77, 59) = (Detroit, MI, 9, 74, 53): False
// (Boston, MA, 6, 77, 59) = (Minneapolis, MN, 8, 81, 61): False
//
// (Detroit, MI, 9, 74, 53) = (Minneapolis, MN, 8, 81, 61): False
Imports System.Collections
Public Class Item3And4Comparer(Of T1, T2, T3, T4) : Implements IEqualityComparer
Private argument As Integer = 0
Public Overloads Function Equals(x As Object, y As Object) As Boolean _
Implements IEqualityComparer.Equals
argument += 1
' Return true for all values of Item1, Item2.
If argument <= 2 Then
Return True
Else
Return x.Equals(y)
End If
End Function
Public Overloads Function GetHashCode(obj As Object) As Integer _
Implements IEqualityComparer.GetHashCode
If TypeOf obj Is T1 Then
Return CType(obj, T1).GetHashCode()
ElseIf TypeOf obj Is T2 Then
Return CType(obj, T2).GetHashCode()
ElseIf TypeOf obj Is T3 Then
REturn CType(Obj, T3).GetHashCode()
Else
Return CType(obj, T4).GetHashCode()
End If
End Function
End Class
Module Example
Public Sub Main()
Dim temperatures() =
{ Tuple.Create("New York, NY", 4, 61, 43), _
Tuple.Create("Chicago, IL", 2, 34, 18), _
Tuple.Create("Newark, NJ", 4, 61, 43), _
Tuple.Create("Boston, MA", 6, 77, 59), _
Tuple.Create("Detroit, MI", 9, 74, 53), _
Tuple.Create("Minneapolis, MN", 8, 81, 61) }
' Compare each item with every other item for equality.
For ctr As Integer = 0 To temperatures.Length - 1
Dim temperatureInfo As IStructuralEquatable = temperatures(ctr)
For ctr2 As Integer = ctr + 1 To temperatures.Length - 1
Console.WriteLine("{0} = {1}: {2}",
temperatureInfo, temperatures(ctr2),
temperatureInfo.Equals(temperatures(ctr2),
New Item3And4Comparer(Of String, Integer, Double, Double)))
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' (New York, NY, 4, 61, 43) = (Chicago, IL, 2, 34, 18): False
' (New York, NY, 4, 61, 43) = (Newark, NJ, 4, 61, 43): True
' (New York, NY, 4, 61, 43) = (Boston, MA, 6, 77, 59): False
' (New York, NY, 4, 61, 43) = (Detroit, MI, 9, 74, 53): False
' (New York, NY, 4, 61, 43) = (Minneapolis, MN, 8, 81, 61): False
'
' (Chicago, IL, 2, 34, 18) = (Newark, NJ, 4, 61, 43): False
' (Chicago, IL, 2, 34, 18) = (Boston, MA, 6, 77, 59): False
' (Chicago, IL, 2, 34, 18) = (Detroit, MI, 9, 74, 53): False
' (Chicago, IL, 2, 34, 18) = (Minneapolis, MN, 8, 81, 61): False
'
' (Newark, NJ, 4, 61, 43) = (Boston, MA, 6, 77, 59): False
' (Newark, NJ, 4, 61, 43) = (Detroit, MI, 9, 74, 53): False
' (Newark, NJ, 4, 61, 43) = (Minneapolis, MN, 8, 81, 61): False
'
' (Boston, MA, 6, 77, 59) = (Detroit, MI, 9, 74, 53): False
' (Boston, MA, 6, 77, 59) = (Minneapolis, MN, 8, 81, 61): False
'
' (Detroit, MI, 9, 74, 53) = (Minneapolis, MN, 8, 81, 61): False
Observações
Este membro é uma implementação explícita de membro de interface. Só pode ser usado quando a Tuple<T1,T2,T3,T4> instância é transmitida para uma IStructuralEquatable interface.
A implementação IEqualityComparer.Equals é chamada apenas se other não for null, e se puder ser convertida com sucesso (em C#) ou convertida (em Visual Basic) para um objeto Tuple<T1,T2,T3,T4> cujos componentes sejam do mesmo tipo que a instância atual. O IStructuralEquatable.Equals(Object, IEqualityComparer) método passa primeiro os Item1 valores dos Tuple<T1,T2,T3,T4> objetos a serem comparados com a IEqualityComparer.Equals implementação. Se esta chamada de método devolver true, o método é chamado novamente e passa os Item2 valores dos dois Tuple<T1,T2,T3,T4> objetos. Se esta chamada de método regressar true novamente, o método é chamado uma terceira vez e passa os Item3 valores dos dois Tuple<T1,T2,T3,T4> objetos. Se esta chamada de método regressar true , o método é chamado pela quarta e última vez e recebe os Item4 valores dos dois Tuple<T1,T2,T3,T4> objetos.
