opérateur implicite utilisant des interfaces

Question

J'ai une classe générique pour laquelle j'essaie d'implémenter le transtypage de type implicite. Bien que cela fonctionne principalement, cela ne fonctionnera pas pour la conversion d'interface. Après un examen plus approfondi, j'ai constaté une erreur de compilation: & Quot; Conversion définie par l'utilisateur à partir de l'interface & Quot; cela s'applique. Bien que je comprenne que cela devrait être appliqué dans certains cas, ce que j'essaie de faire semble être un cas légitime.

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 pour l'utiliser:

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

Est-ce que quelqu'un connaît une solution de contournement, ou quelqu'un peut-il expliquer de manière satisfaisante pourquoi je ne devrais pas pouvoir jouer interfaceReferenceToBar implicitement à Foo<IBar>, car dans mon cas, il n'est pas converti, mais uniquement contenu dans Foo ?

MODIFIER: Il semble que la covariance pourrait offrir le salut. Espérons que la spécification C # 4.0 permette la conversion implicite des types d'interface à l'aide de la covariance.

Answer 1

La raison pour laquelle vous ne pouvez pas faire cela est que cela est spécifiquement interdit dans la spécification du langage C #:

  

Une classe ou une structure est autorisée à   déclarer une conversion à partir d'une source   Type S à un type de cible T fourni tous   des éléments suivants sont vrais:

     

  
• ...
  
• Ni S ni T ne sont object ou un type d'interface .
  

et

  

Les conversions définies par l'utilisateur ne sont pas   autorisé à convertir de ou vers    types d'interface . En particulier, cette   la restriction garantit qu'aucun   les transformations définies par l'utilisateur se produisent   lors de la conversion en type d'interface ,   et qu'une conversion en    interface-type ne réussit que si le   objet en cours de conversion   implémente le spécifié    type d'interface .

Source