Warum kann ich nicht zuordnen eine Liste<Abgeleitet> Liste<Base>?

Definierte ich die folgende Klasse:

public abstract class AbstractPackageCall
    {

     ...

    }

Ich auch durch die Definition einer Unterklasse dieser Klasse:

class PackageCall : AbstractPackageCall
    {

      ...
    }

Es gibt auch mehrere andere subclases von AbstractPackageCall

Nun möchte ich den folgenden Aufruf:

 List<AbstractPackageCall> calls = package.getCalls();

Aber ich bekomme immer diese exception:

Error   13  Cannot implicitly convert type 'System.Collections.Generic.List<Prototype_Concept_2.model.PackageCall>' to 'System.Collections.Generic.List<Prototype_Concept_2.model.AbstractPackageCall>'

Was ist hier das problem? Dies ist die Methode Package#getCalls

 internal List<PackageCall> getCalls()
        {
            return calls;
        }

Es heißt Kovarianz/Kontravarianz mit Generika. Check out dies, SO Frage.
Wenn Sie zurückkehren können, eine IEnumerable<AbstractPackageCall> statt List<AbstractPackageCall> dann funktioniert das wie IEnumerable<> unterstützt Kovarianz.
Sie können auch daran interessiert sein, Lesen Sie diese zwei Seiten. Lesen Sie diese aus co-/contra - Varianz auf, die für mich C# 4.0 die FUNKTION im FOKUS – TEIL 4 – CO - UND CONTRA-VARIANZ FÜR GENERISCHE DELEGAT-UND INTERFACE-TYPEN und natürlich Eric Lippert hat eine Menge Beiträge zu dem Thema.
Danke für die vielen Antworten, endlich habe ich glaube ich verstehe das Konzept der Kovarianz.

InformationsquelleAutor | 2011-01-10

.net c#covariance generics

54

Der einfachste Weg, um zu verstehen, warum dies nicht erlaubt ist, ist das folgende Beispiel:
```
abstract class Fruit
{
}

class Apple : Fruit
{
}

class Banana : Fruit
{
}

//This should intuitively compile right? Cause an Apple is Fruit.
List<Fruit> fruits = new List<Apple>();

//But what if I do this? Adding a Banana to a list of Apples
fruits.Add(new Banana());
```
Die Letzte Aussage würde ruinieren die Typ-Sicherheit .NET.

Arrays jedoch erlauben diese:
```
Fruit[] fruits = new Apple[10]; //This is perfectly fine
```
Jedoch, indem Sie ein Banana in fruits würde noch Pause geben Sicherheit, so dafür .NET zu tun hat, eine Art check auf jedem array einfügen und werfen eine Ausnahme, wenn es nicht tatsächlich ein Apple. Dies ist möglicherweise eine (kleine) performance-hit werden, aber dies kann umgangen werden, indem erstellen ein struct wrapper geben, wie diese überprüfung geschieht nicht für Wert-Typen (weil Sie keine Erben von etwas). Auf den ersten, ich habe nicht verstanden, warum diese Entscheidung getroffen wurde, aber Sie stoßen sehr oft, warum diese nützlich sein kann. Am häufigsten ist String.Format nimmt, die params object[] und Arrays, die übergeben werden können, in diesem.

In .NET 4 gibt es aber typsichere Kovarianz und Kontravarianz, die Ihnen erlaubt, um einige Aufgaben wie diese, aber nur, wenn Sie nachweislich sicher sind. Was ist nachweislich sicher?
```
IEnumerable<Fruit> fruits = new List<Apple>();
```
Den oben genannten Werken .NET 4, da IEnumerable<T> wurde IEnumerable<out T>. Die out bedeutet, dass T kann immer nur kommen aus von fruits ist und dass es keine Methode in allen auf IEnumerable<out T> dass immer T als parameter, so können Sie nie falsch pass eine Banana in IEnumerable<Fruit>.

Kontravarianz ist viel das gleiche, aber ich vergesse immer die genauen details auf. Es überrascht nicht, dafür gibt es jetzt die in Schlüsselwort für Typ-Parameter.

Wieso der downvote? Wenn eine Antwort nicht dumm, streitsüchtig oder beleidigend sind, lassen Sie immer einen Kommentar, so könnte ich vielleicht beheben/korrigieren Sie die Dinge.
Das ist eine Super Antwort, mit der rechten gibt. Fair play, um Ihnen für die Zeit nehmen

