Warum benötigt IEnumerable keine Umwandlung, aber eine Liste?

Question

folgendes LinqPad Beispiel Gegeben:

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;} 
} 

Warum EnumerableMethod direkt die Liste nehmen kann, während ListMethod zuerst eine Besetzung braucht?

Ich bekomme, dass eine Besetzung von DbItem zu IDbItem passiert, aber was ist anders an der IEnumerable, die es ermöglicht, die Besetzung ohne eine ausdrückliche Anfrage zu machen?

Ich stelle mir vor, die Antwort beinhaltet das Wort Covariance, aber ich weiß nicht genug darüber, um es mir selbst herauszufinden.

Answer 1

Auschecken this post about covariance. Er gibt eine Erklärung und eine Möglichkeit, den Code ohne die Besetzung funktionieren zu lassen. Listen sind nicht covariant, aber man kann einfach die Methode ändern, wie so:

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

Kovarianz ist die Fähigkeit, eine abgeleitete generischen Typ zu einer Basis generischer Typ zuzuordnen. Der Grund List nicht kovariant ist, weil Sie dies tun könnte:

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

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

dogs ist wirklich eine Liste von Hunden, nicht von Tieren. Daher wäre das Hinzufügen eines Cat ein Problem, das speziell einen Compilerfehler verursacht.

Answer 2

Weil Sie keine Sammlung von xs in eine Sammlung von ys schreiben können, obwohl x von y abgeleitet ist und daher jedes x ein y ist. Siehe this SO question.

Aus diesem Grund wurden die Konzepte Kovarianz und Contravarianz der Sprache hinzugefügt.

Leider unterstützt List<T> diese Funktionen nicht.

Answer 3

ich die Antwort vorstellen, das Wort Kovarianzstrukturen

beinhaltet Ja, Sie richtig sind, der Typ-Parameter für IEnumerable<T> kovariant. so können Sie entweder den Typ verwenden Sie jede Art angegeben oder die mehr

abgeleitet

public interface IEnumerable<out T> : IEnumerable 

Wo als List<T> Typparameter nicht kovariant ist

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