CA1013: sobrecarregar igualdades de operador em add e subtract de sobrecarga

Causa

Um público ou um tipo protegido implementam 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 adição e subtração, você deve quase sempre definir a igualdade para retornar true para todas as duas instâncias que têm os mesmos valores de.

Você não pode usar o operador de igualdade padrão em uma implementação sobrecarregada do operador de igualdade.Isso causará um estouro de pilha.Para implementar o operador de igualdade, use o método de 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 de modo que ele seja matematicamente consistente com os operadores de adição e subtração.

Quando Suprimir Alertas

É seguro suprimir um aviso desta 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 tipoBadAddableType() que viola esta regra.Esse tipo deve implementar o operador de igualdade para fazer todas as duas instâncias que tenham o mesmo teste true dos valores de campo para fins de igualdade.O tipo GoodAddableType mostra a implementação fixa.Observe que esse tipo também implementa o operador de desigualdade e substitui Equals para as outras regras.Uma implementação completo 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 de tipos que foram definidas anteriormente neste tópico para ilustrar o comportamento padrão e 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

Outros recursos

Guidelines for Implementing Equals and the Equality Operator (==)