InformationsquelleAutor JulianR

Nun, wenn Sie wollen, um den folgenden Aufruf:

List<PackageCall> calls = package.getCalls();

//select only AbstractPackageCall items
List<AbstractPackageCall> calls = calls.Select();
calls.Add(new AnotherPackageCall());

Nenne ich Verallgemeinerung.

Können Sie auch diese spezifischer:

List<PackageCall> calls = package.getCalls();

//select only AnotherPackageCall items
List<AnotherPackageCall> calls = calls.Select(); 
calls.Add(new AnotherPackageCall());

Implementieren diese mit extension-Methode:

public static class AbstractPackageCallHelper
{
    public static List<U> Select(this List<T> source)
        where T : AbstractPackageCall
        where U : T
    {
        List<U> target = new List<U>();
        foreach(var element in source)
        {
            if (element is U)
            {
                 target.Add((U)element);
            }
        }
        return target;
    }
}

Ihre Erweiterung Methode erfordert zwei Parameter des Typs - und diese müssen einbezogen werden in Aufrufe der Methode.

InformationsquelleAutor Artur Mustafin

2

, Warum das, was Sie versucht hat nicht funktioniert

Du fragst den compiler zur Behandlung einer List<PackageCall> als List<AbstractPackageCall>, was er nicht ist. Es ist eine andere Sache, dass jedes PackageCall Instanzen ist in der Tat ein AbstractPackageCall.

Was arbeiten würden anstatt
```
var calls = package.getCalls().Cast<AbstractPackageCall>().ToList();
```
, Warum das, was Sie versuchen, wird nie erlaubt werden, zu arbeiten

Obwohl jedes Element innerhalb der Rückgabewert von package.getCalls() stammt aus AbstractPackageCall wir nicht behandeln können die ganze Liste als List<AbstractPackageCall>. Hier ist, was passieren würde, wenn wir könnten:
```
var calls = package.getCalls(); //calls is List<PackageCall>
List<AbstractPackageCalls> apcs = calls; //ILLEGAL, but assume we could do it

apcs.Add(SomeOtherConcretePackageCall()); //BOOM!
```
Wenn wir das tun könnten, dann könnten wir hinzufügen, eine SomeOtherConcretePackageCall zu einem List<PackageCall>.

InformationsquelleAutor Jon
1

Weil List<PackageCall> erbt nicht von List<AbstractPackageCall>. Sie können die Cast<>() Erweiterung Methode, wie:
```
var calls = package.getCalls().Cast<AbstractPackageCall>();
```
Fehler 3 kann Nicht implizit konvertiert Typ 'System.Sammlungen.Generisches.IEnumerable<Prototype_Concept_2.Modell.AbstractPackageCall>' zu 'System.Sammlungen.Generisches.Liste<Prototype_Concept_2.Modell.AbstractPackageCall>'. Eine explizite Konvertierung vorhanden ist (fehlt ein cast?}
Dies ist die Fehlermeldung die ich bekomme, wenn ich versuche diese
Ja, nur Feste auf meine Antwort.

InformationsquelleAutor Brian Ball
0

Können Sie diese Konvertierung durchführen, da ein List<AbstractPackageCall> kann alles enthalten, ergibt sich aus AbstractPackageCall, während ein List<PackageCall> nicht-es können nur Dinge enthalten, die sich aus PackageCall.

Berücksichtigen, wenn dieser Besetzung durften:
```
class AnotherPackageCall : AbstractPackageCall { }

//...

List<AbstractPackageCall> calls = package.getCalls();
calls.Add(new AnotherPackageCall());
```
Den Sie gerade Hinzugefügt eine AnotherPackageCall in eine List<PackageCall> - aber AnotherPackageCall nicht ableiten aus PackageCall! Das ist, warum diese Konvertierung ist nicht erlaubt.

Diese Art der Konvertierung ist zulässig für arrays, das ist wahrscheinlich, warum fragte er dies.

InformationsquelleAutor cdhowie

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

, Warum das, was Sie versucht hat nicht funktioniert

Was arbeiten würden anstatt

, Warum das, was Sie versuchen, wird nie erlaubt werden, zu arbeiten