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

Article
08/10/2011

TypeName	OperatorOverloadsHaveNamedAlternates
CheckId	CA2225
Catégorie	Microsoft.Usage
Modification avec rupture	Modification sans rupture

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.

Description de la règle

La surcharge d'opérateur autorise l'utilisation de symboles pour représenter des calculs pour un type. Par exemple, un type qui surcharge le symbole plus (+) pour l'addition aurait en général un membre de substitution nommé 'Add'. Le membre de substitution nommé donne accès aux mêmes fonctionnalités que l'opérateur. Il est fourni aux développeurs qui programment dans les langages qui ne prennent pas en charge les opérateurs surchargés.

Cette règle examine les opérateurs répertoriés dans le tableau suivant.

C#	Visual Basic	C++	Nom de substitution
+ (binaire)	+	+ (binaire)	Ajouter
+=	+=	+=	Ajouter
&	And	&	BitwiseAnd
&=	And=	&=	BitwiseAnd
\|	Or	\|	BitwiseOr
\|=	Or=	\|=	BitwiseOr
--	N/A	--	Decrement
/	/	/	Divide
/=	/=	/=	Divide
==	=	==	Equals
^	Xor	^	Xor
^=	Xor=	^=	Xor
>	>	>	Comparaison
>=	>=	>=	Comparaison
++	N/A	++	Increment
!=	<>	!=	Equals
<<	<<	<<	LeftShift
<<=	<<=	<<=	LeftShift
<	<	<	Comparaison
<=	<=	<=	Comparaison
&&	N/A	&&	LogicalAnd
\|\|	N/A	\|\|	LogicalOr
!	N/A	!	LogicalNot
%	Mod	%	Mod or Remainder
%=	N/A	%=	Mod
* (binaire)	*	*	Multiplier
*=	N/A	*=	Multiplier
~	Not	~	OnesComplement
>>	>>	>>	RightShift
>>=	N/A	>>=	RightShift
- (binaire)	- (binaire)	- (binaire)	Subtract
-=	N/A	-=	Subtract
true	IsTrue	N/A	IsTrue (Property)
- (unaire)	N/A	-	Negate
+ (unaire)	N/A	+	Plus
false	IsFalse	False	IsTrue (Property)

N/D == ne peut pas être surchargé dans la langue sélectionnée.

La règle vérifie également les opérateurs de cast implicites et explicites dans un type (SomeType) en vérifiant la présence de méthodes nommées ToSomeType et FromSomeType.

En C#, lorsqu'un opérateur binaire est surchargé, l'opérateur d'assignation correspondant (s'il y en a un) est, lui aussi, implicitement surchargé.

Comment corriger les violations

Pour corriger une violation de cette règle, implémentez la méthode de substitution destinée à l'opérateur ; nommez-la à l'aide du nom de substitution recommandé.

Quand supprimer les avertissements

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

Exemple

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

using System;

namespace UsageLibrary
{
    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;}}
    }
}

Règles connexes

CA1046 : Ne pas surcharger l'opérateur égal à sur les types référence

CA2226 : Les opérateurs doivent contenir des surcharges symétriques

CA2224 : Remplacez Equals au moment de surcharger l'opérateur égal

CA2218 : Remplacez GetHashCode au moment de remplacer Equals

CA2231 : Surchargez l'opérateur égal (equals) en remplaçant ValueType.Equals

Partager via