（49）C#设计原则

使用

使用设计模式的根本原因是适应变化，提高代码复用率，是软件更具有可维护性和可扩展性。并且，在进行设计的时候，也需要遵循以下几个原则：单一职责原则、开放封闭原则、里氏替换原则、依赖导致原则、接口隔离原则、合成复用原则和迪米特法则。

单一职责原则

就一个类而言，应该只有一个引起它变化的原因。如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会影响到其他的职责，另外，把多个职责耦合在一起，也会影响复用性。

开闭原则（Open-Closed Principe）

开闭原则即OCP原则，强调：一个软件实体（指类、函数、模块等）应该对扩展开放，对修改关闭。即每次发生变化时，要通过添加新的代码来增强现有类型的行为，而不是修改原有的代码。

符合开闭原则最好的方式是提供一个接口，然后让所有可能发生变化的类实现该接口，让固定的接口与相关对象进行交互。

里氏替换原则（Liskov Substitution Principe）

里氏替换原则指的是子类型必须替换掉他们的父类型。也就是说，在软件开发过程中，子类替换父类后，程序的行为是一样的。只有当子类替换掉父类后，此时软件的功能不受影响时，父类才真正地被复用，而子类也可以在父类的基础上添加新的行为。下面的代码就违反了里氏替换原则

public class Rectangle
    {
        public virtual long Width { get; set; }
        public virtual long Height { get; set; }
    }
    // 正方形
    public class Square : Rectangle
    {
        public override long Height
        {
            get
            {
                return base.Height;
            }
            set
            {
                base.Height = value;
                base.Width = value;
            }
        }

        public override long Width
        {
            get
            {
                return base.Width;
            }
            set
            {
                base.Width = value;
                base.Height = value;
            }
        }
    }
 class Test
    {
        public void Resize(Rectangle r)
        {
            while (r.Height >= r.Width)
            {
                r.Width += 1;
            }
        }
        var r = new Square() { Width = 10, Height = 10 };
         new Test().Resize(r);
     }

上面的设计，在执行Test的Resize方法是，如果传入的是长方形对象，当高度大于宽度是，会自动增加宽度直到超出高度。但是如果传入的是正方形对象，则会陷入死循环。此时根本原因是，矩形不能作为正方形的父类，既然出现了问题，可以进行重构，是它们两都继承于四边形类。

// 四边形
    public abstract class Quadrangle
    {
        public virtual long Width { get; set; }
        public virtual long Height { get; set; }
    }
    // 矩形
    public class Rectangle : Quadrangle
    {
        public override long Height { get; set; }

        public override long Width { get; set; }
       
    }
    // 正方形
    public class Square : Quadrangle
    {
        public long _side;

        public Square(long side)
        {
            _side = side;
        }
    }
 class Test
    {
        public void Resize(Quadrangle r)
        {
            while (r.Height >= r.Width)
            {
                r.Width += 1;
            }
        }


        static void Main(string[] args)
        {
            var s = new Square(10);

            new Test().Resize(s);
        }
    }

依赖倒置原则

依赖倒置（Dependence Inversion Principe，DIP）原则指的是抽象不应该依赖于细节，细节应该依赖于抽象，也就是提出的“面向接口编程，而不是面向实现编程”。这样可以降低客户与具体实现的耦合。

接口隔离原则

接口隔离原则（Interface Segregation Principe，ISP）指的是使用多个专门的接口比使用单一的总接口要好。也就是说不要让一个单一的接口承担过多的职责，而应该把每个职责分离到多个专门的接口中，进行接口分离。过于臃肿的接口是对接口的一种污染。

合成复用原则

合成复用原则（Composite Reuse Principe，CRP）就是在一个对象中使用一些已有的对象，使之成为新对象的一部分。新对象通过向这些对象的委派达到复用已有功能的目的。简单的说，就是要尽量使用合成/聚合，尽量不要使用继承。

要使用好合成复用原则，首先要区分“Has-A”和“Is-A”的关系。

“Is-A”是指一个类是另一个类的“一种”，是属于的关系，而“Has—A”表示某一个角色具有某一项责任。导致错误的使用继承而不是聚合的常见原因就是错误地把“Has—A”当成“Is—A”，例如

实际上，雇员、经理、学生描述的是一种角色，比如一个人是经理那么必然是雇员。在上面的设计中，一个人无法同时拥有多个角色，是雇员就不能再是学生了，这显然不合理，因为现实中很多在职研究生，即使雇员也是学生。

上面的设计的错误源于把角色的等级结构与人的等级结构混淆，误把“Has—A”当作"Is—A"。具体的解决方法就是抽象出一个角色类：

迪米特法则

迪米特法则（Law of Demeter，LOP）又叫做最少知识原则，指的是一个对象应当对其他对象有尽可能少的了解。也就是说，一个模块或对象应尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立，这样当一个模块修改时，影响的模块就会越少，扩展起来更容易。外观模式和中介者模式就使用了迪米特法则。