《大话设计模式(C#实现)》

版本

作者

参与者

完成日期

备注

YanlzFramework_GoF_V01_1.0

严立钻

2020.02.10

#第一篇：6大设计原则篇

++单一职责原则的好处：

++++1、类的复杂性降低：实现什么职责都有清晰明确的定义；

++++2、可读性提高：复杂性降低，那当然可读性提高了；

++++3、可维护性提高：可读性提高，那当然更容易维护了；

++++4、变更引起的风险降低：变更是必不可少的，如果接口的单一职责做得好，一个接口修改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性、维护性都有非常大的帮助；

++依赖倒置原则包含三层含义：

++++A、高层模块不应该依赖低层模块，两者都应该依赖其抽象；

++++B、抽象不应该依赖细节；

++++C、细节应该依赖抽象；

++++补充1：抽象就是指接口或抽象类，两者都是不能直接被实例化的；细节就是实现类，实现接口或继承抽象类而产生的类就是细节，其特点就是可以直接被实例化，也就是可以加上一个关键字new产生一个对象。

++依赖倒置原则的表现：

++++A、模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的；

++++B、接口或抽象类不依赖于实现类；

++++C、实现类依赖接口或抽象类；

++++补充1：面向接口编程是OOD（Object-Oriented Design，面向对象设计）的精髓之一。

++依赖的三种写法：

++++第一种：构造函数传递依赖对象：

--在类中通过构造函数声明依赖对象，按照依赖注入的说法，这种方式叫做构造函数注入。

--public Driver(ICar _car){  this.car = _car;  }

++++第二种：Setter方式传递依赖对象：

--在抽象中设置Setter方法声明依赖关系，依照依赖注入的说法，这是Setter依赖注入。

--public void SetCar(ICar car){  this.car = car;  }

++++第三种：接口声明依赖对象：

--在接口的方法中声明依赖对象，采用接口声明依赖的方式，该方法也叫做接口注入。

--public void drive(ICar car);

++保证接口的纯洁性：

++++A、接口要尽量小。（这是接口隔离原则的核心定义，不出现臃肿的接口（Fat Interface），但是“小”是由限度的，首先就是不能违反单一职责原则。）

++++B、接口要高内聚。（高内聚就是提高接口、类、模块的处理能力，减少对外的交互。）（在接口中尽量少公布public方法，接口是对外的承诺，承诺越少对系统的开发越有利，变更的风险也就越少，同时也有利于降低成本。）

++迪米特法则对类的低耦合包含以下4层含义：

++++A、只和朋友交流。（类与类之间的关系是建立在类间的，而不是方法间，因此一个方法尽量不引入一个类中不存在的对象。）（两个对象之间的耦合方式：组合、聚合、依赖等）

++++B、朋友间也是有距离的。（一个类公开的public属性或方法越多，修改时涉及的面也就越大，变更引起的风险扩散也就越大；）（尽量不要对外公布太多的public方法和非静态的public变量，尽量内敛，多使用private，protected等访问权限。）

++++C、是自己的就是自己的。（如果一个方法放在本类中，即不增加类间关系，也对本类不产生负面影响，就放置在本类中。）

++++D、谨慎使用Serializable。（从private变更为public，访问权限扩大了，如果服务器上没有做出相应的变更，就会报序列化失败。）

++如何使用开闭原则：

++++A、抽象约束。（抽象是对一组事物的通用描述，没有具体的实现，也就表示它可以有非常多的可能性，可以跟随需求的变化而变化。因此，通过接口或抽象类可以约束一组可能变化的行为，并且能够实现对扩展开放）

--第一：通过接口或抽象类约束扩展，对扩展进行边界限定，不允许出现在接口或抽象类中不存在的public方法；

--第二：参数类型、引用对象尽量使用接口或者抽象类，而不是实现类；

--第三：抽象层尽量保持稳定，一旦确定即不允许修改；

++++B、元数据（metadata）控制模块行为。（尽量使用元数据来控制程序的行为，减少重复开发。）（元数据：用来描述环境和数据的数据，就是配置参数，参数可以从文件中获得，也可以从数据库中获得。）

++++C、封装变化。

--第一：将相同的变化封装到一个接口或抽象类中。

--第二：将不同的变化封装到不同的接口或抽象类中，不应该有两个不同的变化出现在同一个接口或抽象类中。

#第二篇：23设计模式篇

++设计模式的四个境界：

++++境界1（懵懂）：没学前是一点不懂，根本想不到用设计模式，设计的代码很糟糕；

++++境界2（认知）：学了几个模式后，很开心，于是到处想着要用自己学过的模式，于是时常造成误用模式而不自知；

++++境界3（了解）：学完全部模式时，感觉诸多模式极其相似，无法分清模式之间的差异，有困惑，但深知误用之害，应用之时有所犹豫；

++++境界4（领悟）：灵活应用模式，甚至不应用具体的某种模式也能设计出非常优秀的代码，以达到无剑胜有剑的境界；

++2B.01、单例模式

//立钻哥哥：Singleton类

class Singleton{

    private static Singleton instance;

    private Singleton(){}    //构造方法让其private，防止外界利用new实例化

    //此方法是获得本类实例的唯一全局访问点

    public static Singleton GetInstance(){

        if(instance == null){

            instance = new Singleton();    //不存在，new实例化一个

        }

        return instance;

    }    //立钻哥哥：public static Singleton GetInstance(){}

}    //立钻哥哥：class Singleton{}

++2B.02、工厂方法模式

//立钻哥哥：计算器的工厂方法模式实现

//A、先构建一个工厂接口：

interface IFactory{

    Operation CreateOperation();

}    //立钻哥哥：interface IFactory{}

//B、然后加减乘除各建一个具体工厂去实现这个接口：

//B.1、加法类工厂

class AddFactory : IFactory{

    public Operation CreateOperation(){

        return new OperationAdd();

    }

}    //立钻哥哥：class AddFactory:IFactory{}

//B.2、减法类工厂

class SubFactory : IFactory{

    public Operation CreateOperation(){

        return new OperationSub();

    }

}    //立钻哥哥：class SubFactory:IFactory{}

//B.3、乘法类工厂

class MulFactory : IFactory{

    public Operation CreateOperation(){

        return new OperationMul();

    }

}    //立钻哥哥：class MulFactory:IFactory{}

//B.4、除法类工厂

class DivFactory : IFactory{

    public Operation CreateOperation(){

        return new OperationDiv();

    }

}    //立钻哥哥：class DivFactory:IFactory{}

//C、创建一个Operation运算类

public class Operation{

    private double _numberA = 0;

    private double _numberB = 0;

    public double NumberA{

        get{  return _numberA;  }

        set{  _numberA = value;  }

    }

    public double NumberB{

        get{  return _numberB;  }

        set{  _numberB = value;  }

    }

    public virtual double GetResult(){

        double result = 0;

        return result;

    }

}    //立钻哥哥：public class Operation{}

//C、加减乘除类（继承public class Operation{}）

//C.1、加法类，继承运算类

class OperationAdd : Operation{

    public override double GetResult(){

        double result = 0;

        resutl = NumberA + NumberB;

        return result;

    }

}    //立钻哥哥：class OperationAdd:Operation{}

//C.2、减法类，继承运算类

class OperationSub : Operation{

    public override double GetResult(){

        double result = 0;

        result = NumberA - NumberB;

        return result;

    }

}    //立钻哥哥：class OperationSub:Operation{}

//C.3、乘法类，继承运算类

class OperationMul : Operation{

    public override double GetResult(){

        double result = 0;

        result = NumberA * NumberB;

        return result;

    }

}    //立钻哥哥：class OperationMul:Operation{}

//C.4、除法类，继承运算类

class OperationDiv : Operation{

    public override double GetResult(){

        double result = 0;

        if(NumberB == 0){

            throw new Exception(“立钻哥哥：除数不能为0。”);

        }

        result = NumberA / NumberB;

        return result;

    }

}    //立钻哥哥：class OperationDiv:Operation{}

//D、客户端的代码

IFactory operFactory = new AddFactory();

Operation oper = operFactory.CreateOperation();

oper.NumberA = 11;

oper.NumberB = 100;

double result = oper.GetResult();

++2B.03、抽象工厂模式

++2B.04、建造者模式

//立钻哥哥：建造者模型基本代码

//A、Product类：产品类，由多个部件组成

class Product{

    List<string> parts = new List<string>();

    //添加产品部件

    public void Add(string part){

        parts.Add(part);

    }

    public void Show(){

        Console.WriteLine(“立钻哥哥：产品 创建 ----”);

        foreach(string part in parts){

            Console.WriteLine(part);

        }

    }

}    //立钻哥哥：class Product{}

//B、Builder类：抽象建造者类，确定产品由两个部件PartA和PartB组成，并声明一个得到产品建造后结果的方法GetResult:

abstract class Builder{

    public abstract void BuildPartA();

    public abstract void BuildPartB();

    public abstract Product GetResult();

}    //立钻哥哥：abstract class Builder{}

//B.1、ConcreteBuilder1类：具体建造者类

class ConcreteBuilder1 : Builder{

    private Product product = new Product();

    public override void BuilderPartA(){

        product.Add(“立钻哥哥：部件A”);

    }

    public override void BuilderPartB(){

        product.Add(“立钻哥哥：部件B”);

    }

    public override Product GetResult(){

        return product;

    }

}    //立钻哥哥：class ConcreteBuilder1:Builder{}

//B.2、ConcreteBuilder2类：具体建造者类

class ConcreteBuilder2 : Builder{

    private Product product = new Product();

    public override void BuildPartA(){

        product.Add(“立钻哥哥：部件X”);

    }

    public override void BuildPartB(){

        product.Add(“立钻哥哥：部件Y”);

    }

    public override Product GetResult(){

        return product;

    }

}    //立钻哥哥：class ConcreteBuilder2:Builder{}

//C、Director类：指挥者类

class Director{

    public void Construct(Builder builder){

        builder.BuildPartA();

        builder.BuildPartB();

    }

}    //立钻哥哥：class Director{}

//D、客户端代码，客户不需知道具体的建造过程

static void Main(string[] args){

    Director director = new Director();

    Builder b1 = new ConcreteBuilder1();

    Builder b2 = new ConcreteBuilder2();

    //指挥者用ConcreteBuilder1的方法来建造产品

    director.Construct(b1);

    Product p1 = b1.GetResult();

    p1.Show();

    //指挥者用ConcreteBuilder2的安防来建造产品

    director.Construct(b2);

    Product p2 = b2.GetResult();

    p2.Show();

    Debug.Log(“立钻哥哥：建造者模式演示完毕~~”);

}

++2B.05、原型模式

//立钻哥哥：Prototype原型模式

//A、原型类

abstract class Prototype{

    private string id;

    public string Id{

        get{  return id;  }

    }

    public Prototype(string id){

        this.id = id;

    }

    //立钻哥哥：抽象类关键就是有这样一个Clone方法

public abstract Prototype Clone();

}    //立钻哥哥：abstract class Prototype{}

//B、具体原型类

class ConcretePrototype1 : Prototype{

    public ConcretePrototype1(string id) : base(id){

    }

    public override Prototype Clone(){

        return (Prototype)this.MemeberwiseClone();

    }

}    //立钻哥哥：class ConcretePrototype1:Prototype{}

//C、客户端代码

static void Main(string[] args){

    ConcretePrototype1 p1 = new ConcretePrototype1(“立钻哥哥”);

    //克隆类ConcretePrototype1的对象p1就能得到新的实例c1

    ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();

}

//补充说明：对于.NET而言，原型抽象类Prototype是用不着的，因为克隆实在是太常用了，所以.NET在System命名空间中提供了ICloneable接口，其中就是唯一的一个方法Clone()，这样只需要实现这个接口就可以完成原型模式了。

++2B.06、适配器模式

++适配器模式的优点

++++优点1：适配器模式可以让两个没有任何关系的类在一起运行，只要适配器这个角色能够搞定他们就成。

++++优点2：增加了类的透明性。（我们访问的Target目标角色，但是具体的实现都委托给了源角色，而这些对高层次模块是透明的，也是它不需要关心的。）

++++优点3：提高了类的复用度。（源角色在原有的系统中还是可以正常使用，而在目标角色中也可以充当新的演员。）

++++优点4：灵活性非常好。（如果不想要适配器了，删除掉就可以了，其他的代码都不用修改，基本上就类似一个灵活的构件，想用就用，不想要就卸载。）

//立钻哥哥：Adapter适配器模式代码实现

//A、Target类（这是客户所期望的接口。目标可以是具体的或抽象的类，也可以是接口）

class Target{

    public virtual void Request(){

        Debug.Log(“立钻哥哥：----普通请求----”);

    }

}    //立钻哥哥：class Target{}

//B、Adaptee类（需要适配的类）

class Adaptee{

    public void SpecificRequest(){

        Debug.Log(“立钻哥哥：----特殊请求----”);

    }

}    //立钻哥哥：class Adaptee{}

//C、Adapter类（通过在内部包装一个Adaptee对象，把源接口转换成目标接口）

class Adapter : Target{

    //建立一个私有的Adaptee对象

    private Adaptee adaptee = new Adaptee();

    public override void Request(){

        //这样就可把表面上调用Request()方法变成实际调用SpecificRequest()

        adaptee.SpecificRequest();

    }

}    //立钻哥哥：class Adapter:Target{}

//D、客户端代码

static void Main(string[] args){

    Target target = new Adapter();

    target.Request();    //对客户端来说，调用的就是Target的Request()

    Debug.Log(“立钻哥哥：----适配器模式演示完毕~~”);

}

++2B.07、装饰模式

//立钻哥哥：Decorator装饰模式的代码实现

//A、Component类

abstract class Component{

    public abstract void Operation();

}    //立钻哥哥：abstract class Component{}

//B、ConcreteComponent类

class ConcreteComponent : Component{

    public override void Operation(){

        Debug.Log(“立钻哥哥：----具体对象的操作----”);

    }

}    //立钻哥哥：class ConcreteComponent:Component{}

//C、Decorator类

abstract class Decorator : Component{

    protected Component component;

    //设置Component

    public void SetComponent(Component component){

        this.component = component;

    }

    //重写Operation(),实际执行的是Component的Operation()

    public override void Operation(){

        if(component != null){

            component.Operation();

        }

    }

}    //立钻哥哥：abstract class Decorator:Component{}

//D.1、ConcreteDecoratorA类

class ConcreteDecoratorA : Decorator{

    //本类的独有功能，以区别于ConcreteDecoratorB

    private string addedState;

    public override void Operation(){

        //首先运行原Component的Operation()，再执行本类的功能，如addedState，相当于对原Component进行了装饰。

        base.Operation();

        addedState = “立钻哥哥”;

        Debug.Log(“立钻哥哥：具体装饰对象A的操作”);

    }

}    //立钻哥哥：class ConcreteDecoratorA:Decorator{}

//D.2、ConcreteDecoratorB类

class ConcreteDecoratorB : Decorator{

    public override void Operation(){

        //首先运行原Component的Operation()，再执行本类的功能，如AddedBehaviour()，相当于对原Component进行了装饰

        base.Operation();

        AddedBehaviour();

        Debug.Log(“立钻哥哥：----具体装饰对象B的操作”);

    }

    //本类独有的方法，以区别于ConcreteDecoratorA

    private void AddedBehaviour();

}    //立钻哥哥：class ConcreteDecoratorB:Decorator{}

//E、客户端代码

static void Main(string[] args){

    ConcreteComponent c = new ConcreteComponent();

    ConcreteDecoratorA d1 = new ConcreteDecoratorA();

    ConcreteDecoratorB d2 = new ConcreteDecoratorB();

    //装饰的方法是：首先用ConcreteComponent实例化对象c，然后用ConcreteDecoratorA的实例化对象d1来包装c，再用ConcreteDecoratorB的对象d2包装d1，最终执行d2的Operation();

    d1.SetComponent(c);

    d2.SetComponent(d1);

    d2.Operation();

    Debug.Log(“立钻哥哥：----装饰模式演示完毕~~”);

}    //立钻哥哥：static void Main(string[] args){}

++2B.08、桥接模式

//立钻哥哥：Bridge桥接模式的代码实现

//A、Implementor类

abstract class Implementor{

    public abstract void Operation();

}    //立钻哥哥：abstract class Implementor{}

//B.1、ConcreteImplementorA派生类

class ConcreteImplementorA : Implementor{

     public override void Operation(){

        Debug.Log(“立钻哥哥：----具体实现A的方法执行----”);

    }

}    //立钻哥哥：class ConcreteImplementorA:Implementor{}

//B.2、ConcreteImplementorB派生类

class ConcreteImplementorB : Implementor{

    public override void Operation(){

        Debug.Log(“立钻哥哥：----具体实现B的方法执行----”);

    }

}    //立钻哥哥：class ConcreteImplementorB:Implementor{}

//C、Abstraction类

class Abstraction{

    protected Implementor implementor;

    public void SetImplementor(Implementor implementor){

        this.implementor = implementor;

    }

    public virtual void Operation(){

        implementor.Operation();

    }

}    //立钻哥哥：class Abstraction{}

//D、RefinedAbstraction类

class RefinedAbstraction : Abstraction{

    public override void Operation(){

        implementor.Operation();

    }

}    //立钻哥哥：class RefinedAbstraction:Abstraction{}

//E、客户端实现

static void Main(stirng[] args){

    Abstraction ab = new RefinedAbstraction();

    ab.SetImplementor(new ConcreteImplementorA());

    ab.Operation();

    ab.SetImplementor(new ConcreteImplementorB());

    ab.Operation();

    Debug.Log(“立钻哥哥：----桥接模式演示完毕~~”);

}

++2B.09、组合模式

//立钻哥哥：Composite组合模式代码实现

//A、Component为组合中的对象声明接口，在适当情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component的子部件

abstract class Component{

    protected string name;

    public Component(string name){

        this.name = name;

    }

    //通常都用Add和Remove方法来提供增加或移除树叶或树枝的功能

    public abstract void Add(Component c);

    public abstract void Remove(Component c);

    public abstract void Display(int depth);

}    //立钻哥哥：abstract class Component{}

//B、Leaf组合中表示叶节点对象，叶节点没有子节点

class Leaf : Component{

    public Leaf(string name) : base(name){

    }

    //由于叶子没有再增加分枝和树叶，所以Add和Remove方法实现它没有意义，但这样做可以消除叶节点和枝节点对象在抽象层次的区别，它们具有完全一致的接口

    public override void Add(Component c){

        Debug.Log(“立钻哥哥：----Cannot add to a leaf.---”);

    }

    public override void Remove(Component c){

        Debug.Log(“立钻哥哥：----Cannot remove from a leaf.---”);

    }

    //叶节点的具体方法，此处是显示其名称和级别

    public override void Display(int depth){

        Debug.Log(new string(‘-’, depth) + name);

    }

}    //立钻哥哥：class Leaf:Component{}

//C、Composite定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关的操作，比如增加Add和删除Remove

class Composite : Component{

    //一个子对象集合用来存储其下属的枝节点和叶节点

    private List<Component> children = new List<Component>();

    public Composite(string name) : base(name){

    }

    public override void Add(Component c){

        children.Add(c);

    }

    public override void Remove(Component c){

        children.Remove(c);

    }

    public override void Display(int depth){

        Debug.Log(new string(‘-’, depth) + name);

        foreach(Component component in children){

            component.Display(depth + 2);

        }

    }

}    //立钻哥哥：class Composite:Component{}

//D、客户端代码，能通过Component接口组合部件的对象

static void Main(string[] args){

    //生成树根root，根上长出两叶LeafA和LeafB

    Composite root = new Composite(“root”);

    root.Add(new Leaf(“Leaf A”));

    root.Add(new Leaf(“Leaf B”));

    //根上长出分枝CompositeX，分枝上也有两叶LeafXA和LeafXB

    Composite comp = new Composite(“Composite X”);

    comp.Add(new Leaf(“Leaf XA”));

    comp.Add(new Leaf(“Leaf XB”));

    root.Add(comp);

    //在CompositeX上再长出分枝CompositeXY，分枝上也有两叶LeafXYA和LeafXYB

    Composite comp2 = new Composite(“Composite XY”);

    comp2.Add(new Leaf(“Leaf XYA”));

    comp2.Add(new Leaf(“Leaf XYB”));

    comp.Add(comp2);

    //根部又长出两叶LeafC和LeafD，可惜LeafD每长牢，被风吹走了

    root.Add(new Leaf(“Leaf C”));

    Leaf leaf = new Leaf(“Leaf D”);

    root.Add(leaf);

    root.Remove(leaf);

    //显示大树的样子

    root.Display(1);

    Debug.Log(“立钻哥哥：----组合模式演示完毕~~”);

}

//E、结果显示

++2B.10、享元模式

立钻哥哥推荐的拓展学习链接（Link_Url）