Tengo una clase genérica para la que estoy intentando implementar la conversión implícita de tipos. Si bien funciona principalmente, no funcionará para el intercambio de interfaces. Tras una investigación adicional, descubrí que hay un error de compilación: se aplica "conversión definida por el usuario desde la interfaz". Si bien entiendo que esto debería aplicarse en algunos casos, lo que estoy tratando de hacer parece ser un caso legítimo.

Aquí hay un ejemplo:

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 usarlo:

var concreteReferenceToBar = new ConcreteBar();
IBar intefaceReferenceToBar = concreteReferenceToBar;
Foo<ConcreteBar> concreteFooFromConcreteBar = concreteReferenceToBar;
Foo<IBar> fooFromConcreteBar = concreteReferenceToBar;
Foo<IBar> fooFromInterfaceBar = intefaceReferenceToBar; // doesn't work

¿Alguien sabe una solución, o alguien puede explicar de manera satisfactoria por qué no debería poder emitir?interfaceReferenceToBar implícitamente aFoo<IBar>, ya que en mi caso no se está convirtiendo, sino que solo está contenido dentro de Foo?

EDITAR: Parece que la covarianza podría ofrecer salvación. Esperemos que la especificación C # 4.0 permita la conversión implícita de tipos de interfaz utilizando covarianza.