nie można przekonwertować z listy <Bar> do listy <Foo>

Question

mam skonfigurować tak:

abstract class Foo {} 
class Bar : Foo {} 

i sposób gdzie indziej tej postaci:

void AddEntries(List<Foo>) {} 

próbuję wywołać tę metodę za pomocą lista obiektów typu Bar

List<Bar> barList = new List<Bar>() 
AddEntries(barList); 

ale to daje mi błąd:

cannot convert from List<Bar> to List<Foo>

Czy w ogóle istnieje ten problem? Muszę zachować definicję metody za pomocą klasy abstrakcyjnej.

Answer 1

Można zrobić swój AddEntries rodzajowy i zmienić go na tym

void AddEntries<T>(List<T> test) where T : Foo 
{ 
    //your logic 
} 

Wystarczy popatrzeć na Constraints on Type Parameters celu uzyskania dalszych informacji.

Answer 2

Mają lektury Covariance and Contravariance in Generics from docs.microsoft.com jak ten, szczególnie sekcji „generyczne Interfejsy z kowariantna parametrów typu” pokryje się scenariusz, że pracujesz.

W skrócie, jeśli (może) zmienić podpis metodę AddEntries do:

static void AddEntries(IEnumerable<Foo> entries) 

(Uwaga wykorzystania IEnumerable<Foo> zamiast List<Foo>) będziesz w stanie zrobić to, czego szukasz do zrobienia.

Specyficzny Różnica polega na tym, że IEnumerable<T> i List<T> deklarowane są różnie:

public interface IEnumerable<out T> : IEnumerable 
public class List<T> : IList<T>, ... ... 

Różnica że liczy jest out w deklaracji IEnumerable<T> który wskazuje, że jest kowariantna co oznacza (z definicją zaczerpniętą z docs.microsoft.com):

Covariance: Enables you to use a more derived type than originally specified.

Answer 3

To nie jest dozwolone z prostego powodu. Załóżmy, że poniżej kompiluje:

AddEntries(new List<Bar>()); 

void AddEntries(List<Foo> list) 
{ 
    // list is a `List<Bar>` at run-time 
    list.Add(new SomethingElseDerivingFromFoo()); // what ?! 
} 

Jeśli kod będzie kompilować, masz niebezpieczny dodatek (co sprawia, że ​​cały list generyczne bezcelowe), gdzie dodany SomethingElseDerivingFromFoo do rzeczywistości List<Bar> (typ wykonawczego).

Aby rozwiązać problem, można użyć rodzajowych:

void AddEntries<T>(List<T> list) where T:Foo 
{ 

}