Implémentation générique de l'interface

Question

Pourquoi cela ne fonctionne-t-il pas?

public interface IPoint 
{ 
    // not important 
} 

public interface IPointList 
{ 
    List<IPoint> Points { get; } 
} 

public abstract class Point : IPoint 
{ 
    // implemented IPoint 
} 

public abstract class PointList<TPointType> : IPointList 
    where TPointType: IPoint 
{ 
    public abstract List<TPointType> Points { get; } // <- doesn't compile 
} 

Le TPointType doit évidemment être un IPoint. Pourquoi cette implémentation n'est pas autorisée?

salutations, Kate

Answer 1

En réponse à votre commentaire, sur la façon d'obtenir le meilleur des deux mondes; Je pensais à quelque chose comme ceci, où vous implémentez votre propriété GetPoints d'interface de manière explicite, créez une propriété GetPoints qui est plus typée et une méthode abstraite protégée que vous pouvez remplacer dans les implémentations concrètes.
Les 2 propriétés appellent l'implémentation abstraite.

public abstract class PointList<T> : IPointList where T : IPoint 
    { 
     public IList<T> GetPoints 
     { 
      get 
      { 
       return GetPointsCore(); 
      } 
     } 

     IList<IPoint> IPointList.GetPoints 
     { 
      get 
      { 
       return GetPointsCore() as IList<IPoint>; 
      }   
     } 

     protected abstract IList<T> GetPointsCore();   
    } 

Answer 2

La classe PointList devrait implémenter l'interface IPointList. Les méthodes/propriétés ne peuvent pas différer selon le type de retour uniquement, ce que vous essayez de faire avec la déclaration Points dans la classe PointList. Si vous implémentez

List<TPointType> Points { get; } 

alors vous pouvez logiquement ne pas mettre en œuvre

List<IPoint> Points { get; } 

parce qu'ils diffèrent selon le type de retour seulement.