operador implícito que usa interfaces

Question

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

He aquí 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 utilizarlo:

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 puede alguien explicar de manera satisfactoria por lo que shuouldn't capaz de lanzar interfaceReferenceToBar implícitamente a Foo<IBar>, ya que en mi caso no se está convirtiendo, pero solo figura dentro de Foo?

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

Answer 1

La razón por la que no puede hacer esto es porque está prohibido específicamente en la especificación del lenguaje C#:

A class or struct is permitted to declare a conversion from a source type S to a target type T provided all of the following are true:

• ...
• Neither S nor T is object or an interface-type.

y

User-defined conversions are not allowed to convert from or to interface-types. In particular, this restriction ensures that no user-defined transformations occur when converting to an interface-type, and that a conversion to an interface-type succeeds only if the object being converted actually implements the specified interface-type.

Source