继承与Liskov替换原理

Question

在创建我的班级结构时，我努力坚持利斯科夫替代原则。我想在Day类中存储一组日历项。需要有几种不同类型的日历项，例如：

任命项目
备注项目
轮换项目

它们都共享一些抽象基类CalendarItem中的常见功能：

public abstract class CalendarBaseItem
{
  public string Description { get; private set; }
  public List<string> Notes { get; private set; }
  public TimeSpan StartTime { get; private set; }
  public TimeSpan EndTime { get; private set; }
  public int ID { get; private set; }
  public DateTime date { get; private set; }

  code omitted...
}

但例如RotaItem有一些额外的功能：

public class RotaItem : CalendarBaseItem
{
    public string RotaName { get; private set; }
    private bool spansTwoDays;

    public bool spanTwoDays()
    {
        return this.spansTwoDays;
    }

}

其他类也添加了自己的逻辑等。

我有一组CalendarBaseItem用于我的日课：

List<CalendarBaseItem> calendarItems;

但在回顾这一点时，我可以看到我正在打破LSP原则，因为我必须检查并转换每个具体类型，以获得我希望每个子类的功能。

如果有人能建议如何避免这个问题，我将不胜感激。我是否应该使用合成方法，在每个最终类中添加CalendarItem类，例如

 public class RotaItem
{
    private CalendarBaseItem baseItem;
    public string RotaName { get; private set; }
    private bool spansTwoDays;

    public RotaItem(baseArgs,rotaArgs)
    {
       baseItem = new CalendarBaseItem(baseArgs);

    }

    public bool spanTwoDays()
    {
        return this.spansTwoDays;
    }

}

这里唯一的问题是，我将需要一个单独的收集，为每个具体的日历项目在我的日课？

Answer 1

我认为，您遇到的与其说是违反了Liskov替换原则，不如说是在大多数语言中遇到了多态性限制。

用类似于List的东西

有一些模式可以让你处理这种限制。最流行的是双调度模式：一种多调度的专门化，它将方法调用分派到运行时类型。这可以通过提供重写来实现，即当分派时，分派预期的方法。（即“双重分派”）。由于缺乏细节，很难准确地与你的情况联系起来。但是，如果你想做一些基于其他类型的处理，例如：

public abstract class CalendarBaseItem
{
    abstract void Process(SomeData somedata);
//...
}

public class RotaItem : CalendarBaseItem
{
    public override void Process(SomeData somedata)
    {
        // now we know we're dealing with a `RotaItem` instance,
        // and the specialized ProcessItem can be called
        someData.ProcessItem(this);
    }
//...
}

public class SomeData
{
    public void ProcessItem(RotaItem item)
    {
        //...
    }
    public void ProcessItem(NoteItem item)
    {
        //...
    }
}

这将取代像这样的东西：

var someData = new SomeData();
foreach(var item in calendarItems)
    someData.ProcessItem(item);

现在，这就是C语言中的“经典”处理方式——它涵盖了C语言的所有版本。对于C#4，引入了动态关键字以允许运行时类型评估。因此，只需将项目强制转换为dynamic，您就可以随心所欲地完成任务，而无需自己编写双重分派。它强制在运行时进行方法评估，因此将选择专门的覆盖：

var someData = new SomeData();
foreach(var item in calendarItems)
    someData.ProcessItem((dynamic)item);

这引入了您可能希望捕获和处理的潜在运行时异常——这就是为什么有些人不喜欢这样。相比之下，它目前也非常慢，因此不建议在性能敏感的紧密循环中使用它。