Substituir métodos nos tipos comparáveis

Causa

Um tipo público ou protegido implementa o System.IComparable interface e não substituir Object.Equals ou não sobrecarregar o operador específico do linguagem igualdade, desigualdade, menor ou maior que. A regra não relata uma violação se o tipo herda somente a uma implementação da interface.

Descrição da regra

Tipos que definem uma ordem de classificar personalizada implementam o IComparable interface. The CompareTo método retorna um valor inteiro que indica a ordem de classificar adequada de duas instâncias do tipo. Esta regra identifica tipos de conjunto uma ordem de classificar, indicando que o significado comum de igualdade, desigualdade, menor e maior do que não se aplicam.Quando você fornecer uma implementação de IComparable, geralmente é necessário à substituir também Equals para que ele retorne valores que são consistentes com CompareTo. Se você substituir Equals e está codificando em uma linguagem que suporta sobrecargas de operador, você também deve fornecer os operadores são consistentes com Equals.

Como corrigir violações

Para corrigir uma violação dessa regra, substitua Equals. Se sua linguagem de programação oferece suporte a sobrecarga de operador, fornecer os seguintes operadores:

• op_Equality

• op_Inequality

• op_LessThan

• op_GreaterThan

Em translation from VPE for Csharp, os tokens usados para representar esses operadores são: ==, !=, <, and >.

Quando suprimir avisos

É seguro eliminar um aviso da regra quando a violação é causada por operadores estão faltando e sua linguagem de programação não suporta o sobrecarga de operador, assim sistema autônomo acontece com o Visual Basic. NET.

Exemplo

O exemplo a seguir contém um tipo que implementa corretamente IComparable. Comentários do código identificam os métodos que satisfaçam várias regras relacionadas a Equals e o IComparable interface.

using System;
using System.Globalization;

namespace DesignLibrary
{
   // Valid ratings are between A and C.
   // A is the highest rating; it is greater than any other valid rating.
   // C is the lowest rating; it is less than any other valid rating.

   public class RatingInformation :IComparable 
   {
      private string rating;

      public RatingInformation (string s)
      {
         string v = s.ToUpper(CultureInfo.InvariantCulture);
         if (v.CompareTo("C") > 0 || v.CompareTo("A") < 0 || v.Length != 1)
         {
            throw new ArgumentException("Invalid rating value was specified.");
         }
         rating = v;
      }

      public int CompareTo ( object obj)
      {
         if (!(obj is RatingInformation))
         {
            throw new ArgumentException(
               "A RatingInformation object is required for comparison.");
         }
         // Ratings compare opposite to normal string order,
         // so reverse the value returned by String.CompareTo.
         return -1 * this.rating.CompareTo(((RatingInformation)obj).rating);
      }

      public string Rating 
      {
         get { return rating;}
      }

      // Omitting Equals violates rule: OverrideMethodsOnComparableTypes.
      public override bool Equals (Object obj)
      {
         if (!(obj is RatingInformation))
            return false;
         return (this.CompareTo(obj)== 0);
      }  

      // Omitting getHashCode violates rule: OverrideGetHashCodeOnOverridingEquals.
      public override int GetHashCode ()
      {
         char [] c = this.Rating.ToCharArray();
         return (int) c[0];
      }  
      // Omitting any of the following operator overloads 
      // violates rule: OverrideMethodsOnComparableTypes.
      public static bool operator == (RatingInformation r1, RatingInformation r2)
      {
         return r1.Equals(r2);
      }  
      public static bool operator != (RatingInformation r1, RatingInformation r2)
      {
        return !(r1==r2);
      }  
      public static bool operator < (RatingInformation r1, RatingInformation r2)
      {
         return (r1.CompareTo(r2) < 0);
      }  
      public static bool operator > (RatingInformation r1, RatingInformation r2)
      {
         return (r1.CompareTo(r2) > 0);
      }  
   }
}

O aplicativo a seguir testa o comportamento do IComparable implementação mostrada anteriormente.

using System;

namespace DesignLibrary
{
    public class Test
    {
       public static void Main(string [] args)
       {
          if (args.Length < 2)
          {
             Console.WriteLine ("usage - TestRatings  string 1 string2");
             return;
          }
          RatingInformation r1 = new RatingInformation(args[0]) ;
          RatingInformation r2 = new RatingInformation( args[1]);
          string answer;

          if (r1.CompareTo(r2) > 0)
             answer = "greater than";
          else if (r1.CompareTo(r2) < 0)
             answer = "less than";
          else
             answer = "equal to";

          Console.WriteLine("{0} is {1} {2}", r1.Rating, answer, r2.Rating);      
       }
    }
}

Consulte também

Referência

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

System.IComparable

Object.Equals