Dlaczego IEnumerable nie potrzebuje rzutu, ale robi to lista?

Question

Biorąc pod uwagę następujący przykład LINQPad:

void Main() 
{ 
    List<DbItem> dbItems = new List<DbItem> 
    { 
     new DbItem{Id = 4, SomeValue = "Value For 4", OtherValue = 1}, 
     new DbItem{Id = 19, SomeValue = "Value For 19", OtherValue = 2} 
    }; 

    ListMethod(dbItems.Cast<IDbItem>().ToList()); <-+ 
    EnumerableMethod(dbItems);      <-+ 
}              | 
                 | 
// These are the methods are I asking about -------+ 

public void ListMethod(List<IDbItem> dbItems) 
{ 
    Console.WriteLine(dbItems); 
} 
public void EnumerableMethod(IEnumerable<IDbItem> dbItems) 
{ 
    Console.WriteLine(dbItems); 
} 
public class DbItem : IDbItem 
{ 
    public int Id {get; set;} 
    public string SomeValue {get; set;} 
    public int OtherValue {get; set;} 
} 
public interface IDbItem 
{ 
    int Id {get; set;} 
    string SomeValue {get; set;} 
} 

Dlaczego EnumerableMethod podjęcia listę bezpośrednio podczas ListMethod musi najpierw obsady?

Dostaję, że obsada dzieje się od DbItem do IDbItem, ale co różni się od IEnumerable, która pozwala mu obsadzić bez wyraźnego żądania?

Wyobrażam sobie, że odpowiedź zawiera słowo Kowariancja, ale nie wiem wystarczająco dużo o tym, aby samemu to zrozumieć.

Answer 1

Zapoznaj się z this post about covariance. Daje wyjaśnienie i sposób, aby kod zadziałał bez obsady. Listy nie są kowariantna, ale można po prostu zmienić metodę tak:

public void ListMethod<T>(List<T> dbItems) where T : IDbItem 
{ 
    Console.WriteLine(dbItems); 
} 

kowariancji jest możliwość przypisania bardziej ogólny typ pochodzący z podstawą typu rodzajowego. Powodem List nie kowariantna dlatego można to zrobić:

class Animal {} 
class Dog : Animal {} 
class Cat : Animal {} 

void someFunction() 
{ 
    List<Animal> dogs = new List<Dog>(); 
    dogs.Add(new Cat()); 
} 

dogs jest naprawdę lista psów, a nie zwierząt. Dlatego dodanie do niego numeru Cat stanowiłoby problem, szczególnie powodując błąd kompilatora.

Answer 2

Ponieważ nie można rzucić kolekcji x do kolekcji y, nawet jeśli x pochodzi od y, a zatem każde x jest y. Zobacz this SO question.

Dlatego do języka dodano pojęcia kowariancji i kontrawariancji.

Niestety List<T> nie obsługuje tych funkcji.

Answer 3

sobie wyobrazić odpowiedź wiąże się słowo kowariancji

Tak masz rację, parametr typu dla IEnumerable<T> jest kowariantna. więc można użyć typu ty określony lub dowolny typ, który jest bardziej pochodzący

public interface IEnumerable<out T> : IEnumerable 

Gdzie jak List<T> parametr typu nie jest kowariantna

public class List<T> : IList<T>, ICollection<T>, 
    IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, 
    IEnumerable