CA2225 : Les surcharges d'opérateur offrent d'autres méthodes nommées

  • Article
Propriété Value
Identificateur de la règle CA2225
Titre Les surcharges d'opérateur offrent d'autres méthodes nommées
Catégorie Utilisation
Le correctif est cassant ou non cassant Sans rupture
Activé par défaut dans .NET 8 Non

Cause

Une surcharge d’opérateur a été détectée, et la méthode de substitution nommée attendue n’a pas été trouvée.

Par défaut, cette règle examine uniquement les types visibles en externe, mais elle est configurable.

Description de la règle

La surcharge d’opérateur permet d’utiliser des symboles pour représenter des calculs pour un type. Par exemple, un type qui surcharge le symbole plus + pour l’addition aurait généralement un autre membre nommé Add. L’autre membre nommé fournit l’accès à la même fonctionnalité que l’opérateur. Il est destiné aux développeurs qui programment dans des langages qui ne prennent pas en charge les opérateurs surchargés.

Cette règle examine ce qui suit :

  • Les opérateurs de cast implicite et explicite dans un type en vérifiant les méthodes nommées To<typename> et From<typename>

  • Les opérateurs listés dans le tableau suivant :

C# Visual Basic C++ Nom de l’autre méthode
+ (binaire) + + (binaire) Ajouter
+= += += Ajouter
& And & BitwiseAnd
&= And= &= BitwiseAnd
| ou | BitwiseOr
|= Or= |= BitwiseOr
-- N/A -- Décrémentation
/ / / Diviser
/= /= /= Diviser
== = == Égal à
^ Xor ^ Xor
^= Xor= ^= Xor
> > > CompareTo ou Compare
>= >= >= CompareTo ou Compare
++ N/A ++ Incrément
!= <> != Égal à
<< << << LeftShift
<<= <<= <<= LeftShift
< < < CompareTo ou Compare
<= <= <= CompareTo ou Compare
&& S/O && LogicalAnd
|| N/A || LogicalOr
! N/A ! LogicalNot
% Mod % Mod ou Remainder
%= N/A %= Mod
* (binaire) * * Multiplier
*= N/A *= Multiplier
~ Not ~ OnesComplement
>> >> >> RightShift
>>= N/A >>= RightShift
- (binaire) - (binaire) - (binaire) Soustraire
-= N/A -= Soustraire
true IsTrue N/A IsTrue (propriété)
- (unaire) N/A - Negate
+ (unaire) N/A + Plus
false IsFalse False IsTrue (propriété)

*N/A signifie que l’opérateur ne peut pas être surchargé dans le langage sélectionné.

Notes

En C#, quand un opérateur binaire est surchargé, l’opérateur d’assignation correspondant, le cas échéant, est aussi implicitement surchargé.

Comment corriger les violations

Pour corriger une violation de cette règle, implémentez la méthode de substitution pour l’opérateur. Nommez-la en utilisant l’autre nom recommandé.

Quand supprimer les avertissements

Ne supprimez pas un avertissement de cette règle si vous implémentez une bibliothèque partagée. Les applications peuvent ignorer un avertissement de cette règle.

Supprimer un avertissement

Si vous voulez supprimer une seule violation, ajoutez des directives de préprocesseur à votre fichier source pour désactiver et réactiver la règle.

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

Pour désactiver la règle sur un fichier, un dossier ou un projet, définissez sa gravité sur none dans le fichier de configuration.

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

Pour plus d’informations, consultez Comment supprimer les avertissements de l’analyse de code.

Configurer le code à analyser

Utilisez l’option suivante pour configurer les parties de votre codebase sur lesquelles exécuter cette règle.

Vous pouvez configurer cette option pour cette règle uniquement, pour toutes les règles auxquelles elle s’applique ou pour toutes les règles de cette catégorie (Utilisation) auxquelles elle s’applique. Pour plus d’informations, consultez Options de configuration des règles de qualité du code.

Inclure des surfaces d’API spécifiques

Vous pouvez configurer les parties de votre codebase sur lesquelles exécuter cette règle, en fonction de leur accessibilité. Par exemple, pour spécifier que la règle doit s’exécuter uniquement sur la surface d’API non publique, ajoutez la paire clé-valeur suivante à un fichier .editorconfig dans votre projet :

dotnet_code_quality.CAXXXX.api_surface = private, internal

Exemple

L’exemple suivant définit une structure qui enfreint cette règle. Pour corriger l’exemple, ajoutez une méthode publique Add(int x, int y) à la structure.

public struct Point
{
    private int x, y;

    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public override string ToString()
    {
        return String.Format("({0},{1})", x, y);
    }

    // Violates rule: OperatorOverloadsHaveNamedAlternates.
    public static Point operator +(Point a, Point b)
    {
        return new Point(a.x + b.x, a.y + b.y);
    }

    public int X { get { return x; } }
    public int Y { get { return x; } }
}