SOLID原则

1. SRP(Single Responsibility Principle) 单一责任原则

每一个封装类实现单一的原则，例如：实现计算1+1然后将结果写入文件中，应该实现2个方法，分别是：1）计算2个数的和、2）将string写入文件 

然后在1）中引用2） （比较简单没有代码例子）

2. OCP(Open Closed Principle) 开放封闭原则，

OCP简单来说就是 对扩展是开放的，对修改是封闭的。

例如：实现用户到银行进行相关业务（例子来自百度百科）

原代码：

 public class BusyBankStaff
    {
        private BankProcess bankProc = new BankProcess();
        // 定义银行员工的业务操作
        public void HandleProcess(Client client)
        {
            switch (client.ClientType)
            {
                case "存款用户":
                    bankProc.Deposit();
                    break;
                case "转账用户":
                    bankProc.Transfer();
                    break;
                case "取款户":
                    bankProc.DrawMoney();
                    break;
            }
        }
    }

修改后代码：

定义接口：

public interface IBankProcess
    {
        void Process();
    }

实现接口：

public class DepositProcess : IBankProcess
    {
        //IBankProcess Members
        #region IBankProcess Members
        public void Process()
        {
            // 办理存款业务
            throw new Exception("The method or operation is not implemented.");
        }
        #endregion
    }
    public class TransferProcess : IBankProcess
    {
        //IBankProcess Members
        #region IBankProcess Members
        public void Process()
        {
            // 办理转账业务
            throw new Exception("The method or operation is not implemented.");
        }
        #endregion
    }
    public class DrawMoneyProcess : IBankProcess
    {
        //IBankProcess Members
        #region IBankProcess Members
        public void Process()
        {
            // 办理取款业务
            throw new Exception("The method or operation is not implemented.");
        }
        #endregion
    }

对客户进行分类：

 public class Client
    {
        public string ClientType;
        public Client(string clientType)
        {
            ClientType = clientType;
        }
        public IBankProcess CreateProcess()
        {
            switch (ClientType)
            {
                case "存款用户":
                    return new DepositProcess();
                case "转账用户":
                    return new TransferProcess();
                case "取款用户":
                    return new DrawMoneyProcess();
            }
            return null;
        }
    }

使用方法：

  public class EasyBankStaff
    {
        private IBankProcess bankProc = null;
        public void HandleProcess(Client client)
        {
            bankProc = client.CreateProcess();
            bankProc.Process();
        }
    }

接口和实现接口可以使用虚方法和重构代替

　 规则建议
　　l 开放封闭原则，是最为重要的设计原则，Liskov替换原则和合成/聚合复用原则为开放封闭原则的实现提供保证。
　　2 可以通过Template Method模式和Strategy模式进行重构，实现对修改封闭、对扩展开放的设计思路。
　　3 封装变化，是实现开放封闭原则的重要手段，对于经常发生变化的状态一般将其封装为一个抽象，例如银行业务中的IBankProcess接口。
　　4 拒绝滥用抽象，只将经常变化的部分进行抽象，这种经验可以从设计模式的学习与应用中获得。

3. LSP(Liskov Substitution Principle) 里氏替换原则，

任何基类（父类）可以出现的地方，子类一定可以出现 当一个子类的实例应该能够替换任何其超类实例时，他们之间才具有is-A（继承）关系

说白了 就是父类能做的事情子类也要能做 也就是老鼠的儿子会打洞

4. ISP(Interface Segregation Principle) 接口分离原则，

接口分离原则 既是接口所实现的功能应该分离

 public interface IAnimal
    {
        public void Fly { }
        public void Eat { }
    }
    public class Dog:IAnimal { 
    
    }
    public class Hawk : IAnimal { 
    
    }

上面的代码IAnimal接口实现了 Fly和Eat 继承接口的Dog并不会飞

5. DIP(Dependency Inversion Principle) 依赖倒置原则，

A.高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。

B.抽象不应该依赖于具体实现，具体实现应该依赖于抽象。

依赖倒置原则（Dependence Inversion Principle）是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。