CA1013: Přetižte operátor rovnosti společně s přetížením operátorů sčítání a odečítání

TypeName	OverloadOperatorEqualsOnOverloadingAddAndSubtract
CheckId	CA1013
Kategorie	Microsoft.Design
Narušující změna	Nenarušující

Příčina

Veřejný nebo chráněný typ implementuje operátory sčítání a odčítání, aniž by implementoval operátor rovnosti.

Popis pravidla

Když instance typu lze kombinovat pomocí operace jako sčítání a odčítání, téměř vždy měli definovat rovnosti vrátil true pro libovolné dvě instance, které mají stejné základní hodnoty.

Nelze použít výchozí operátor rovnosti v přetížené implementaci operátoru rovnosti.Pokračování v této činnosti by vedlo k přetečení zásobníku.Pro implementaci operátoru rovnosti je v implementaci zapotřebí použít metodu Object.Equals.Viz následující příklad.

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);

Jak vyřešit porušení

Chcete-li k porušení tohoto pravidla, implementujte tak, aby je matematicky konzistentní s operátory sčítání a odčítání operátor rovnosti.

Kdy potlačit upozornění

Je bezpečné při provádění výchozí operátor rovnosti stanoví typ správné chování potlačit upozornění od tohoto pravidla.

Příklad

Následující příklad definuje typ (BadAddableType), toto pravidlo porušují.Tento typ musí implementovat operátor rovnosti, aby jakékoliv dvě instance, které mají stejné hodnoty pole test true pro rovnost.Typ GoodAddableType ukazuje implementaci opravený.Poznámka: Tento typ také implementuje nerovnost operátor a přepíše Equals k uspokojení jiných pravidel.Kompletní implementace by také implementovat 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);
      }
   }
}

Následující příklad testuje rovnost pomocí instance typů, které byly dříve definovány v tomto tématu popisují výchozí a správné chování operátoru rovnosti.

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");
       }
    }
}

Tento příklad vytvoří následující výstup.

Viz také

Další zdroje

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