你能用一个很好的C#例子解释Liskov替换原则(SOLID的'L'),以简化的方式涵盖原理的所有方面吗?如果真的有可能。
答案 0 :(得分:125)
(此答案已于2013-05-13重写,请阅读评论底部的讨论内容)
LSP是关于基类的合同。
例如,您可以不在子类中抛出新的异常,因为使用基类的异常不会发生这种情况。如果基类抛出ArgumentNullException
,如果参数丢失且子类允许参数为null,也是LSP违规,则同样如此。
以下是违反LSP的类结构示例:
public interface IDuck
{
void Swim();
// contract says that IsSwimming should be true if Swim has been called.
bool IsSwimming { get; }
}
public class OrganicDuck : IDuck
{
public void Swim()
{
//do something to swim
}
bool IsSwimming { get { /* return if the duck is swimming */ } }
}
public class ElectricDuck : IDuck
{
bool _isSwimming;
public void Swim()
{
if (!IsTurnedOn)
return;
_isSwimming = true;
//swim logic
}
bool IsSwimming { get { return _isSwimming; } }
}
和调用代码
void MakeDuckSwim(IDuck duck)
{
duck.Swim();
}
如您所见,有两个鸭子的例子。一只有机鸭和一只电鸭。电鸭只有在打开时才会游泳。这打破了LSP原则,因为它必须打开才能游泳,因为IsSwimming
(也是合同的一部分)不会像在基类中那样设置。
你可以通过做这样的事情来解决它
void MakeDuckSwim(IDuck duck)
{
if (duck is ElectricDuck)
((ElectricDuck)duck).TurnOn();
duck.Swim();
}
但这会打破开放/封闭原则,必须在任何地方实施(因此仍会生成不稳定的代码)。
正确的解决方案是在Swim
方法中自动打开鸭子并通过这样做使电子鸭的行为完全按照IDuck
界面的定义
<强>更新强>
有人添加了评论并将其删除。它有一个有用的观点,我想谈谈:
在使用Swim
方法时打开鸭子的解决方案在使用实际实现时可能会产生副作用(ElectricDuck
)。但这可以通过使用explicit interface implementation来解决。 imho你更有可能因为Swim
中没有打开它而遇到问题,因为预计它会在使用IDuck
界面时游泳
更新2
改写一些部分以使其更清晰。
答案 1 :(得分:8)
LSP一种实用方法
我到处寻找LSP的C#示例,人们使用了虚构的类和接口。以下是我在其中一个系统中实现的LSP的实际实现。
场景:假设我们有3个数据库(抵押客户,经常账户客户和储蓄账户客户)提供客户数据,我们需要客户详细信息给出客户的姓氏。现在,根据给定的姓氏,我们可以从这3个数据库中获得超过1个客户详细信息。
实现:
商业模式层:
public class Customer
{
// customer detail properties...
}
数据访问层:
public interface IDataAccess
{
Customer GetDetails(string lastName);
}
上面的接口由抽象类
实现public abstract class BaseDataAccess : IDataAccess
{
/// <summary> Enterprise library data block Database object. </summary>
public Database Database;
public Customer GetDetails(string lastName)
{
// use the database object to call the stored procedure to retrieve the customer details
}
}
这个抽象类有一个共同的方法&#34; GetDetails&#34;对于由每个数据库类扩展的所有3个数据库,如下所示
按揭客户数据访问:
public class MortgageCustomerDataAccess : BaseDataAccess
{
public MortgageCustomerDataAccess(IDatabaseFactory factory)
{
this.Database = factory.GetMortgageCustomerDatabase();
}
}
当前帐户客户数据访问:
public class CurrentAccountCustomerDataAccess : BaseDataAccess
{
public CurrentAccountCustomerDataAccess(IDatabaseFactory factory)
{
this.Database = factory.GetCurrentAccountCustomerDatabase();
}
}
节省账户客户数据访问:
public class SavingsAccountCustomerDataAccess : BaseDataAccess
{
public SavingsAccountCustomerDataAccess(IDatabaseFactory factory)
{
this.Database = factory.GetSavingsAccountCustomerDatabase();
}
}
一旦设置了这3个数据访问类,现在我们将注意力吸引到客户端。在Business层中,我们有CustomerServiceManager类,它将客户详细信息返回给客户端。
业务层:
public class CustomerServiceManager : ICustomerServiceManager, BaseServiceManager
{
public IEnumerable<Customer> GetCustomerDetails(string lastName)
{
IEnumerable<IDataAccess> dataAccess = new List<IDataAccess>()
{
new MortgageCustomerDataAccess(new DatabaseFactory()),
new CurrentAccountCustomerDataAccess(new DatabaseFactory()),
new SavingsAccountCustomerDataAccess(new DatabaseFactory())
};
IList<Customer> customers = new List<Customer>();
foreach (IDataAccess nextDataAccess in dataAccess)
{
Customer customerDetail = nextDataAccess.GetDetails(lastName);
customers.Add(customerDetail);
}
return customers;
}
}
我还没有展示依赖注入来保持简单,因为它现在已经变得复杂了。
现在,如果我们有一个新的客户详细信息数据库,我们可以添加一个扩展BaseDataAccess并提供其数据库对象的新类。
当然,我们在所有参与的数据库中都需要相同的存储过程。
最后,CustomerServiceManager
类的客户端只调用GetCustomerDetails方法,传递lastName,不应该关心数据的来源和位置。
希望这能为您提供一种理解LSP的实用方法。
答案 2 :(得分:-1)
以下是应用Liskov替代原则的代码。
public abstract class Fruit
{
public abstract string GetColor();
}
public class Orange : Fruit
{
public override string GetColor()
{
return "Orange Color";
}
}
public class Apple : Fruit
{
public override string GetColor()
{
return "Red color";
}
}
class Program
{
static void Main(string[] args)
{
Fruit fruit = new Orange();
Console.WriteLine(fruit.GetColor());
fruit = new Apple();
Console.WriteLine(fruit.GetColor());
}
}
LSV声明:
“派生类应该可以替代它们的基类(或接口)”
&安培;
“使用对基类(或接口)的引用的方法必须能够使用派生类的方法,而无需了解它或了解详细信息。”