A comparação em .NET é algo que muitas vezes os programadores deixam de lado, renegada à simples comparação de endereço de memória (a == b).
Contudo, o .Net Framework nos fornece mecanismos muito mais poderosos para essas comparações que, além de elegantes, nos ajudam na manutenção futura dos códigos e na prevenção de possíveis bugs em nossos algoritmos.
Utilizemos um cenário com um objeto de negócio (Usuario):
C#public class Usuario
{
private string _Nome;
private string _Email;
private byte _Idade;
private int _ID;
public string Nome
{
get { return _Nome; }
set { _Nome = value; }
}
public string Email
{
get { return _Email; }
set { _Email = value; }
}
public byte Idade
{
get { return _Idade; }
set { _Idade = value; }
}
public int ID
{
get { return _ID; }
set { _ID = value; }
}
}VB.NET
Public Class Usuario
Private _Nome As String
Private _Email As String
Private _Idade As Byte
Private _ID As Integer
Public Property Nome() As String
Get
Return _Nome
End Get
Set(ByVal value As String)
_Nome = value
End Set
End Property
Public Property Email() As String
Get
Return _Email
End Get
Set(ByVal value As String)
_Email = value
End Set
End Property
Public Property Idade () As Byte
Get
Return _Idade
End Get
Set(ByVal value As Byte)
_Idade = value
End Set
End Property
Public Property ID () As Integer
Get
Return _ID
End Get
Set(ByVal value As Integer)
_ID = value
End Set
End Property
End ClassComo objeto de negócio, um Usuario será igual ao outro se, e somente se, o ID (chave primária) for igual nos dois objetos. Utiliza-se muito esse mecanismo em áreas de prevalência de dados.
Em uma situação típica, executaríamos o código abaixo para verificar se os usuários são iguais.
C#
if (userI.ID == userII.ID)
{
// Usuários Iguais
}
else
{
// Usários Diferentes
}VB.NET
If (userI.ID = userII.ID) Then
' Usuários Iguais
Else
' Usuários Diferentes
End IfNada de errado com a forma de se realizar essa verificação, contudo não está orientada a objetos e se por acaso a chave primária (que identifica um usuário) mudar, teremos um grande problemas em mãos.
A fim de minimizar esse problema, podemos adotar a interface (System.IEquatable<T>) e nosso objeto de usuário ficará:
C#
public class Usuario : IEquatable<Usuario>
{
private string _Nome;
private string _Email;
private byte _Idade;
private int _ID;
public string Nome
{
get { return _Nome; }
set { _Nome = value; }
}
public string Email
{
get { return _Email; }
set { _Email = value; }
}
public byte Idade
{
get { return _Idade; }
set { _Idade = value; }
}
public int ID
{
get { return _ID; }
set { _ID = value; }
}
public bool Equals(Usuario obj)
{
return obj.ID == this.ID;
}
}VB.NET
Public Class Usuario
Implements IEquatable(Of Usuario)
Private _Nome As String
Private _Email As String
Private _Idade As Byte
Private _ID As Integer
Public Property Nome() As String
Get
Return _Nome
End Get
Set(ByVal value As String)
_Nome = value
End Set
End Property
Public Property Email() As String
Get
Return _Email
End Get
Set(ByVal value As String)
_Email = value
End Set
End Property
Public Property Idade() As Byte
Get
Return _Idade
End Get
Set(ByVal value As Byte)
_Idade = value
End Set
End Property
Public Property ID() As Integer
Get
Return _ID
End Get
Set(ByVal value As Integer)
_ID = value
End Set
End Property
Public Function Equals(ByVal other As Usuario) As Boolean Implements IEquatable(Of Usuario).Equals
Return IIf(other.ID = Me.ID, True, False)
End Function
End ClassA partir deste momento, podemos utilizar a seguinte forma para a mesma comparação anterior:
C#
if (userI.Equals(userII))
{
// Usuários Iguais
}
else
{
// Usários Diferentes
}VB.NET
If (userI.Equals(userII)) Then
' Usuários Iguais
Else
' Usuários Diferentes
End IfDesta forma, temos uma comparação entre objetos de negócio de uma forma orientada a objetos e cuja regra de comparação fica restrita no próprio objeto. Acima de tudo, a regra ainda está TypeSafe graças à interface Generics utilizada.

Olá Guilherme, tudo bem?
Em primeiro lugar, parabéns pelo artigo.
Surgiu-me uma dúvida deveras leiga, qual seria a diferença caso tivéssemos implementado a função Equals sem usar a herança IEquatable?
Obrigado

Bom dia Lucas.
Bom, primeiramente não existem dúvidas leigas, hehehe
Enfim,
Você pode implementar o "Equals" sem a inteface, mas, ele não será TypeSafe.
De fato que, se for interessante comparar um Objeto com Outros vc pode e até deve implementar o Equals sem a Interface.
Contudo, pense que a maioria dos objetos e mecanismos (especialmente os melhor construidos) verificam se as objetos implementam tal interface afim de prover uma comparação mais precisa. Pode acontecer de algumas ferramentas e_ou componentes não executar o (Equals) sem a interface (IEquatable).
Espero ter respondido sua dúvida, pois, se não respondi é só mandar ela denovo.
Muito obrigado pelo tempo e interesse....

Olá Guilherme..
Primeiramente, parabéns pelo artigo.Eu sou desenvolvedor e sem dúvida a interface (IEquatable<T>) é bem confiável.Outro detalhe no seu artigo, é o uso do operador ternário (iif), um poderoso método do vb.
abraços e parabéns pelo artigo.
Jorge Teodoro
Os textos publicados neste espaço são de responsabilidade única de seus autores (colunistas e leitores) e podem não expressar necessariamente a opinião do iMasters.
Guilherme Bacellar é Bacharel em Ciências da Computação, Desenvolvedor .NET há 4 anos, MCAD, Autor de Livros e Artigos, Arquiteto de Software do Projeto D.NET (Framework de Desenvolvimento .NET). Blog: http://dotnetmax.bacellar.org/
2001 - iMasters FFPA Informática Ltda - Todos os direitos reservados.