CA1036: Eseguire l'override di metodi su tipi confrontabili
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
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per