在构造函数中是否可能违反Liskov替换原则？

Question

我刚刚安装了Microsoft代码合同。这是的一部分。NET框架和Visual Studio加载项。它提供运行时检查和定义的合同的静态检查。

该工具有四个警告级别，因此我设置了最高级别。

我已经声明了违反Liskov替换原则的类。

public class Person
{
    protected int Age { get; set; }

    public Person(int age)
    {
        Contract.Requires(age > 0);
        Contract.Requires(age < 130);
        this.Age = age;
    }
}

public class Child : Person
{
    public Child(int age) : base(age)
    {
        Contract.Requires(age > 0); 
        Contract.Requires(age < Consts.AgeOfMajority);
        Contract.Requires(age < 130);
        this.Age = age;
    }
}

public static class Consts
{
    public readonly static int AgeOfMajority = 18;
}

LSP规定：

如果S是T的子类型，则T类型的对象可以替换为S类型的对象，而不改变该程序的任何期望属性

在我的例子中，违规行为是这样的：人=新孩子（23）；。我们应该能够做到这一点，但是我们不能，因为孩子们不能比个人班级要求的年龄小。

然而，分析的结果是令人惊讶的代码契约：检查了11个断言： 11个正确的。我的例子是错误的还是代码合同没有检测到这样的事情？

Answer 1

我认为liskov替换控制类的构造实例的行为。因此，一个适当构造的儿童实例可以代替一个没有问题的人。

您对如何构造一个孩子有限制。我不认为框架没有将此标记为问题。

Answer 2

有一个著名的鸭子违反LSP的例子：

然而，我们不能在构造函数中违反它。假设我们有鸭子和野鸭课程：

public abstract class Duck
{
    public abstract string Quack();
    public double Weight { get; set; }

    public Duck(double weight)
    {
        Contract.Requires(weight > 0);
        this.Weight = weight;
    }
}

public class WildDuck : Duck
{
    public WildDuck(double weight)
        : base(weight)
    {
        Contract.Requires(weight > 0);
        this.Weight = weight;
    }

    public override string Quack()
    {
        return "wild quack";
    }
}

现在让我们来介绍一下：

public class ElectricDuck : Duck
{
    public Battery Battery { get; set; }

    public override string Quack()
    {
        return "electric quack";
    }

    public ElectricDuck(double weight, Battery battery)
        : base(weight)
    {
        Contract.Requires(weight > 0);
        Contract.Requires(battery != null);
        this.Weight = weight;
        this.Battery = battery;
    }
}

public class Battery
{
    public bool IsEmpty { get; set; }
}

乍一看，它似乎违反了LSP，因为电子鸭需要比野鸭或抽象鸭更多的东西。但这不是真的，只要电鸭提供嘎嘎方法没有额外的要求。

如果电鸭需要电池发光——从LSP的角度来看，这是完全正确的：

public void Glow()
{
    Contract.Requires(!this.Battery.IsEmpty);
}

当我们向继承的方法添加需求时，违反了LSP：

public override string Quack()
{
    Contract.Requires(!this.Battery.IsEmpty);
    return "electric quack";
}

此修改将导致CodeContracts显示警告。

Answer 3

虽然LSP确实指定了子类型，但不能对方法设置更严格的前提条件，但这不适用于构造函数，因为您没有以多态方式使用构造函数。

违反合同的将是新生儿（23） 在分配给人员之前发生。

因此，示例冲突是错误的，它没有创建子类型的实例，更不用说将其替换为t了。