C#, múltiples== sobrecargas de operador sin comprobación nula ambigua

operator-overloading null-check

Question

Introducción :
Tengo algunas clases que hacen el mismo trabajo, pero con diferentes tipos de valores (por ejemplo, Vectores de flotadores o enteros).
Ahora quiero poder verificar la igualdad, esta igualdad también debería funcionar entre los tipos (como vectorF == vectorI).
Además, debería ser posible realizar una comprobación nula (vectorF == null).

Enfoque
Mi enfoque es crear múltiples sobrecargas para los operadores == y! =, Una para cada combinación posible.

public sealed class VectorF
{
[...]
public static bool operator == (VectorF left, VectorI right)
{
// Implementation...
}
public static bool operator == (VectorF left, VectorF right)
{
// Implementation...
}
// Same for != operator
[...]
}

Problema
Al usar varias sobrecargas, no puedo hacer una comprobación nula con el operador ==, ya que la llamada sería ambigua.

var v = new VectorF([...]);
if (v == null) // This call is ambiguous
[...]

Soy consciente de la posibilidad de usar un ReferenceEquals o un casting nulo en su lugar, pero ese enfoque es una seria restricción para mí.

var v = new VectorF([...]);
if(object.ReferenceEquals(v, null)) // Would work, is not user friendly.
[...]
if(v == (VectorF)null) // Would also work, is neither user friendly.
[...]

Pregunta :
¿Hay una manera de implementar el operador == de una manera que permita la simple comprobación de nulos y permita la verificación de igualdad entre los diferentes vectores?

Alternativamente, ¿hay otra forma en la que podría / debería implementar esto?

Answer 1

Lo que haría en este caso es no sobrecargar al operador == y, en cambio, hacer algo como:

public static bool operator == (VectorF left, object right) {
if (object.ReferenceEquals(null, right)) {
// handle null case
}
VectorF rightF = right as VectorF;
if (!object.ReferenceEquals(null, rightF)) {
// Compare VectorF
}
VectorI rightI = right as VectorI;
if (!object.ReferenceEquals(null, rightI)) {
// Compare VectorI
}
// and so on...
}

Answer 2

Para empezar, presionaría todo el diseño. Nunca implementaría == con semántica de valor entre diferentes tipos, lo encontraría bastante confuso: instaceTypedA == instanceTypedB grita la igualdad de referencia (al menos para mí).

Si necesita que esto funcione, entonces implemente una conversión implícita entre VectorI y VectorF . Así es como funciona el marco. Cuando haces lo siguiente:

int i = 1;
double d = 1;
var b = i == d;

Una sobrecarga ==(int, double) no se produce mágicamente. Lo que sucede es que i se convierte implícitamente a double y se invoca a ==(double, double) .

Answer 3

Puedes dar la vuelta a la comparación usando:

if (v is VectorF)

Esta comprobación fallará si v es null .