opérateur implicite utilisant des interfaces
-
02-07-2019 - |
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.
La solution
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 .