Sobrecarga de operador equals em sobrecarga adicionar e subtrair

Causa

Um tipo público ou protegido implementa os operadores de adição ou subtração sem implementar o operador de igualdade.

Descrição da regra

Instâncias de um tipo podem ser combinado usando operações sistema autônomo adição e subtração, quase sempre você deve definir igualdade retornar true para quaisquer duas instâncias que possuem sistema autônomo mesmos valores constituintes.

Não é possível usar o operador de igualdade padrão em uma implementação do operador de igualdade sobrecarregada.Isso fará com que um estouro de pilha.Para implementar o operador de igualdade, use o método objeto.Equals na sua implementação.Por exemplo:

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 dessa regra, implemente o operador de igualdade de forma que ele é matematicamente consistente com os operadores de adição e subtração.

Quando suprimir avisos

É seguro eliminar um aviso da 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 as duas instâncias com os mesmos valores de campo testar true igualdade. O tipo de GoodAddableType mostra a implementação correta. 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 de tipos que foram definidos anteriormente neste tópico para ilustrar os 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.

Bad type:  {2,2} {2,2} are equal? No Good type: {3,3} {3,3} are equal? Yes Good type: {3,3} {3,3} are == ?   Yes Bad type:  {2,2} {9,9} are equal? No Good type: {3,3} {9,9} are == ?   No

Consulte também

Referência

Diretrizes para implementação é igual A e o operador de igualdade (==)