Covariance Contravariance Generics Interfaces - pourquoi cela ne fonctionne-t-il pas?

Question

Merci d'avance. Voici mon code:

public class ApplicationUser : IdentityUser 
{ 
    public ApplicationUser() 
    { 

    } 
} 

public class AppUserManager : UserManager<ApplicationUser> 
{ 
... 
} 

public interface IOwinManager 
{ 
    UserManager<IdentityUser> UserManager { get; } 
} 

Pourquoi cela ne fonctionne-t-il pas?

public class OwinManager : IOwinManager 
{   
    public UserManager<IdentityUser> UserManager 
    { 
     get { return new AppUserManager(); } 
    } 
} 

Depuis ApplicationUser hérite de IdentityUser et AppUserManager de UserManager, pourquoi le non générique combinée acceptée? Merci!

Answer 1

La contravariance et la covariance sur les paramètres de type générique pour les classes ne sont pas prises en charge.

votre question Simplifier:

// Compiler error! 
UserManager<IdentityUser> userManager = new AppUserManager(); 

• AppUserManager hérite UserManager<ApplicationUser>. Par conséquent, vous essayez de définir une référence UserManager<ApplicationUser> -derived sur une référence UserManager<IdentityUser>. C'est le problème! Ils sont différents types.

OP a dit ...:

qui, signifie essentiellement, je ne peux pas utiliser des classes concrètes et leurs génériques dans une interface et attendre qu'ils soient mis en œuvre par leurs enfants?

Les interfaces prennent en charge la variance. Ainsi, vous pouvez concevoir votre interface comme suit:

public interface IOwinManager<out TUser, out TManager> 
    where TUser : IdentityUser 
    where TManager : UserManager<TUser> 
{ 
    TManager UserManager { get; } 
} 

... et une fois que vous avez mis cette interface, votre implémentation déclarera une propriété du type TManager béton.

Answer 2

La réponse de Matias est bonne; Je pensais que j'ajouterais un peu plus de contexte. Encore une fois simplifier votre exemple:

class Animal {} // IdentityUser 
class Tiger : Animal {} // ApplicationUser  
class Giraffe : Animal {} // some other kind of user 
class Cage<T> where T : Animal {} // UserManager 
class SpecialTigerCage : Cage<Tiger> {} // AppUserManager 

La question est maintenant "pourquoi cette conversion est-elle illégale?"

Cage<Animal> cage = new SpecialTigerCage(); 

Il devrait être évident maintenant pourquoi c'est illégal. Vous pouvez mettre une girafe dans une cage qui peut contenir des animaux, mais si vous mettez une girafe dans une cage de tigre spéciale, la girafe ne va pas être très heureux à ce sujet.

Le système de type ne peut pas prouver à sa satisfaction que vous n'allez pas mettre une girafe dans cette cage de tigre, donc il interdit la conversion. Comme d'autres l'ont fait remarquer, C# supporte ce type de conversion covariante sur les interfaces et les délégués, où peut prouver que vous n'allez pas mettre une girafe dans une cage de tigre. Par exemple, IEnumerable<T> est covariant. Une séquence de tigres peut être utilisée lorsqu'une séquence d'animaux est nécessaire parce que IEnumerable<T> ne possède pas de méthode qui puisse insérer une girafe dans la séquence.