Gli overload degli operatori hanno alternative con nome

Articolo
09/12/2008

Aggiornamento: novembre 2007

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
\|	Or	\|	BitwiseOr
\|=	Or=	\|=	BitwiseOr
--	N/D	--	Decrement
/	/	/	Divide
/=	/=	/=	Divide
==	=	==	Equals
^	Xor	^	Xor
^=	Xor=	^=	Xor
>	>	>	Compare
>=	>=	>=	Compare
++	N/D	++	Increment
!=	<>	!=	Equals
<<	<<	<<	LeftShift
<<=	<<=	<<=	LeftShift
<	<	<	Compare
<=	<=	<=	Compare
&&	N/D	&&	LogicalAnd
\|\|	N/D	\|\|	LogicalOr
!	N/D	!	LogicalNot
%	Mod	%	Mod o resto
%=	N/D	%=	Mod
* (binario)	*	*	Multiply
*=	N/D	*=	Multiply
~	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.

Correzione di 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.

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

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

Gli operatori devono avere overload simmetrici

Eseguire l'override di Equals all'overload dell'operatore "uguale a"

Eseguire l'override di GetHashCode all'override di Equals

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

Condividi tramite