C# conversiones implícitas y operador ==
-
23-08-2019 - |
Pregunta
Algún código para el contexto:
class a
{
}
class b
{
public a a{get;set;}
public static implicit operator a(b b)
{
return b.a;
}
}
a a=null;
b b=null;
a = b;
//compiler: cannot apply operator '==' to operands of type tralala...
bool c = a == b;
¿Es posible utilizar el operador == en diferentes instancias de tipo, donde uno puede convertir implícitamente a otro?¿Qué me perdí?
Editar:
Si los tipos deben ser los mismos llamando ==, entonces ¿por qué?
int a=1;
double b=1;
bool c=a==b;
¿obras?
Solución
El operador implicit
sólo funciona para la asignación.
Usted quiere sobrecargar el operador de igualdad (==
), como por ejemplo:
class a
{
public static bool operator ==(a x, b y)
{
return x == y.a;
}
public static bool operator !=(a x, b y)
{
return !(x == y);
}
}
class b
{
public a a{get;set;}
public static implicit operator a(b b)
{
return b.a;
}
}
Esto debería entonces permitirá comparar dos objetos de tipo a
y b
como se sugiere en su puesto.
var x = new a();
var y = new b();
bool c = (x == y); // compiles
Nota:
Yo se lo recomiendo simplemente reemplazando el método GetHashCode
y Equals
, como el compilador advierte, pero como parece que quieren suprimir ellos, puede hacerlo de la siguiente manera.
Cambiar su declaración de la clase de a
a:
#pragma warning disable 0660, 0661
class a
#pragma warning restore 0660, 0661
{
// ...
}
Otros consejos
¿Es posible utilizar == operador diferentes instancias de tipo, en los que uno puede convertir implícitamente a otra?
Sí.
¿Qué me he perdido?
Esta es la parte relevante de la especificación. Se ha perdido la palabra resaltada.
El predefinida igualdad tipo de referencia operadores requieren [que] ambos operandos son valores de tipo de referencia o las nula literal. Además, un estándar existe conversión implícita de la tipo de cualquiera de los operandos al tipo de el otro operando.
A de conversión definida por el usuario es, por definición, no una conversión estándar. Estos son los tipos de referencia. Por lo tanto, el operador de igualdad predefinido tipo de referencia no es un candidato.
Si los tipos deben ser los mismos que llama ==, entonces ¿por qué [int doble ==] funciona?
Su suposición de que los tipos deben ser del mismo es incorrecta. Hay un estándar de conversión implícita de int a doble y hay un operador de igualdad que tiene dos dobles, por lo que este funciona.
Creo que también se perdió este bit:
Se trata de un error en tiempo de compilación para utilizar el de referencia predefinido tipo igualdad operadores para comparar dos referencias que son conocidos por ser diferente en tiempo de compilación. Por ejemplo, si el tipos en tiempo de compilación de los operandos son dos tipos de clase A y B, y si ni A ni B se deriva de la otra, entonces sería imposible los dos operandos para hacer referencia a la misma objeto. Por lo tanto, la operación es considerado un error en tiempo de compilación.
Me imagino que se debe redefinir en realidad el operador == para los tipos que le interesan. Si la compilación / ejecución todavía se quejan incluso si los tipos son implícitamente convertible es algo que tendrá que experimentar.
public static bool operator ==(a a, b b)
{
//Need this check or we can't do obj == null in our Equals implementation
if (((Object)a) == null)
{
return false;
}
else
{
return a.Equals(b);
}
}
Como alternativa sólo tiene que utilizar implementaciones Igual a como sugiere ole6ka y asegurar que la aplicación que hace la colada tipo que usted necesita.
http://msdn.microsoft.com/en-us/library /8edha89s.aspx
En cada caso, un parámetro debe ser del mismo tipo que la clase o struct que declara el operador (...)
Utilizar esta
bool c = a.Equals(b);