CA1013: É igual a operador de sobrecarga em sobrecarga, adicionar e subtrair
TypeName |
OverloadOperatorEqualsOnOverloadingAddAndSubtract |
CheckId |
CA1013 |
<strong>Categoria</strong> |
Microsoft.design |
Alteração significativa |
Não-separável |
Causa
Um tipo de público ou protegido implementa os operadores de adição ou subtração sem implementar o operador de igualdade.
Descrição da regra
Quando as instâncias de um tipo podem ser combinadas usando operações como, por exemplo, adição e subtração, quase sempre você deve definir a igualdade para retornar true para quaisquer duas instâncias que têm o mesmo valores constituintes.
É possível usar o operador de igualdade padrão em uma implementação de sobrecarga de operador de igualdade. Isso fará com que um estouro de pilha. Para implementar o operador de igualdade, use o método Object. Equals em sua implementação. Consulte o exemplo a seguir.
If (Object.ReferenceEquals(left, Nothing)) Then
Return Object.ReferenceEquals(right, Nothing)
Else
Return left.Equals(right)
End If
if (Object.ReferenceEquals(left, null))
return Object.ReferenceEquals(right, null);
return left.Equals(right);
Como corrigir violações
Para corrigir uma violação desta regra, implemente o operador de igualdade para que ele seja matematicamente consistente com os operadores de adição e subtração.
Quando suprimir avisos
É seguro eliminar um aviso esta regra quando a implementação padrão do operador de igualdade fornece o comportamento correto para o tipo.
Exemplo
O exemplo a seguir define um tipo (BadAddableType) que viola essa regra. Este tipo deve implementar o operador de igualdade para tornar qualquer duas instâncias que têm os mesmos valores de campo de teste true de igualdade. O tipo de GoodAddableType mostra a implementação corrigido. Observe que esse tipo também implementa o operador de desigualdade e substitui Equals para atender a outras regras. Uma implementação completa também implementaria GetHashCode.
using System;
namespace DesignLibrary
{
public class BadAddableType
{
private int a, b;
public BadAddableType(int a, int b)
{
this.a = a;
this.b = b;
}
// Violates rule: OverrideOperatorEqualsOnOverridingAddAndSubtract.
public static BadAddableType operator +(BadAddableType a, BadAddableType b)
{
return new BadAddableType(a.a + b.a, a.b + b.b);
}
// Violates rule: OverrideOperatorEqualsOnOverridingAddAndSubtract.
public static BadAddableType operator -(BadAddableType a, BadAddableType b)
{
return new BadAddableType(a.a - b.a, a.b - b.b);
}
public override string ToString()
{
return String.Format("{{{0},{1}}}", a, b);
}
}
public class GoodAddableType
{
private int a, b;
public GoodAddableType(int a, int b)
{
this.a = a;
this.b = b;
}
// Satisfies rule: OverrideOperatorEqualsOnOverridingAddAndSubtract.
public static bool operator ==(GoodAddableType a, GoodAddableType b)
{
return (a.a == b.a && a.b == b.b);
}
// If you implement ==, you must implement !=.
public static bool operator !=(GoodAddableType a, GoodAddableType b)
{
return !(a==b);
}
// Equals should be consistent with operator ==.
public override bool Equals(Object obj)
{
GoodAddableType good = obj as GoodAddableType;
if (obj == null)
return false;
return this == good;
}
public static GoodAddableType operator +(GoodAddableType a, GoodAddableType b)
{
return new GoodAddableType(a.a + b.a, a.b + b.b);
}
public static GoodAddableType operator -(GoodAddableType a, GoodAddableType b)
{
return new GoodAddableType(a.a - b.a, a.b - b.b);
}
public override string ToString()
{
return String.Format("{{{0},{1}}}", a, b);
}
}
}
O exemplo a seguir testa a igualdade usando instâncias dos tipos que foram definidos anteriormente neste tópico para ilustrar o padrão e o comportamento correto para o operador de igualdade.
using System;
namespace DesignLibrary
{
public class TestAddableTypes
{
public static void Main()
{
BadAddableType a = new BadAddableType(2,2);
BadAddableType b = new BadAddableType(2,2);
BadAddableType x = new BadAddableType(9,9);
GoodAddableType c = new GoodAddableType(3,3);
GoodAddableType d = new GoodAddableType(3,3);
GoodAddableType y = new GoodAddableType(9,9);
Console.WriteLine("Bad type: {0} {1} are equal? {2}", a,b, a.Equals(b)? "Yes":"No");
Console.WriteLine("Good type: {0} {1} are equal? {2}", c,d, c.Equals(d)? "Yes":"No");
Console.WriteLine("Good type: {0} {1} are == ? {2}", c,d, c==d? "Yes":"No");
Console.WriteLine("Bad type: {0} {1} are equal? {2}", a,x, a.Equals(x)? "Yes":"No");
Console.WriteLine("Good type: {0} {1} are == ? {2}", c,y, c==y? "Yes":"No");
}
}
}
O exemplo produz a seguinte saída.
Consulte também
Referência
Diretrizes para a implementação de Equals e o operador de igualdade (= =)