Comment gérer ce problème de génériques C#?

Question

J'ai une classe de base qui hérite de la liste <> dont plusieurs classes sont dérivées.

Je souhaite créer une méthode permettant d'ajouter des éléments à une classe héritée de cette classe de base, est-ce possible?

code pseudo:

public class BaseList<T> : List<T> where T: baseItem 
{ 
} 

public BaseList<T> AddItems<T>(int someArg) where T: new(), baseItem 
{ 

BaseList<T> temp = new BaseList<T>(); 
temp.add(new T()); 
temp.add(new T()); 
return temp; 
} 

public class MyDerived: BaseList<SomeClass> 
{ 
} 

Alors pour appeler ce code:

MyDerived temp = (MyDerived)AddItems(); 

est quelque chose comme cela possible? Je ne peux pas comprendre la syntaxe correcte

Answer 1

Avez-vous vraiment besoin de dériver de List<T> au lieu d'utiliser la composition?

On dirait que vous voulez une méthode statique dans un type non générique:

public static TList CreateList<TList,TItem>(int someArg) 
    where TList : BaseList<TItem>, new() 
    where TItem : baseItem, new() 
{ 
    TList temp = new TList(); 
    temp.Add(new TItem()); 
    temp.Add(new TItem()); 
    return temp; 
} 

Il ne semble pas particulièrement agréable mais ... peut-être si vous nous avez expliqué le but de cela, nous pourrions arriver à avec une meilleure idée.

Answer 2

Vous pouvez également utiliser

public static void AddItems<T>(List<T> list, int someArg) where T: new() { 
    list.Add(new T()); 
    list.Add(new T()); 
} 

Et l'appeler comme ceci:

List list = new List<SomeClass>(); 
AddItems(list, someArg); 

Answer 3

Je ne peux pas vraiment comprendre votre question, mais je l'ai rencontré ce problème avant. Si vous avez rencontré le même problème que moi: vous ne connaissez pas le paramètre <T> au moment de la compilation. Heureusement, il s'agit d'un cynch à résoudre en utilisant des interfaces - vous pouvez créer une liaison de type plus forte en utilisant une interface non générique.

class Program 
{ 
    static void Main(string[] args) 
    { 
     IAddBaseItem addItem = new DerivedList(); 
     BaseItem item = new DerivedItem(); 
     IgnorantMethod(addItem, item); 
    } 

    static void IgnorantMethod(IAddBaseItem list, BaseItem item) 
    { 
     list.Add(item); 
    } 
} 

class BaseItem 
{ 
} 

class BaseList<T> : List<T>, IAddBaseItem 
{ 
    #region IAddBaseItem Members 

    void IAddBaseItem.Add(BaseItem item) 
    { 
     if (item == null) 
      Add(item); 
     else 
     { 
      T typedItem = item as T; 
      // If the 'as' operation fails the item isn't 
      // of type T. 
      if (typedItem == null) 
       throw new ArgumentOutOfRangeException("T", "Wrong type"); 
      Add(typedItem); 
     } 
    } 

    #endregion 
} 

class DerivedList : BaseList<DerivedItem> 
{ 
} 

class DerivedItem : BaseItem 
{ 
} 

interface IAddBaseItem 
{ 
    void Add(BaseItem item); 
} 

Comme je l'ai dit, c'est ma meilleure estimation quant à ce que vous demandez.