C# conversiones implícitas y operador ==

Question

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?

Answer 1

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
{
    // ...
}

Answer 2

  

¿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.

Answer 3

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.

Answer 4

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 (...)

Answer 5

Utilizar esta

 bool c = a.Equals(b);