Оператор перегружает полиморфизм, возвращающий общую коллекцию

Question

Я хочу перегрузить оператор + для добавления сегментов вместе, чтобы сформировать Путь. Я определил путь, где T - сегмент, и содержит список (где, естественно, T - сегмент). Сегмент является абстрактным базовым классом для различных типов сегментов, то есть LineSegment

У меня есть перегруженный метод Подключен, который проверяет, что сегменты имеют общую конечную точку. Я хотел бы определить перегрузку для 2 сегментов в абстрактном сегменте, а затем для разных типов, т. Е. Сегментов и LineSegment в соответствующих производных классах.

public static Path<T> operator +(Segment s1, Segment s2) 
{ 
    if (s1.Connected(s2)) 
    { 
     List<Segment> slist = new List<Segment>(); 
     slist.Add(s1); 
     slist.Add(s2); 
     Path<T> p = new Path<T>(slist); 
     return p; 
    } 
    else 
    { 
     return null; 
    } 
} 

@ Джон

Так по существу ...

Я пытаюсь заменить следующий код (path1 это путь, Сегменты является список, где T является сегмент).

Path<T> path1 = new Path<T>(s1); 
path1.Segments.Add(s2); 

с

Path<T> path1 = s1 + s2; 

Проблема в том, что с код не компилируется.

Answer 1

Поскольку C# не поддерживает общие операторы, я думаю, что нет простого способа сделать это. Но я могу представить несколько способов сделать это:

1. Не делайте этого. Как сказал Джон, вы всегда можете вернуть Path<Segment>, даже если вы добавите, скажем, два LineSegment. Мне не нравится это «решение», потому что это может означать, что вам придется использовать броски повсюду.

2. Добавить оператора в любой тип, который наследуется от Segment. Это означает повторение кода, но я думаю, что это лучший вариант здесь. Например, оператор LineSegment будет выглядеть следующим образом:

   public static Path<LineSegment> operator +(LineSegment s1, LineSegment s2) 
   

3. Не добавляйте два сегмента вместе, но вместо того, чтобы добавить их в пустой путь. Если вы сделаете это, то было бы, вероятно, лучше всего, если вы сделали Path непреложное:

   var path = Path<LineSegment>.Empty + lineSegment1 + lineSegment2; 
   

4. Используйте вариант curiously recurring template pattern:

   class SegmentBase<T> where T : SegmentBase<T> 
   { 
       public static Path<T> operator +(SegmentBase<T> s1, SegmentBase<T> s2) 
       { 
        return new Path<T>(new List<T> { (T)s1, (T)s2 }); 
       } 
   } 
   
   class LineSegment : SegmentBase<LineSegment> 
   { } 
   

   Если вы сделаете это, вы не имеете никакого повторения , но это похоже на хак, и это может усложнить иерархию наследования (вы не можете наследовать от класса, который указывает T). Мне не нравится это решение.