operador implícito usando interfaces
-
02-07-2019 - |
Pergunta
Eu tenho uma classe genérica que eu estou tentando implementar fundição tipo implícito para. Embora a maioria funciona, ele não vai funcionar para fundição interface. Ao investigar mais, descobri que há um erro do compilador: "conversão definida pelo usuário a partir da interface" que se aplica. Embora eu entenda que este deve ser aplicada em alguns casos, o que eu estou tentando fazer parece ser um caso legítimo.
Aqui está um exemplo:
public class Foo<T> where T : IBar
{
private readonly T instance;
public Foo(T instance)
{
this.instance = instance;
}
public T Instance
{
get { return instance; }
}
public static implicit operator Foo<T>(T instance)
{
return new Foo<T>(instance);
}
}
código para usá-lo:
var concreteReferenceToBar = new ConcreteBar();
IBar intefaceReferenceToBar = concreteReferenceToBar;
Foo<ConcreteBar> concreteFooFromConcreteBar = concreteReferenceToBar;
Foo<IBar> fooFromConcreteBar = concreteReferenceToBar;
Foo<IBar> fooFromInterfaceBar = intefaceReferenceToBar; // doesn't work
Alguém sabe uma solução alternativa, ou alguém pode explicar de forma satisfatória porque eu shuouldn't ser capaz de interfaceReferenceToBar
elenco implicitamente Foo<IBar>
, já que no meu caso não está sendo convertido, mas apenas contido dentro Foo?
EDIT: Parece que covariância podem oferecer salvação. Vamos esperar que o C # 4.0 especificação permite a conversão implícita de tipos de interface usando covariância.
Solução
A razão que você não pode fazer isso é porque ele é especificamente proibido na especificação da linguagem C #:
classe A ou struct é permitido declarar uma conversão a partir de uma fonte tipo S para um tipo de alvo t fornecida todos dos seguintes forem verdadeiras:
- ...
- Nem S, nem T é
object
ou um -tipo de interface .
e
conversões definidas pelo usuário não são permitiu converter de ou para interface de tipos . Em particular, este garante que nenhuma restrição transformações definidas pelo utilizador ocorrer ao converter para um interface de tipo , e que a conversão a um interface de tipo tem sucesso apenas se o objecto a ser convertido na verdade implementa o especificado interface de tipo .