CA1036: Eseguire l'override di metodi su tipi confrontabili

  • Articolo
Proprietà valore
ID regola CA1036
Titolo Eseguire l'override di metodi su tipi confrontabili
Categoria Progettazione
Correzione che causa un'interruzione o un'interruzione Nessuna interruzione
Abilitato per impostazione predefinita in .NET 8 No

Causa

Un tipo implementa l'interfaccia e non esegue l'override System.IComparableSystem.Object.Equals o non esegue l'overload dell'operatore specifico del linguaggio per uguaglianza, disuguaglianza, minore o maggiore di. La regola non segnala una violazione se il tipo eredita solo un'implementazione dell'interfaccia.

Per impostazione predefinita, questa regola esamina solo i tipi visibili esternamente, ma è configurabile.

Descrizione regola

I tipi che definiscono un ordinamento personalizzato implementano l'interfaccia IComparable . Il CompareTo metodo restituisce un valore intero che indica l'ordinamento corretto per due istanze del tipo. Questa regola identifica i tipi che impostano un ordinamento. L'impostazione di un ordinamento implica che il significato ordinario di uguaglianza, disuguaglianza, minore e maggiore di non si applica. Quando si fornisce un'implementazione di IComparable, è in genere necessario eseguire l'override anche in modo che restituisca Equals valori coerenti con CompareTo. Se si esegue l'override Equals e si codifica in un linguaggio che supporta gli overload degli operatori, è necessario fornire anche operatori coerenti con Equals.

Come correggere le violazioni

Per correggere una violazione di questa regola, eseguire l'override Equalsdi . Se il linguaggio di programmazione supporta l'overload degli operatori, specificare gli operatori seguenti:

  • op_Equality
  • op_Inequality
  • op_LessThan
  • op_GreaterThan

In C# i token usati per rappresentare questi operatori sono i seguenti:

==
!=
<
>

Quando eliminare gli avvisi

È possibile eliminare un avviso dalla regola CA1036 quando la violazione è causata da operatori mancanti e il linguaggio di programmazione non supporta l'overload degli operatori, come nel caso di Visual Basic. Se si determina che l'implementazione degli operatori non ha senso nel contesto dell'app, è anche possibile eliminare un avviso da questa regola quando viene attivato sugli operatori di uguaglianza diversi da op_Equality. È tuttavia consigliabile eseguire sempre l'override di op_Equality e dell'operatore == se si esegue l'override Object.Equalsdi .

Eliminare un avviso

Se si vuole eliminare una singola violazione, aggiungere direttive del preprocessore al file di origine per disabilitare e quindi riabilitare la regola.

#pragma warning disable CA1036
// The code that's violating the rule is on this line.
#pragma warning restore CA1036

Per disabilitare la regola per un file, una cartella o un progetto, impostarne la gravità none su nel file di configurazione.

[*.{cs,vb}]
dotnet_diagnostic.CA1036.severity = none

Per altre informazioni, vedere Come eliminare gli avvisi di analisi del codice.

Configurare il codice da analizzare

Usare l'opzione seguente per configurare le parti della codebase in cui eseguire questa regola.

È possibile configurare questa opzione solo per questa regola, per tutte le regole a cui si applica o per tutte le regole in questa categoria (Progettazione) a cui si applica. Per altre informazioni, vedere Opzioni di configurazione delle regole di qualità del codice.

Includere superfici API specifiche

È possibile configurare le parti della codebase in modo da eseguire questa regola in base all'accessibilità. Ad esempio, per specificare che la regola deve essere eseguita solo sulla superficie dell'API non pubblica, aggiungere la coppia chiave-valore seguente a un file con estensione editorconfig nel progetto:

dotnet_code_quality.CAXXXX.api_surface = private, internal

Esempi

Il codice seguente contiene un tipo che implementa IComparablecorrettamente . I commenti di codice identificano i metodi che soddisfano varie regole correlate a Equals e all'interfaccia IComparable .

// 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, IComparable<RatingInformation>
{
    public string Rating
    {
        get;
        private set;
    }

    public RatingInformation(string rating)
    {
        if (rating == null)
        {
            throw new ArgumentNullException("rating");
        }

        string v = rating.ToUpper(CultureInfo.InvariantCulture);
        if (v.Length != 1 || string.Compare(v, "C", StringComparison.Ordinal) > 0 || string.Compare(v, "A", StringComparison.Ordinal) < 0)
        {
            throw new ArgumentException("Invalid rating value was specified.", "rating");
        }

        Rating = v;
    }

    public int CompareTo(object? obj)
    {
        if (obj == null)
        {
            return 1;
        }

        if (obj is RatingInformation other)
        {
            return CompareTo(other);
        }

        throw new ArgumentException("A RatingInformation object is required for comparison.", "obj");
    }

    public int CompareTo(RatingInformation? other)
    {
        if (other is null)
        {
            return 1;
        }

        // Ratings compare opposite to normal string order, 
        // so reverse the value returned by String.CompareTo.
        return -string.Compare(this.Rating, other.Rating, StringComparison.OrdinalIgnoreCase);
    }

    public static int Compare(RatingInformation left, RatingInformation right)
    {
        if (object.ReferenceEquals(left, right))
        {
            return 0;
        }
        if (left is null)
        {
            return -1;
        }
        return left.CompareTo(right);
    }

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

        return false;
    }

    // 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 left, RatingInformation right)
    {
        if (left is null)
        {
            return right is null;
        }
        return left.Equals(right);
    }
    public static bool operator !=(RatingInformation left, RatingInformation right)
    {
        return !(left == right);
    }
    public static bool operator <(RatingInformation left, RatingInformation right)
    {
        return (Compare(left, right) < 0);
    }
    public static bool operator >(RatingInformation left, RatingInformation right)
    {
        return (Compare(left, right) > 0);
    }
}

Il codice dell'applicazione seguente verifica il comportamento dell'implementazione IComparable illustrata in precedenza.

public class Test
{
    public static void Main1036(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);
    }
}

Vedi anche