opérateur implicite de l'utilisation d'interfaces

J'ai une classe générique que je suis en train de mettre en œuvre implicite type de casting pour. Alors qu'il travaille, il ne fonctionnera pas pour l'interface de la coulée. Après enquête, j'ai trouvé qu'il y est une erreur de compilateur: "conversion définie par l'Utilisateur à partir de l'interface" qui s'applique. Bien que je comprenne que ce doivent être appliquées dans certains cas, ce que je suis en train de faire ne semblent légitimes cas.

Voici un exemple:

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);
    }
}

Code à utiliser:

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

Quelqu'un sait-il une solution de contournement, ou peut-on expliquer de manière satisfaisante pourquoi je shuouldn pas être en mesure de lancer interfaceReferenceToBar implicitement à Foo<IBar>, étant donné que dans mon cas, il n'est pas converti, mais seulement contenues dans Foo?

EDIT:
Il ressemble à la covariance peut offrir le salut. Espérons que le C# 4.0 spécification permet la conversion implicite de types d'interface à l'aide de la covariance.