C # conversões implícitos e == operador

Question

Alguns código para o 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; 

É possível usar == operador em diferentes instâncias do tipo, onde se pode converter implicitamente para outro? O que eu perdi?

Editar:
Se os tipos deve ser a mesma vocação ==, então porque

int a=1;
double b=1;
bool c=a==b; 

obras?

Answer 1

O operador implicit só funciona para atribuição.

Você quer sobrecarregar o operador de igualdade (==), tais como:

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

Esta deve então permitir que você compare dois objetos do tipo a e b como sugerido em seu post.

var x = new a();
var y = new b();
bool c = (x == y); // compiles

Nota:

I recommmend simplesmente substituindo o método GetHashCode e Equals, como o compilador avisa, mas como você parece querer suprimir-los, você pode fazer isso da seguinte forma.

Mude sua declaração de classe de a a:

#pragma warning disable 0660, 0661
class a
#pragma warning restore 0660, 0661
{
    // ...
}

Answer 2

É possível usar == operador em diferentes casos tipo, onde um pode converter implicitamente para outro?

Sim.

O que eu perdi?

Aqui está a parte relevante da especificação. Você perdeu a palavra destacada.

O tipo de referência predefinidos igualdade operadores requerem [que] os dois operandos são valores de tipo de referência ou os nula literal. Além disso, a padrão existe conversão implícita do tipo de quer operando com o tipo de o outro operando.

A conversão definida pelo utilizador é, por definição, não uma conversão padrão. Estes são tipos de referência. Portanto, a referência do operador Tipo de igualdade predefinido não é um candidato.

Se os tipos deve ser a mesma vocação ==, então porque [dupla == int] obras?

A sua suposição de que os tipos deve ser a mesma é incorreta. Há uma conversão implícita padrão de int para casal e há um operador de igualdade que leva duas duplas, então isso funciona.

Eu acho que você também perdeu este bit:

É um erro em tempo de compilação para usar o Tipo de igualdade de referência pré-definida operadores para comparar duas referências que são conhecidos como sendo diferentes em em tempo de compilação. Por exemplo, se o tipos em tempo de compilação dos operandos são dois tipos de classes A e B, e se nem deriva A nem B do outro, então seria impossível para os dois operandos de referência à mesma objeto. Assim, a operação é considerado um erro em tempo de compilação.

Answer 3

Eu imagino que você precisa para realmente substituir o operador == para os tipos que você está interessado. Se a compilação / runtime ainda vai reclamar mesmo se os tipos são implicitamente conversível é algo que você tem 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 apenas uso Igual implementações como ole6ka sugere e assegurar que a implementação faz o tipo de vazamento que você precisa.

Answer 4

http://msdn.microsoft.com/en-us/library /8edha89s.aspx

Em cada caso, um parâmetro deve ser do mesmo tipo que a classe ou struct que declara o operador (...)

Answer 5

Use esta

 bool c = a.Equals(b);