Warum funktioniert Explicit Cast für generische Liste nicht

Question

Ich versuche, eine Liste von Objekten in einem Consturctor für eine IntersectionPath der Ableitungsklasse wie folgt zu werfen.

public class IntersectionPath : Path<IntersectionSegment>, IEnumerable 
    {   

     //Constructors 
     public IntersectionPath() : base() { Verts = null; } 

     public IntersectionPath(List<Intersection> inVerts, List<Segment<Node>> inEdges) : base() 
     { 
      this.Segments = (List<IntersectionSegment>) inEdges; 
     } 

    } 

Segmente werden in dem generischen Basisklasse Pfad definiert

public class Path<T> : IEnumerable<T> where T : Segment<Node> 
    { 
     //public properties 
     public List<Direction> Directions {get; set; } 
     public List<T> Segments { get; set; } 
    } 

Ich habe einen expliziten Operator für die Besetzung in der IntersectionSegment Klasse definiert (siehe unten und ist so unklar, warum wird dies nicht .. kompiliert ich eine Fehlermeldung für das Gießen im IntersectionPath Konstruktor

public class IntersectionSegment : Segment<Intersection> 
{   
    //curves which intersect the primary curve at I0(Start Node) and I1(End Node) 
    public Curve C0 { get; set; } 
    public Curve C1 { get; set; } 

    public IntersectionSegment():base() {} 

    public IntersectionSegment(Intersection n0, Intersection n1):base(n0,n1){} 

    public static explicit operator IntersectionSegment(Segment<Node> s) 
    { 
     if ((s.Start is Intersection) && (s.End is Intersection)) 
     { 
      return new IntersectionSegment(s.Start as Intersection,s.End as Intersection); 
     } 
     else return null; 
    } 

    public static explicit operator List<IntersectionSegment>(List<Segment<Node>> ls) 
    { 
     List<IntersectionSegment> lsout = new List<IntersectionSegment>(); 
     foreach (Segment<Node> s in ls) 
     { 
      if ((s.Start is Intersection) && (s.End is Intersection)) 
      { 
       lsout.Add(new IntersectionSegment(s.Start as Intersection,s.End as Intersection)); 
      } 
      else return null; 
     } 
     return lsout; 
    } 

Segment wird definiert als:

public class Segment <T> : Shape where T : Node 
{ 
    //generic properties 
    public T Start { get; set; } 
    public T End { get; set; } 

} 

Answer 1

List<InteractionSegment> ist nicht dasselbe wie InteractionSegment. Wenn Sie eine Liste eines Typs in eine Liste eines anderen Typs umwandeln, wird nicht jedes Element umgewandelt.
Sie brauchen so etwas wie dies zu tun:

this.Segments = inEdges.Select(x => (InteractionSegment)x).ToList(); 

Dies verwendet LINQ to Objects jedes Objekt in inEdges zu einem InteractionSegment Objekt zu werfen und legt das Ergebnis wieder in eine Liste, die dann zu this.Segments zugeordnet ist.

Answer 2

Es funktioniert nicht einfach, weil ein List<Segment<Node>> kein List<IntersectionSegment> ist. Wenn Sie die später erstellen möchten, können Sie Ihre Cast() verwenden, um explizit jedes Element in der Liste nach Art zu werfen Sie wollen:

this.Segments = inEdges.Cast<IntersectionSegment>().ToList(); 

Answer 3

die an einem weit weniger verwirrend Beispiel aussehen lassen.

Ihre Frage ist ich glaube "Warum ist die Besetzung der letzten Zeile illegal?"

Nehmen wir an, es war legal. Jetzt fügen wir eine weitere Zeile hinzu:

animals.Add(new Tiger()); 

Sie können einen Tiger zu einer Liste von Tieren hinzufügen, richtig? Aber diese Liste von Tieren ist eigentlich eine Liste von Giraffen. Die Besetzung kopiert nicht die Liste, es sagt "Ich möchte dieses Objekt als von diesem Typ behandeln". Aber da du dadurch verrückte Dinge tun könntest, wie einen Tiger in eine Giraffenliste aufzunehmen, machen wir die Besetzung illegal.

Ihre Situation ist nur eine viel kompliziertere Version der gleichen Situation.

Diese Frage wird fast jeden Tag auf StackOverflow gestellt. Suchen Sie nach "Kovarianz und Kontravarianz" und Sie werden Dutzende von Beispielen finden.