CA2225: Gli overload degli operatori hanno alternative con nome

Articolo
08/11/2011

TypeName	OperatorOverloadsHaveNamedAlternates
CheckId	CA2225
Category	Microsoft.Usage
Breaking Change	Non sostanziale

Causa

È stato rilevato un overload di operatore e il metodo alternativo denominato previsto non è stato trovato.

Descrizione della regola

L'overload dell'operatore consente di utilizzare simboli per rappresentare calcoli per un tipo. Ad esempio, un tipo che esegue l'overload del segno più (+) per l'addizione presenta in genere un membro alternativo denominato "Add". Il membro alternativo denominato fornisce accesso alla stessa funzionalità dell'operatore e viene fornito per gli sviluppatori che programmano in linguaggi che non supportano operatori di overload.

Questa regola esamina gli operatori elencati nella tabella riportata di seguito.

C#	Visual Basic	C++	Nome alternativo
+ (binario)	+	+ (binario)	Add
+=	+=	+=	Add
&	And	&	BitwiseAnd
&=	And=	&=	BitwiseAnd
\|	Oppure	\|	BitwiseOr
\|=	Or=	\|=	BitwiseOr
--	N/D	--	Decrement
/	/	/	Divide
/=	/=	/=	Divide
==	=	==	Equals
^	Xor	^	Xor
^=	Xor=	^=	Xor
>	>	>	Confronto
>=	>=	>=	Confronto
++	N/D	++	Increment
!=	<>	!=	Equals
<<	<<	<<	LeftShift
<<=	<<=	<<=	LeftShift
<	<	<	Confronto
<=	<=	<=	Confronto
&&	N/D	&&	LogicalAnd
\|\|	N/D	\|\|	LogicalOr
!	N/D	!	LogicalNot
%	Mod	%	Mod o resto
%=	N/D	%=	Mod
* (binario)	*	*	Moltiplica
*=	N/D	*=	Moltiplica
~	Not	~	OnesComplement
>>	>>	>>	RightShift
>>=	N/D	>>=	RightShift
- (binario)	- (binario)	- (binario)	Subtract
-=	N/D	-=	Subtract
true	IsTrue	N/D	IsTrue (Proprietà)
- (unario)	N/D	-	Negate
+ (unario)	N/D	+	Plus
false	IsFalse	False	IsTrue (Proprietà)

N/D == Non può essere sottoposto a overload nel linguaggio selezionato.

La regola controlla inoltre gli operatori di cast impliciti ed espliciti in un tipo (SomeType) cercando i metodi denominati ToSomeType e FromSomeType.

In C#, quando si esegue l'overload di un operatore binario, viene eseguito in modo implicito anche l'overload dell'eventuale operatore di assegnazione corrispondente.

Come correggere le violazioni

Per correggere una violazione di questa regola, implementare il metodo alternativo per l'operatore; denominarlo utilizzando il nome alternativo consigliato.

Esclusione di avvisi

Non escludere un avviso da questa regola se si implementa una libreria condivisa. Le applicazioni possono ignorare un avviso da questa regola.

Esempio

Nell'esempio riportato di seguito viene definita una struttura che viola questa regola. Per correggere l'esempio, aggiungere un metodo Add(int x, int y) pubblico alla struttura.

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;}}
    }
}

Regole correlate

CA1046: Non eseguire l'overload dell'operatore "uguale a" per i tipi di riferimento

CA2226: Gli operatori devono avere overload simmetrici

CA2224: Eseguire l'override di Equals all'override dell'operatore

CA2218: Eseguire l'override di GetHashCode all'override di Equals

CA2231: Eseguire l'overload dell'operatore "uguale a" all'override di ValueType.Equals

Condividi tramite