面向对象设计原则

单一职责原则(SRP, Single Responsibility Principle)

定义

一个类，最好只做一件事，只有一个引起它变化的原因。

应用

数据库管理系统为例，通常情况下根据不同的权限进行数据增删改查。
比较坏的设计将判断用户权限和对数据的增删改查放在一个类,在遇到权限或对数据操作修改时都需要修改该类

    public void Add()
        {
            if (GetPermission("userId")=="CanAdd")
            {
                Console.WriteLine("我有权限添加数据");
            }
        }

考虑单一责任原则，将权限判断和对数据操作分到不同的类,通过权限代理实现单一职责

    public interface IDBAction
    {
        void Add();
    }
    public class DBManager: IDBAction
    {
        public void Add()
        {
            //执行数据增加
        }
    }

    public class DBManagerProxy : IDBAction
    {
        private IDBAction dbManager;
        public DBManagerProxy(IDBAction dbAction)
        {
            dbManager = dbAction;
        }

        public string GetPermission(string userId)
        {
            string userRole = string.Empty;
            return userRole;
        }

        public void Add()
        {
            if (GetPermission("userId") == "CanAdd")
            {
                dbManager.Add();
            }
        }
    }

开放封闭原则(OCP, Open Closed Principle)

定义

软件实体应该是可扩展，而不可修改的。也就是说，对扩展是开发的，而对修改是封闭的。

应用

这里实现个计算器，由客户端和计算端组成。设计应该尽量保证计算端的核心业务不修改。坏的代码无法对功能扩展

    public class Client
    {
        private CalculatorProcess _calculator = new CalculatorProcess();

        public int NumFirst { get; set; }
        public int NumSecond { get; set; }
        public int Use(string oper)
        {
            int ret = 0;
            switch (oper)
            {
                case "+":
                    ret = _calculator.Add(this.NumFirst, this.NumSecond);
                    break;
                case "-":
                    ret = _calculator.Sbu(this.NumFirst, this.NumSecond);
                    break;
                default:
                    break;
            }

            return ret;
        }
    }

    public class CalculatorProcess
    {
        public int Add(int a,int b)
        {
            return a + b;
        }

        public int Sbu(int a,int b)
        {
            return a - b;
        }
    }

对计算端扩展开放，添加乘法

public class Client
    {
        private ICalculatorProcess _calculator;

        public int NumFirst { get; set; }
        public int NumSecond { get; set; }
        public int Use(string oper)
        {
            int ret = 0;
            switch (oper)
            {
                case "+":
                    _calculator = new Add();
                    ret = _calculator.Operation(this.NumFirst, this.NumSecond);
                    break;
                case "-":
                    _calculator = new Sub();
                    ret = _calculator.Operation(this.NumFirst, this.NumSecond);
                    break;
                case "*":
                    _calculator = new Mul();
                    ret = _calculator.Operation(this.NumFirst, this.NumSecond);
                    break;
                default:
                    break;
            }
            return ret;
        }
    }

    public interface ICalculatorProcess
    {
        int Operation(int a, int b);
    }

    public class Add : ICalculatorProcess
    {
        public int Operation(int a, int b)
        {
            return a + b;
        }
    }

    public class Sub : ICalculatorProcess
    {
        public int Operation(int a, int b)
        {
            return a - b;
        }
    }

    public class Mul:ICalculatorProcess
    {
        public int Operation(int a, int b)
        {
            return a * b;
        }
    }

依赖倒置原则(DIP, Dependency Inversion Principle)

定义

• 高层模块不应该依赖于底层模块，二者都应该依赖于抽象。

• 抽象不应该依赖于具体，具体应该依赖于抽象。

  应用

  依赖倒置也是著名的好莱坞法则：不要调用我们，我们会调用你。在高层与低层间添加一抽象层（如上面的计算器）。

  接口隔离原则(ISP, Interface Segregation Principle)

  定义

  使用多个小的专门的接口，而不要使用一个大的总接口。
  一个类对另一个类的依赖应该建立在最小的接口上，不要强迫依赖不用的方法，这是一种接口污染。

  应用

  天鹅(Swan)即会游泳又会飞，但是鸭子只会游泳。
  强迫鸭子飞
  

接口隔离，做到最小接口

Liskov替换原则(LSP, Liskov Substitution Principle)

定义

子类必须能够替换其基类。

应用

主要体现在父类方法应该为virtual方法，子类重写父类方法，则子类完全可以替换父类在此调用自己的方法。