C # conversões implícitos e == operador
-
23-08-2019 - |
Pergunta
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?
Solução
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
{
// ...
}
Outras dicas
É 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.
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.
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 (...)
Use esta ??p>
bool c = a.Equals(b);