C# type dérivé à la liste générique en tant que paramètre

Question

Je suis en train de faire ce qui suit en C# 4.0:

J'ai une classe de base et 2 classes dérivées

 

public class Base {} 
public class DerivedClass1 : Base {} 
public class DerivedClass2 : Base {} 
 

Je veux faire quelque chose comme ça, mais ça ne marche pas. Comment indiquer à une liste générique d'accepter une classe de base et les classes dérivées de la classe de base?

 

public class Class_1 
{ 
    public Class_1() 
    { 
     List<DerivedClass2> list = new List<DerivedClass2>(); 
     new Class_2(list); 
    } 
} 

public class Class_2 
{ 
    public Class_2(List<Base> list) 
    { 

    } 
} 
 

En Java je peux faire quelque chose comme ça

 

public class Class_2 
{ 
    public Class_2(List<? extends Base> list) 
    { 

    } 
} 
 

Est-ce que quelque chose comme ça existe en C#

J'espère que ma question est claire, son juste sur les génériques de la liste.

Merci beaucoup à l'avance :)

Answer 1

Je pense que vous voulez dire soit:

// Define other methods and classes here 
public class Class_1 
{ 
    public Class_1() 
    { 
     List<DerivedClass2> list = new List<DerivedClass2>(); 
     new Class_2<DerivedClass2>(list); 
    } 
} 

public class Class_2<T> where T : Base 
{ 
    public Class_2(List<T> list) 
    { 

    } 
} 

Ou, si vous voulez que le constructeur soit générique, et non la classe:

// Define other methods and classes here 
public class Class_1 
{ 
    public Class_1() 
    { 
     List<DerivedClass2> list = new List<DerivedClass2>(); 
     Class_2.Create(list); 
    } 
} 

public class Class_2 
{ 
    public static Class_2 Create<T>(List<T> list) where T : Base 
    { 
     // Stuff 
     return new Class_2(/*Stuff*/); 
    } 

    public Class_2() 
    { 

    } 
} 

Answer 2

Cas général:

function Foo<T>(List<T> list) where T : Base { 
    ... 
} 

ainsi que pour les interfaces et les délégués, C# permet co/contravariance.

Par exemple. IEnumerable<T> et IList<T>, votre code fonctionnera donc! Notez que si cela était autorisé pour List<T> s, vous pouvez insérer un Derived1 dans une liste de Derived2 en utilisant la classe de base commune, ce qui romprait la sécurité de type. Il suffit donc de respecter les interfaces ci-dessus, en lecture seule.