nicht aus Liste konvertieren Kann <DerivedClass><BaseClass> zur Liste

Question

ich eine Liste von DerivedClass an eine Funktion zu übergeben bin versucht, die eine Liste von BaseClass nimmt, aber ich habe den Fehler:

cannot convert from 
'System.Collections.Generic.List<ConsoleApplication1.DerivedClass>' 
to 
'System.Collections.Generic.List<ConsoleApplication1.BaseClass>' 

Jetzt konnte ich gegossen mein List<DerivedClass> zu einem List<BaseClass>, aber ich fühle mich nicht wohl, wenn ich nicht verstehe, warum der Compiler dies nicht erlaubt.

Erklärungen, die ich gefunden habe, haben einfach gesagt, dass es Typsicherheit irgendwie verletzt, aber ich sehe es nicht. Kann mir jemand helfen?

Wie groß ist das Risiko, dass der Compiler die Konvertierung von List<DerivedClass> zu List<BaseClass> zulässt?

---

Hier ist meine SSCCE:

class Program 
{ 
    public static void Main() 
    { 
     BaseClass bc = new DerivedClass(); // works fine 
     List<BaseClass> bcl = new List<DerivedClass>(); // this line has an error 

     doSomething(new List<DerivedClass>()); // this line has an error 
    } 

    public void doSomething(List<BaseClass> bc) 
    { 
     // do something with bc 
    } 
} 

class BaseClass 
{ 
} 

class DerivedClass : BaseClass 
{ 
} 

Answer 1

funktionieren Es ist, weil List<T>in-variant ist, nicht co-variant, so dass Sie IEnumerable<T> ändern sollte, die co-variant unterstützt, sollte es funktionieren:

IEnumerable<BaseClass> bcl = new List<DerivedClass>(); 
public void doSomething(IEnumerable<BaseClass> bc) 
{ 
    // do something with bc 
} 

Informationen über co-variant in generic

Answer 2

Das Verhalten Sie beschreiben genannt wird Kovarianz – wenn A ist B, dann List<A>istList<B>.

Für veränderbare Typen wie List<T> ist das jedoch grundsätzlich unsicher.

Wäre dies möglich gewesen, wäre die Methode in der Lage, eine new OtherDerivedClass() zu einer Liste hinzuzufügen, die eigentlich nur DerivedClass halten kann.

Covariance ist sicher auf unveränderlichen Typen, obwohl .NET nur in Schnittstellen und Delegaten unterstützt.
Wenn Sie den List<T> Parameter IEnumerable<T> ändern, dass

Answer 3

Wenn könnten Sie schreiben

List<BaseClass> bcl = new List<DerivedClass>(); 

könnten Sie

var instance = new AnotherClassInheritingFromBaseClass(); 
bc1.Add(instance); 

rufen Sie eine Instanz hinzufügen, die auf der Liste kein DerivedClass ist.

Answer 4

Wenn Sie eine Klasse haben, die von einer Basisklasse abgeleitet ist, werden alle Container dieser Klassen nicht automatisch abgeleitet. Sie können also nicht einfach eine List<Derived> an eine List<Base> übertragen.

Verwenden .Cast<T>() eine neue Liste zu erstellen, in dem jedes Objekt wird auf die Basisklasse zurückgeworfen:

List<MyDerived> list1 = new List<MyDerived>(); 
List<MyBase> list2 = list1.Cast<MyBase>().ToList(); 

Beachten Sie, dass dies eine neue Liste, nicht eine gegossene Version Ihrer ursprünglichen Liste, so dass Operationen auf diesem Die neue Liste spiegelt nicht die ursprüngliche Liste wider. Operationen an den enthaltenen Objekten spiegeln sich jedoch wider.

Answer 5

Explanations that I have found have simply said that it violates type safety somehow, but I'm not seeing it. What is the risk of the compiler allowing conversion from List<DerivedClass> to List<BaseClass> ?

Diese Frage wird fast jeden Tag gestellt.

A List<Mammal> kann nicht auf eine List<Animal> konvertiert werden, da Sie eine Eidechse in eine Liste von Tieren setzen können. A List<Mammal> kann nicht zu einem List<Giraffe> konvertiert werden, da dort ein Tiger in der Liste sein kann bereits.

Daher hat List<T>invariant in T.

jedoch sein kann List<Mammal> zu IEnumerable<Animal> umgewandelt werden (wie von C# 4.0), da es keine Methode auf IEnumerable<Animal> ist, die eine lizard hinzufügt. IEnumerable<T> ist covariant in T.

Answer 6

Eine Lösung war ich verwendet, um eine Erweiterungsklasse zu erstellen:

public static class myExtensionClass 
{ 
    public void doSomething<T>(List<BaseClass> bc) where T: BaseClass 
    { 
     // do something with bc 
    } 
} 

Es verwendet generisch, aber wenn man es so nennen Sie müssen, da Sie die Klasse nicht angeben hat dem Compiler bereits "gesagt", dass der Typ der erweiterten Klasse gleich ist.

Sie es nennen würde auf diese Weise:

List<DerivedClass> lst = new List<DerivedClass>(); 
lst.doSomething();