C#程序设计6大原则
设计模式：
面向对象语言开发过程中，遇到各种场景和问题，解决方案和思路沉淀下来，就是设计模式。俗称，套路
设计模式的六大原则：
理解为面向对象语言开发过程中推荐的一些指导性的原则，通俗的说是套路的 套路
1.单一职责原则（Single Reponsibility Principle，简称：SRP）
一个类只负责一件事。一个方法也应该只做一件事。
好处：
- 阅读简单，易于维护
- 扩展升级，减少修改，直接增加类
- 代码重用
建议：简单-稳定-强大
成本：类变多了，上端需要了解更多的类。衡量着使用，如果类相对稳定，而且逻辑简单扩展少，违背单一原则也没关系。
一个类，不要让它太累了。如果不同的职责，总是一起变化的，这种一定要分开。
- 方法层面：方法多个分支，还可能扩展，最好拆分为多个方法
- 接口层面：也会把不同的功能接口，独立开来
- 类库层面：把项目拆分为多个类库，重用-方便维护
- 项目：很多人都是一个web来解决所有问题。
2.里氏替换原则（Liskov Substitution Principle，简称：LSP。）
任何使用基类的地方，都可以透明的使用其子类。
继承：通过继承，子类拥有父类的一切属性和行为，任何父类出现的地方，都可以用子类代替
- 子类必须完全实现父类有的方法，如果子类没有父类的某项东西，就断掉继承
- 子类可以有父类没有的东西，所以子类出现的地方，不一定能用父类来替代
- 透明，就是安全，父类的东西换成子类后不影响程序
1>建议：父类已经实现的东西，不要去隐藏（使用new）；
2>父类已经实现的东西，如果想修改，使用virtual+override，避免踩雷
变量，参数，属性，字段，最好都是基于基类的。
3.迪米特法则（Law of Demeter，简称：LOD ）：最少知道原则，一个对象应该对其他对象保持最少的了解。
面向对象的单位是类，类与类之间交互，组成功能模块，产生系统。
追求：高内聚，低耦合。通俗理解为高度封装，类与类之间减少依赖。
//我们去饭店点菜，想要知道今天有什么菜色可以点，一般是直接找服务员。
//服务员
public class Waiter
{
public Menu menu = new Menu();
}
//菜单
public class Menu
{
public string Content { get; set; }
}
//顾客
public class People
{
public void GetMenu()
{
Waiter waiter = new Waiter();
Menu menu = waiter.menu;
Console.WriteLine(menu.Content);
}
}
//根据迪米特法则，People类是不应该获得Menu类的相关内容，没必要知道太多，这里却产生了依赖关系。我们应该进行修改，在Waiter类中不对外开放Menu类，通过Waiter的方法来提供Menu的信息。
//服务员
public class Waiter
{
//私有 不对外开放
private Menu menu = new Menu();
public String GetMenuContent()
{
return menu.Content;
}
}
//顾客
public class People
{
public void GetMenu()
{
Waiter waiter = new Waiter();
Console.WriteLine(waiter.GetMenuContent());
}
}
//这样People就可以通过waiter的getMenuContent的方法来获取Menu信息，这样可以避免People和Menu产生依赖。
4.依赖倒置原则（Dependence Inversion Principle，简称：DIP）
- 定义：高层模块不应该依赖底层模块，二者应该通过抽象依赖。通俗讲，依赖抽象，而不是依赖细节，面向抽象编程。23种设计模式，80%跟这个有关
- 依赖细节：程序写死了，不方便扩展
- 依赖抽象：更具有通用性，而且具备扩展性。系统架构基于抽象来搭建的，会更稳定、更具备扩展性。
- 面向抽象编程：底层模块尽量都有抽象类/接口，声明参数/变量/属性的时候，尽量都是 接口/抽象类
//一个人看书
public class People
{
public void ReadStoryBook()
{
Console.WriteLine("read storyBook");
}
}public static void Main(string[] args)
{
People people = new People();
people.ReadStoryBook();
}
//把读书方法单独抽象出来，让它不依赖于People类。
public interface IBook
{
void Read();
}
public class StoryBook : IBook
{
public void Read()
{
Console.WriteLine("read storyBook");
}
}
public class MathBook : IBook
{
public void Read()
{
Console.WriteLine("read mathBook");
}
}
public class People
{
public void ReadBook(IBook book)
{
book.Read();
}
}
public static void Main(string[] args)
{
People people = new People();
people.ReadBook(new StoryBook());
people.ReadBook(new MathBook());
}
注意：如果项目不考虑扩展，确实不需要依赖倒置。
5.接口隔离原则（Interface Segregation Principe，简称：ISP）
定义：
- 客户端不应该依赖，它不需要的接口
- 通俗的理解，一个类对另外一个类的依赖应该建立在最小接口上
- 通俗的理解，实现一个接口的时候，只需要自己必须的功能
namespace TestClass
{
class Program
{
static void Main(string[] args)
{
var driver = new Driver(new LightTank());
driver.Run();
Console.ReadKey();
}
}
interface IVehicle
{
void Run();
}
/// <summary>
/// 汽车
/// </summary>
class Car : IVehicle
{
public void Run()
{
Console.WriteLine("Car is running");
}
}
/// <summary>
/// 卡车
/// </summary>
class Truck : IVehicle
{
public void Run()
{
Console.WriteLine("Truck is running");
}
}
/// <summary>
/// 坦克
/// c#中类或者接口可以继承多接口，但是不能继承多基类。
///
/// </summary>
interface IItank:IVehicle,IWeapon
{
}
class LightTank : IItank
{
public void Fire()
{
Console.WriteLine("LightTank is firing");
}
public void Run()
{
Console.WriteLine("LightTank is running");
}
}
class HeavyTank : IItank
{
public void Fire()
{
Console.WriteLine("HeavyTank is firing");
}
public void Run()
{
Console.WriteLine("HeavyTank is running");
}
}
/// <summary>
/// 驾驶员类
/// </summary>
class Driver
{
private IVehicle vehicle;
public Driver(IVehicle vehicle)
{
this.vehicle = vehicle;
}
public void Run()
{
vehicle.Run();
}
}
interface IWeapon
{
void Fire();
}
}
6.开闭原则（Open Closed Principle，简称：OCP）
- 对扩展开放，对修改封闭。通俗的讲，如果有功能扩展变化的需求，希望是增加类而不是修改
- 原则的原则，五大原则是手段，这个是目标。这个只是告诉你目标，实现靠其他原则。
- 因为修改会影响原有功能，引入错误。增加类就不会影响原有的东西
