operador implícito usando interfaces

Question

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.

Answer 1

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 .

Fonte