CA1013: Operátor rovná přetížení na přetížení sečíst a odečíst

Článek
03/04/2013

Název_typu	OverloadOperatorEqualsOnOverloadingAddAndSubtract
CheckId	CA1013
Kategorie	Microsoft.design
Změnit rozdělení	Bez rozdělení

Příčina

Typ veřejné nebo chráněné implementuje operátory sčítání nebo odčítání bez provádění operátor rovnosti.

Popis pravidla

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

Přetížená provádění operátor rovnosti nelze použít výchozí operátor rovnosti.To způsobí přetečení zásobníku.Chcete-li implementovat operátor rovnosti použijte metodu Object.Equals v implementaci.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 opravit porušení

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

Při potlačení upozornění

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

Příklad

Následující příklad definuje typ (BadAddableType), poruší toto pravidlo.Tento typ by mělo provádět operátor rovnosti provést dvě instance, které mají stejné hodnoty pole test true pro rovnost.Typ GoodAddableType zobrazí opravenou implementace.Tento typ také implementuje operátor nerovnost a přepíše Equals splňovat ostatní pravidla.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í instancí typů, které byly dříve definovány v tomto tématu ilustrují správné chování a výchozí operátor 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é

Referenční dokumentace

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

Sdílet prostřednictvím