23种设计模式

之前我们有讲过六大设计原则，分别为【单一职责】【里氏替换】【 迪米特法则】【依赖倒置原则】【接口隔离原则】【开闭原则】，这些只能叫原则，叫建议，而并没有实际的招数。

那今天我们来讨论一下23种设计模式。设计模式就是：面向对象语言开发过程中，遇到的种种场景和问题，然后提出了解决方案和思路。

沉淀下来的就变成了设计模式，解决具体问题的具体招数，其实说白了就是套路，即是我们站在前辈的肩膀来解决问题。

设计模式分为三大类型：

1：创建型设计模式：关注对象的创建

2：结构型设计模式：关注类与类之间的关系

3：行为型设计模式：关注对象和行为的分离

接下来我们分别来讲讲一下这三类设计模式

一：创建性设计模式

看到这个很多人会想，对象的创建难道不就是new()一下，然后就能解决的吗？其实不然，这里面有很多套路，他包含：【单例模式】【原型】【简单工厂】【工厂方法】【抽象工厂】【建造者模式】等

1：单例模式：主要应用于构造对象耗时好资源，且很多地方都需要去new，想要避免重复构造的时候可以使用单例模式

A：怎么创建单例？

1：构造函数私有化，避免别人私有化

2：公开的静态方法提供对象的实例

3：全局唯一静态，重用这个变量，保证全局都是这一个

B：单例虽然限制了对象的创建，重用了对象，但是单例是不具有多线程安全性的，所以我们可以通过以下三种方式创建

1：静态变量初始化new

2：静态构造函数中new

3：使用lock加锁new

因为构造一个类的时候，首先先创建静态字段，然后再执行静态构造函数，所以使用静态变量或者静态构造函数进行创建时，只要你使用这个类就会创建这个对象，然后会常驻内存，这些称为饿汗单例，使用lock加锁的称为懒汉单例

第一种声明如下：懒汉式单例模式，使用lock加锁new

namespace SingletonPattern
{
    /// <summary>
    /// 单例类：一个构造对象很耗时耗资源类型
    /// 懒汉式单例模式
    /// </summary>
    public class Singleton
    {
        /// <summary>
        /// 构造函数耗时耗资源
        /// </summary>
        private Singleton()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(2000);
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }

        /// <summary>
        /// 3 全局唯一静态  重用这个变量
        /// volatile 促进线程安全 让线程按顺序操作
        /// </summary>
        private static volatile Singleton _Singleton = null;
        //因为单例会有线程安全问题，所以会加锁的操作        
        private static readonly object Singleton_Lock = new object();
       
        /// <summary>
        /// 2 公开的静态方法提供对象实例
        /// 双重if加锁会提高性能
        /// </summary>
        /// <returns></returns>
        public static Singleton CreateInstance()
        {
            if (_Singleton == null)//是_Singleton已经被初始化之后，就不要进入锁等待了
            {
                lock (Singleton_Lock)
                //保证任意时刻只有一个线程进入lock范围
                //也限制了并发，尤其是_Singleton已经被初始化之后
                {
                    if (_Singleton == null)//保证只实例化一次
                    {
                        _Singleton = new Singleton();
                    }
                }
            }
            return _Singleton;
        }

        //既然是单例，大家用的是同一个对象，用的是同一个方法，
       //如果并发还有线程安全问题，所以要保证线程安全必须lock加锁
        public int iTotal = 0;
    }
}

第二种声明如下：静态构造函数

namespace SingletonPattern
{
    /// <summary>
    /// 单例类：一个构造对象很耗时耗资源类型    /// 
    /// 饿汉式
    /// </summary>
    public class SingletonSecond
    {
        private static SingletonSecond _SingletonSecond = null;

        /// <summary>
        /// 1 构造函数耗时耗资源
        /// </summary>
        private SingletonSecond()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }

        /// <summary>
        /// 静态构造函数:由CLR保证，程序第一次使用这个类型前被调用，且只调用一次
        /// 检测，初始化
        /// 写日志功能的文件夹检测
        /// XML配置文件
        /// </summary>
        static SingletonSecond()
        {
            _SingletonSecond = new SingletonSecond();
            Console.WriteLine("SingletonSecond 被启动");
        }
       
        public static SingletonSecond CreateInstance()
        {
            return _SingletonSecond;
        }//饿汉式  只要使用类就会被构造

    }
}

第三种声明如下：静态变量初始化时走私有构造函数

namespace SingletonPattern
{
    /// <summary>
    /// 单例类：一个构造对象很耗时耗资源类型
    /// 饿汉式
    /// </summary>
    public class SingletonThird
    {
        /// <summary>
        /// 构造函数耗时耗资源
        /// </summary>
        private SingletonThird()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }

        /// <summary>
        /// 静态字段：在第一次使用这个类之前，由CLR保证，初始化且只初始化一次
        /// 这个比构造函数还早
        /// </summary>
        private static SingletonThird _SingletonThird = new SingletonThird();
        public static SingletonThird CreateInstance()
        {
            return _SingletonThird;
        }//饿汉式  只要使用类就会被构造
    }
}

C：单例一般运用的场景

单例是保证全局唯一的一个实例，主要是应对一些特殊情况，比如数据库连接池(内置资源），再比如：流水号或者订单号生成器，使用同一个变量保证初始值是同一个！

2：原型设计模式

原型设计模式是在单例的基础上面升级了一下，然后把对象从内存的层面复制了一下，然后返回一个新的对象，但是又不走构造函数

注意：原型模式是一个新的对象，新的地址，但是copy仅仅是浅克隆，而不是深克隆，所以有时候需要注意一下

A：原型模式的声明如下：

namespace SingletonPattern
{
    /// <summary>
    /// 原型模式：单例的基础上升级了一下，把对象从内存层面复制了一下，
    /// 然后返回是个新对象，但是又不是new出来的（不走构造函数）
    /// </summary>
    public class Prototype
    {
        /// <summary>
        /// 构造函数耗时耗资源
        /// </summary>
        private Prototype()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(2000);
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }

        /// <summary>
        /// 3 全局唯一静态  重用这个变量
        /// </summary>
        private static volatile Prototype _Prototype = new Prototype();

        /// <summary>
        /// 2 公开的静态方法提供对象实例
        /// </summary>
        /// <returns></returns>
        public static Prototype CreateInstance()
        {
            Prototype prototype = (Prototype)_Prototype.MemberwiseClone();
            return prototype;
        }
    }
}

B：什么是深克隆，浅克隆

深克隆：除了对象本身被复制外，对象所包含的所有成员变量也将被复制。如下图所示：

下面附上一张深克隆的代码以后需要的话，可以直接拿来用：

浅克隆：当原型对象被复制时，只复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量并没有复制。如下图所示：

C：原型模式适用的场景

1：创建新对象成本较大（例如初始化时间长，占用CPU多或占太多网络资源），新对象可以通过复制已有对象来获得，如果相似对象，则可以对其成员变量稍作修改。

2：系统要保存对象的状态，而对象的状态很小。

3：需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的组合状态，通过复制原型对象得到新实例可以比使用构造函数创建一个新实例更加方便。

3：简单工厂(不属于23种设计模式)

不直接new，然后把对象的创建转移到工厂中，这种是细节没有消失，只是转移了矛盾，并没有消除矛盾，而是把矛盾集中在同一个工厂中

创建一个简单工厂的实例如下：

 public interface IRace
 {
     /// <summary>
     /// show出王者
     /// </summary>
     void ShowKing();
 }
  
   /// <summary>
    /// War3种族之一
    /// </summary>
    public class Human : IRace
    {
        public Human(int id, DateTime dateTime, string reamrk)
        { }
        public Human()
        { }

        public void ShowKing()
        {
            Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Sky");
        }
    }

/// <summary>
/// War3种族之一
/// </summary>
public class Undead : IRace
{
    public void ShowKing()
    {
        Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "GoStop");
    }
}

 /// <summary>
 /// War3种族之一
 /// </summary>
 public class ORC : IRace
 {
     public void ShowKing()
     {
         Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Grubby");
     }
 }
 /// <summary>
 /// War3种族之一
 /// </summary>
 public class NE : IRace
 {
     public void ShowKing()
     {
         Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Moon");
     }
 }

 public enum RaceType
 {
     Human,
     Undead,
     ORC,
     NE
 }

/// <summary>
/// 细节没有消失，只是转移
/// 矛盾也没有消除，只是转移
/// 除此之外把所有的业务都写在这个里面，也集中了矛盾
/// </summary>
/// <param name="raceType"></param>
/// <returns></returns>
public static IRace CreateRace(RaceType raceType)
{
    IRace iRace = null;
    switch (raceType)
    {
        case RaceType.Human:
            iRace = new Human();
            break;
        case RaceType.Undead:
            iRace = new Undead();
            break;
        case RaceType.ORC:
            iRace = new ORC();
            break;
        case RaceType.NE:
            iRace = new NE();
            break;
        //增加一个分支
        default:
            throw new Exception("wrong raceType");
    }
    return iRace;
}

然后调用如下：

{
    Player player = new Player()
    {
        Id = 123,
        Name = "候鸟"
    };
}
{
    IRace human = ObjectFactory.CreateRace(RaceType.Human);  //new Human();没有细节  细节被转移
    player.PlayWar3(human);
}
{
    IRace undead = ObjectFactory.CreateRace(RaceType.Undead); //new Undead();没有细节 细节被转移
    player.PlayWar3(undead);
}

A：简单工厂的优点

1：简单工厂模式解决了客户端直接依赖于具体对象的问题，客户端可以消除直接创建对象的责任，而仅仅是消费产品。简单工厂模式实现了对责任的分割

2：简单工厂模式也起到了代码复用的作用，把所有的创建都统一一起写，以后避免多人多次写重复的代码

B：简单工厂的缺点

1：工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都会受到影响

2：系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，这样就会造成工厂逻辑过于复杂

C：简单工厂的应用场景

1：当工厂类负责创建的对象比较少时可以考虑使用简单工厂模式

2：客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时可以考虑使用简单工厂模式

D：.NET中简单工厂模式的实现

.NET中System.Text.Encoding类就实现了简单工厂模式，该类中的GetEncoding(int codepage)就是工厂方法，具体的代码可以通过Reflector反编译工具进行查看，具体可以看下图

4：工厂方法

由于简单工厂模式系统难以扩展，一旦添加新产品就不得不修改简单工厂的方法，这样就会造就了简单工厂的实现逻辑过于复杂，所以出现了工厂方法。

工厂方法模式之所以可以解决简单工厂的模式，是因为它的实现把具体产品的创建推迟到子类中，此时工厂类不再负责所有产品的创建，而只是给出具体工厂必须实现的接口，这样工厂方法模式就可以允许系统不修改工厂类逻辑的情况下来添加新产品，这样也就克服了简单工厂模式中缺点

A：工厂方法的实现

创建工厂方法如下：

namespace FactoryMethod.Factory
{
    public interface IFactory
    {
        IRace CreateRace();
    }

    public class UndeadFactory : IFactory
    {
        public IRace CreateRace()
        {
            return new Undead();
        }
    }
    public class ORCFactory : IFactory
    {
        public IRace CreateRace()
        {
            return new ORC();
        }
    }
    public class NEFactory : IFactory
    {
        public IRace CreateRace()
        {
            return new NE();
        }
    }

    public class HumanFactory : IFactory
    {
        public virtual IRace CreateRace()
        {
            return new Human();
        }
    }
    public class HumanFactoryAdvanced : HumanFactory
    {
        public override IRace CreateRace()
        {
            Console.WriteLine("123");
            return new Human();
        }
    }
}

调用如下：

{
    IFactory factory = new HumanFactory();//包一层
    IRace race = factory.CreateRace();
   
}
{
    IFactory factory = new UndeadFactory();
    IRace race = factory.CreateRace();
}

这样看来一个实体业务类包了一层工厂，看似和直接创建业务类一致，其实不然，这样做不仅仅是屏蔽了对象的创建，还留下了扩展空间（以后有需要扩展的直接修改factory类，而外界不影响），完美的遵循了开闭原则(对扩展开放，对修改封闭)

B：.NET中工厂方法模式的实现

.NET 类库中也有很多实现了工厂方法的类，例如Asp.net中，处理程序对象是具体用来处理请求，当我们请求一个*.aspx的文件时，此时会映射到System.Web.UI.PageHandlerFactory类上进行处理，而对*.ashx的请求将映射到System.Web.UI.SimpleHandlerFactory类中（这两个类都是继承于IHttpHandlerFactory接口的），关于这点说明我们可以在“C:WindowsMicrosoft.NETFrameworkv4.0.30319ConfigWeb.Config”文件中找到相关定义，具体定义如下：

1 2 3 4 5

<httpHandlers> <add path="*.axd" verb="*" type="System.Web.HttpNotFoundHandler" validate="True" /> <add path="*.aspx" verb="*" type="System.Web.UI.PageHandlerFactory" validate="True" /> <add path="*.ashx" verb="*" type="System.Web.UI.SimpleHandlerFactory" validate="True" /> </httpHandlers>

 

5：抽象工厂

创建一组密不可分的对象，屏蔽对象的创建，约束强制保障产品簇，

A：抽象工厂创建的代码如下

/// <summary>
/// 一个工厂负责一些产品的创建
/// 产品簇
/// 单一职责就是创建完整的产品簇
/// 
/// 继承抽象类后，必须显式的override父类的抽象方法
/// </summary>
public abstract class FactoryAbstract
{
    public abstract IRace CreateRace();
    public abstract IArmy CreateArmy();
    public abstract IHero CreateHero();
    public abstract IResource CreateResource();

    //public abstract ILuck CreateLuck();
}

/// <summary>
/// 一个工厂负责一些产品的创建
/// </summary>
public class HumanFactory : FactoryAbstract
{
    public override IRace CreateRace()
    {
        return new Human();
    }

    public override IArmy CreateArmy()
    {
        return new HumanArmy();
    }
    public override IHero CreateHero()
    {
        return new HumanHero();
    }
    public override IResource CreateResource()
    {
        return new HumanResource();
    }
}
/// <summary>
/// 一个工厂负责一些产品的创建
/// </summary>
public class ORCFactory : FactoryAbstract
{
    public override IRace CreateRace()
    {
        return new ORC();
    }

    public override IArmy CreateArmy()
    {
        return new ORCArmy();
    }
    public override IHero CreateHero()
    {
        return new ORCHero();
    }
    public override IResource CreateResource()
    {
        return new ORCResource();
    }
}
/// <summary>
/// 一个工厂负责一些产品的创建
/// </summary>
public class UndeadFactory : FactoryAbstract
{
    public override IRace CreateRace()
    {
        return new Undead();
    }
    public override IArmy CreateArmy()
    {
        return new UndeadArmy();
    }
    public override IHero CreateHero()
    {
        return new UndeadHero();
    }
    public override IResource CreateResource()
    {
        return new UndeadResource();
    }
}

抽象工厂对扩展种族比较省事，直接继承抽象类，然后即可，但是如果想要在抽象类中扩展一个新的对象，则会影响到所有的子类，它也被称为倾斜的可扩展性设计

B：.NET中抽象工厂模式的实现

其中我们用到的操作数据库类DbProviderFactory就是一个抽象工厂

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

/// 扮演抽象工厂的角色 /// 创建连接数据库时所需要的对象集合， /// 这个对象集合包括有 DbConnection对象（这个是抽象产品类,如绝味例子中的YaBo类）、DbCommand类、DbDataAdapter类，针对不同的具体工厂都需要实现该抽象类中方法， public abstract class DbProviderFactory {     // 提供了创建具体产品的接口方法     protected DbProviderFactory();     public virtual DbCommand CreateCommand();     public virtual DbCommandBuilder CreateCommandBuilder();     public virtual DbConnection CreateConnection();     public virtual DbConnectionStringBuilder CreateConnectionStringBuilder();     public virtual DbDataAdapter CreateDataAdapter();     public virtual DbDataSourceEnumerator CreateDataSourceEnumerator();     public virtual DbParameter CreateParameter();     public virtual CodeAccessPermission CreatePermission(PermissionState state); }

 6：建造者模式

这个主要针对于一些复杂的工厂方法来说的！

 

二：结构性设计模式

结构性设计模式总共包含七种，分别为【适配器设计模式】【代理模式】【装饰器模式】【组合模式】【享元模式】【外观模式】【桥接模式】，他们主要实现的核心是：使用组合包一层，然后增加功能，但是多种结构型模式为何又不相同，是因为他们解决不同的问题，然后有不同的侧重点，也有不同的规范！

下面主要介绍一下适配器设计模式，代理模式，装饰器模式 三种

1：适配器设计模式

主要的功能就是字面上面的意思，做适配转接的功能，他主要分为类适配器模式（继承） 和对象适配器模式（组合），一般组合是优于继承的，通过代码我们来加以说明！

我们先定义一个接口

 /// <summary>
 /// 数据访问接口
 /// </summary>
 public interface IHelper
 {
     void Add<T>();
     void Delete<T>();
     void Update<T>();
     void Query<T>();
 }

然后下面的类分别要实现这个接口

public class SqlserverHelper : IHelper
{
    public void Add<T>()
    {
        Console.WriteLine("This is {0} Add", this.GetType().Name);
    }
    public void Delete<T>()
    {
        Console.WriteLine("This is {0} Delete", this.GetType().Name);
    }
    public void Update<T>()
    {
        Console.WriteLine("This is {0} Update", this.GetType().Name);
    }
    public void Query<T>()
    {
        Console.WriteLine("This is {0} Query", this.GetType().Name);
    }
}

public class MysqlHelper : IHelper
{
    public void Add<T>()
    {
        Console.WriteLine("This is {0} Add", this.GetType().Name);
    }
    public void Delete<T>()
    {
        Console.WriteLine("This is {0} Delete", this.GetType().Name);
    }
    public void Update<T>()
    {
        Console.WriteLine("This is {0} Update", this.GetType().Name);
    }
    public void Query<T>()
    {
        Console.WriteLine("This is {0} Query", this.GetType().Name);
    }
}

然后我们调用的时候如下：

Console.WriteLine("*****************************");
{
    IHelper helper = new SqlserverHelper();
    helper.Add<Program>();
    helper.Delete<Program>();
    helper.Update<Program>();
    helper.Query<Program>();
}
Console.WriteLine("*****************************");
{
    IHelper helper = new MysqlHelper();
    helper.Add<Program>();
    helper.Delete<Program>();
    helper.Update<Program>();
    helper.Query<Program>();
}

程序已经确定好了规范都要实现IHelper，所以我们都可以使用IHelper来接收，但是现在我们新增一个RedisHelper第三方的接口如下：

/// <summary>
/// 第三方提供的  openstack  servicestack
/// 不能修改
/// </summary>
public class RedisHelper
{
    public RedisHelper()
    {
        Console.WriteLine($"构造RedisHelper");
    }
    public void AddRedis<T>()
    {
        Console.WriteLine("This is {0} Add", this.GetType().Name);
    }
    public void DeleteRedis<T>()
    {
        Console.WriteLine("This is {0} Delete", this.GetType().Name);
    }
    public void UpdateRedis<T>()
    {
        Console.WriteLine("This is {0} Update", this.GetType().Name);
    }
    public void QueryRedis<T>()
    {
        Console.WriteLine("This is {0} Query", this.GetType().Name);
    }
}

然后我们也想通过上面的方式调用，即用IHelper来接收，如果是直接 IHelper helper = new RedisHelper();这样是不被允许的，因为他们之间没有父子关系，所以我们现在要增加中间类，来转换一下，让RedisHelper适应于IHelper，可以通过以下两种方式改善

第一种通过继承的方式来改善，新增类如下：

public class RedisHelperInherit : RedisHelper, IHelper
{
    public RedisHelperInherit()
    {
        Console.WriteLine($"构造{this.GetType().Name}");
    }

    public void Add<T>()
    {
        base.AddRedis<T>();
    }

    public void Delete<T>()
    {
        base.DeleteRedis<T>();
    }

    public void Query<T>()
    {
        base.QueryRedis<T>();
    }

    public void Update<T>()
    {
        base.UpdateRedis<T>();
    }
}

第二种通过组合（分为属性注入，构造函数注入，方法注入三种方式）的方式来改善，新增类如下：

public class RedisHelperObject : IHelper
    {
        public RedisHelperObject()
        {
            Console.WriteLine($"构造{this.GetType().Name}");
        }
        //属性注入 声明写死
        private RedisHelper _RedisHelper = new RedisHelper();

        ////构造函数 可以替换(需要抽象) 
        public RedisHelperObject(RedisHelper redisHelper)
        {
            this._RedisHelper = redisHelper;
        }

        ////方法注入 可以替换(需要抽象)
        public void SetObject(RedisHelper redisHelper)
        {
            this._RedisHelper = redisHelper;
        }

        public void Add<T>()
        {
            this._RedisHelper.AddRedis<T>();
        }

        public void Delete<T>()
        {
            this._RedisHelper.DeleteRedis<T>();
        }

        public void Query<T>()
        {
            this._RedisHelper.QueryRedis<T>();
        }

        public void Update<T>()
        {
            this._RedisHelper.UpdateRedis<T>();
        }
    }

这样的两种方式改善代码后，然后可以通过下面调用：

 //继承 既满足现有的规范调用，又没有修改RedisHelper  
 //类适配器模式
 Console.WriteLine("*****************************");
 {
     IHelper helper = new RedisHelperInherit();
     helper.Add<Program>();
     helper.Delete<Program>();
     helper.Update<Program>();
     helper.Query<Program>();
 }
 //组合 既满足现有的规范调用，又没有修改RedisHelper 
 //对象适配器
 Console.WriteLine("*****************************");
 {
     IHelper helper = new RedisHelperObject();
     helper.Add<Program>();
     helper.Delete<Program>();
     helper.Update<Program>();
     helper.Query<Program>();
 }

A：我们上面说了组合是优于继承的，具体分为以下两点来解释

1：侵入性：二者都会先构造一个redishelper，继承是强侵入的，父类的东西子类必须有
2：灵活性：继承只为一个类服务，结构可以为多个类型服务（属性注入，构造函数注入，方法注入 三种）

B：适配器主要是解决重构的问题，新东西和旧系统不吻合，通过继承/组合进行适配

2：代理模式

 通过代理业务类去完成对真实业务类的调用，代理类不能扩展业务功能，比如我们常见的代理如：翻墙代理，火车票代理，VPN代理

下面我们还是通过代码来解释何为代理，比如我们现在有个实际业务的接口如下：

/// <summary>
/// 业务接口
/// </summary>
public interface ISubject
{
    /// <summary>
    /// get
    /// </summary>
    /// <returns></returns>
    bool GetSomething();

    /// <summary>
    /// do
    /// </summary>
    void DoSomething();
}

然后我们有个实际的业务实现类如下：

/// <summary>
/// 一个耗时耗资源的对象方法
/// </summary>
public class RealSubject : ISubject
{
    public RealSubject()
    {
        Thread.Sleep(2000);
        long lResult = 0;
        for (int i = 0; i < 100000000; i++)
        {
            lResult += i;
        }
        Console.WriteLine("RealSubject被构造。。。");
    }

    /// <summary>
    /// 火车站查询火车票
    /// </summary>
    public bool GetSomething()
    {
        Console.WriteLine("坐车去火车站看看余票信息。。。");
        Thread.Sleep(3000);
        Console.WriteLine("到火车站，看到是有票的");
        return true;
    }

    /// <summary>
    /// 火车站买票
    /// </summary>
    public void DoSomething()
    {
        Console.WriteLine("开始排队。。。");
        Thread.Sleep(2000);
        Console.WriteLine("终于买到票了。。。");
    }
}

我们应用的时候不直接访问这个这个实际业务，而是可以通过访问代理来实现这个业务，下面我们可以增加一个代理类如下：

public class ProxySubject : ISubject
{
    //组合一下
    private static ISubject _Subject = new RealSubject();
    public void DoSomething()
    {
        try
        {
            Console.WriteLine("prepare DoSomething...");
            _Subject.DoSomething();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            throw ex;
        }
    }

    private static Dictionary<string, bool> ProxyDictionary = new Dictionary<string, bool>();
    public bool GetSomething()
        {
            try
            {
                Console.WriteLine("prepare GetSomething...");
                string key = "Proxy_GetSomething";
                bool bResult = false;
                if (!ProxyDictionary.ContainsKey(key))
                {
                    bResult = _Subject.GetSomething();
                    ProxyDictionary.Add(key, bResult);
                }
                else
                {
                    bResult = ProxyDictionary[key];
                }
                return bResult;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                throw ex;
            }
        }
}

这个类中通过属性注入的方式来实现对真实业务类的调用，然后我们可以通过下面的方式来调用

 {
     Console.WriteLine("***********Proxy**************");
     ISubject subject = new ProxySubject();
     subject.GetSomething();
     //subject.DoSomething();
 }

然后写到这里会有很多人，为啥不直接调用真实的业务类，而非得要使用代理调用呢？这个问题我们接下来来讨论一下：

比如我们买火车票，我们可以直接去火车站买火车票，但是如果火车站离我们住的地方比较远，过去不方便，然后周围又有代售点，那我们是不是多一种选择，既可以去火车站又可以直接去代售点买呢，其实我们写代理类也类似于这个道理，有时候我们需要增加一些自己的需求，比如增加个日志，增加个异常处理，然后又想提升一下性能，这些完全都可以再ProxySubject中做，而不需要去修改实际业务类。

通过代理，能够为对象扩展功能(不是增加业务)而不去修改原始业务类，也就是包了一层，这就是代理要做的事情！

3：装饰器模式 

装饰器模式是结构型设计模式巅峰之作，主要是通过组合+继承来完成的！

她主要实现的是每个类都可以定制自己的特殊功能，并且功能的顺序可以随意切换，是不是感觉很稀奇怎么实现的！

接下来我们还是以代码来加以理解说明，我们首先有一个抽象学生类

public abstract class AbstractStudent
{
    public int Id { get; set; }
    public string Name { get; set; }

    public abstract void Study();
}

然后我们有两个具体的学生类，一个普通的学生类，一个是VIP学生类，两个实体类分别继承抽象学生类如下：

 /// <summary>
 /// 一个普通的公开课学员,学习公开课
 /// </summary>
 public class StudentFree : AbstractStudent
 {
     public override void Study()
     {
         //Console.WriteLine("上课前要预习");

         Console.WriteLine("{0} is a free student studying .net Free", base.Name);
     }
 }

/// <summary>
/// 一个普通的vip学员,学习vip课程
/// </summary>
public class StudentVip : AbstractStudent
{
    /// <summary>
    /// 付费  上课前要预习   
    /// 上课学习
    /// </summary>
    public override void Study()
    {
        Console.WriteLine("{0} is a vip student studying .net Vip", base.Name);
    }
}

接着我们定义一个装饰器的基类如下：

/// <summary>
/// 继承+组合
/// 装饰器的基类
/// 也是一个学员，继承了抽象类
/// </summary>
public class BaseStudentDecorator : AbstractStudent
{
    private AbstractStudent _Student = null;//用了组合加override
    public BaseStudentDecorator(AbstractStudent student)
    {
        this._Student = student;
    }

    public override void Study()
    {
        this._Student.Study();
    }
}

然后有的学生要付费，有的学生要做作业，有的学生要视频回放，针对于上面三个功能，我们直接定义三个类，分别如下：

 /// <summary>
 /// 父类是BaseStudentDecorator，爷爷类AbstractStudent
 /// </summary>
 public class StudentVideoDecorator : BaseStudentDecorator
 {
     public StudentVideoDecorator(AbstractStudent student)
         : base(student)//表示父类的构造函数
     {
     }
     public override void Study()
     {
         base.Study();
         Console.WriteLine("视频代码回看");
     }
 }

 /// <summary>
 /// 父类是BaseStudentDecorator，爷爷类AbstractStudent
 /// </summary>
 public class StudentHomeworkDecorator : BaseStudentDecorator
 {
     public StudentHomeworkDecorator(AbstractStudent student)
         : base(student)//表示父类的构造函数
     {

     }

     public override void Study()
     {
         base.Study();

         Console.WriteLine("巩固练习");
        
     }
 }

/// <summary>
/// 父类是BaseStudentDecorator，爷爷类AbstractStudent
/// </summary>
public class StudentPayDecorator : BaseStudentDecorator
{
    public StudentPayDecorator(AbstractStudent student)
        : base(student)//表示父类的构造函数
    {

    }

    public override void Study()
    {
        Console.WriteLine("付费");
        base.Study();
    }
}

接下来我们就可以调用了，我们先定义一个学生类

AbstractStudent student = new StudentVip()
{
    Id = 666,
    Name = "加菲猫"
};

然后我们定义一个基础的装饰器类：

BaseStudentDecorator decorator = new BaseStudentDecorator(student);

通过里氏替换原则可以转换为如下：

AbstractStudent decorator = new BaseStudentDecorator(student);//里氏替换

走到这一步我们发现decorator和student的类型一致，于是我们把decorator换成student，于是变成了

student = new BaseStudentDecorator(student);//引用替换一下

然后可以student.Study(); 由此我们整个装饰器完成了！

下面奉上具体的调用代码

 AbstractStudent student = new StudentVip()
 {
     Id = 666,
     Name = "加菲猫"
 };
 student.Study();
 //BaseStudentDecorator decorator = new BaseStudentDecorator(student);
 //AbstractStudent decorator = new BaseStudentDecorator(student);//里氏替换
 student = new BaseStudentDecorator(student);//引用替换一下
 student = new StudentHomeworkDecorator(student);
 student = new StudentVideoDecorator(student);
 student.Study();

输出的内容如下：

下面进行补充代码说明一下：

 public class A
 {
     public virtual void Show()
     {
         Console.WriteLine("A的show");
     }
 }
 public class B : A
 {
     public override void Show()
     {
         Console.WriteLine("B的show-ing");
         base.Show();
         Console.WriteLine("B的show-end");
     }
 }
 public class C : B
 {
     public override void Show()
     {
         Console.WriteLine("C的show-ing");
         base.Show();
         Console.WriteLine("C的show-end");
     }
 }

运行结果为如下：

三：行为型设计模式

行为型设计模式，主要关注对象和行为的分离，把不稳定的地方移出去，自己只写稳定的，能保证自身的稳定，一共有11种模式，分别为：【模版方法模式】【策略模式】【状态模式】【命令模式】【迭代器模式】【备忘录模式】【观察者模式】【中介者模式】【访问者模式】【责任链模式】【解释器模式】

下面我们注重讲一下模板方法模式，观察者模式和责任链模式三种

 

1：模板方法模式

模板方法模式：就是指在基类父类定义流程，把可变逻辑分离到不同子类实现，下面我们以一个业务场景来诠释一下何为模板方法模式，请看下面的业务场景：

比如我们一银行客户端为例，然后用户可以登录，可以查询余额，可以计算利息，我们通过分析发现，用户登录，用户查询余额都是相同的，但是计算利息，和展示用户的信息有所不同，因为有的是定期有的活期，两者有所不同，所以我们先创建一个抽象类，

里面有抽象方法（每个客户端都有利率，但是都不一样），虚方法（部分客户端都是一样的，只是个别客户端不一样），普通的方法（每个客户端的功能都是一样的)如下：

/// <summary>
/// 银行客户端
/// </summary>
public abstract class AbstractClient
{
    public void Query(int id, string name, string password)
    {
        if (this.CheckUser(id, password))
        {
            double balance = this.QueryBalance(id);
            double interest = this.CalculateInterest(balance);
            this.Show(name, balance, interest);
        }
        else
        {
            Console.WriteLine("账户密码错误");
        }
    }

    public bool CheckUser(int id, string password)
    {
        return DateTime.Now < DateTime.Now.AddDays(1);
    }

    public double QueryBalance(int id)
    {
        return new Random().Next(10000, 1000000);
    }

    /// <summary>
    /// 活期  定期  利率不同
    /// </summary>
    /// <param name="balance"></param>
    /// <returns></returns>
    public abstract double CalculateInterest(double balance);

    public virtual void Show(string name, double balance, double interest)
    {
        Console.WriteLine("尊敬的{0}客户，你的账户余额为：{1}，利息为{2}",
            name, balance, interest);
    }       
}

然后我们声明两个子类，一个是活期用户，一个是定期用户，分别继承于上面的抽象类，代码如下：

/// <summary>
/// 银行客户端
/// </summary>
public class ClientVip : AbstractClient
{
    /// <summary>
    /// 活期  定期  利率不同
    /// </summary>
    /// <param name="balance"></param>
    /// <returns></returns>
    public override double CalculateInterest(double balance)
    {
        return balance * 0.005;
    }

    public override void Show(string name, double balance, double interest)
    {
        Console.WriteLine("尊贵的{0} vip客户，您的账户余额为：{1}，利息为{2}",
            name, balance, interest);
    }
}

 /// <summary>
 /// 银行客户端
 /// </summary>
 public class ClientRegular : AbstractClient
 {
     /// <summary>
     /// 活期  定期  利率不同
     /// </summary>
     /// <param name="balance"></param>
     /// <returns></returns>
     public override double CalculateInterest(double balance)
     {
         return balance * 0.003;
     }
 }

这样不同的业务可以直接在子类中实现，相同的业务可以在父类中实现，这就是所谓的模板模式，有没有发现我们平常基本上都是这样的写，然后只是不晓得它有如此一个高大上的名字而已！模板设计模式，好像就只是把一个复杂的多步骤业务，然后定义一个父类（模板），模板负责完成流程，把步骤分解，固定不变的类定义为父类，各不相同的定义为子类，就是把部分行为做了分离，所以有时候设计模式没有那么神奇，只不过是把常用的东西跟场景结合，沉淀下来起个名字。

 2：观察者模式

观察者模式：一个对象动作触发多个对象的行为，通过观察者可以去掉对象的依赖，支持各种自定义和扩展

比如我们经常会拿一只猫叫，来触发鸡飞狗跳，然后如果我们通常先定义一个接口：

/// <summary>
/// 只是为了把多个对象产生关系，方便保存和调用
/// 方法本身其实没用
/// </summary>
public interface IObserver
{
    void Action();
}

然后定一个多个实体分别继承于上面的接口，如下：

public class Chicken : IObserver
{
    public void Action()
    {
        this.Woo();
    }
    public void Woo()
    {
        Console.WriteLine("{0} Woo", this.GetType().Name);
    }
}
 public class Dog : IObserver
 {
     public void Action()
     {
         this.Wang();
     }
     public void Wang()
     {
         Console.WriteLine("{0} Wang", this.GetType().Name);
     }
 }
public class Baby : IObserver
{
    public void Action()
    {
        this.Cry();
    }

    public void Cry()
    {
        Console.WriteLine("{0} Cry", this.GetType().Name);
    }
}

然后定义一只猫如下：

 public class Cat
 {
     public void Miao()
     {
         Console.WriteLine("{0} Miao.....", this.GetType().Name);

         
         new Chicken().Woo();
         new Baby().Cry();             
         new Dog().Wang();            
     }
 }

这样写会触发猫的不稳定性，如果猫叫了一声，接着新增一种动作，那意味着要修改猫的miao的方法，也就是说猫不仅要瞄，还要触发各种动作，违背了单一职责，所以我们由此想到猫只管自己叫，然后具体其它的动作可以不可以甩锅给别人，所以我们将代码进行改版增加MiaoObserver和MiaoEvent如下：

public class Cat
{
    public void Miao()
    {
        Console.WriteLine("{0} Miao.....", this.GetType().Name);
        
        new Chicken().Woo();
        new Baby().Cry();           
        new Dog().Wang();          
    }
   
    private List<IObserver> _ObserverList = new List<IObserver>();
    public void AddObserver(IObserver observer)
    {
        this._ObserverList.Add(observer);
    }
    public void MiaoObserver()
        {
            Console.WriteLine("{0} MiaoObserver.....", this.GetType().Name);
            if (this._ObserverList != null && this._ObserverList.Count > 0)
            {
                foreach (var item in this._ObserverList)
                {
                    item.Action();
                }
            }
        }

    private event Action MiaoHandler;
    public void MiaoEvent()
        {
            Console.WriteLine("{0} MiaoEvent.....", this.GetType().Name);
            if (this.MiaoHandler != null)
            {
                foreach (Action item in this.MiaoHandler.GetInvocationList())
                {
                    item.Invoke();
                }
            }
        }
}

然后调用的地方如下：

 {
     Console.WriteLine("***************Common******************");
     Cat cat = new Cat();
     cat.Miao();
 }
 {
     Console.WriteLine("***************Observer******************");
     Cat cat = new Cat();                   
     cat.AddObserver(new Chicken());
     cat.AddObserver(new Baby());                  
     cat.AddObserver(new Dog());                   
     cat.MiaoObserver();
 }
 {
     Console.WriteLine("***************Observer******************");
     Cat cat = new Cat();
     cat.AddObserver(new Chicken());
     cat.AddObserver(new Baby());                    
     cat.AddObserver(new Dog());                   
     cat.MiaoObserver();
 }

以后增加动作只需要再调用端随时增加，顺序也随意修改，这样成功了保证了猫的稳定性的同时也实现了猫叫后触发了其它的动作！这就是所谓的观察者模式，把不稳定的地方移出去，自己只写稳定的，能保证自身的稳定！

3：责任链模式

责任链模式是：请求的处理流程，沿着链子顺序执行，还运行链子扩展和订制，这是行为型设计模式的巅峰之作！

我们还是从业务场景出发：请假流程的审批，比如请假时间少于等于8小时，则PM可以审批；请假时长大于8小时小于等于16小时的，部门主管审批；请假时长大于16小于等于32个小时，公司主管可以审批；如果我们看到这个业务流程，很多人第一反应是写下面的代码：

 if (context.Hour <= 8)
 {
     Console.WriteLine("PM审批通过");
 }
 else if (context.Hour <= 16)
 {
     Console.WriteLine("部门主管审批通过");
 }
else if (context.Hour <= 32)
 {
     Console.WriteLine("公司主管审批通过");
 }
 else
 {
     Console.WriteLine("************");
 }

把整个业务流程写到上端，一旦修改流程，直接修改代码。所以我们可以通过了解业务逻辑来进行分析，我们审批的人有PM，Charge，Manager，CEO四个人，然后审批者都有名字，都有审批的这个功能，另外我们还需要一个申请人ApplyContext，所以我们创建一个基类如下：

public abstract class AbstractAuditor
{
    public string Name { get; set; }
    public abstract void Audit(ApplyContext context);

    private AbstractAuditor _NextAuditor = null;
    public void SetNext(AbstractAuditor auditor)
    {
        this._NextAuditor = auditor;
    }
    protected void AuditNext(ApplyContext context)
    {
        if (this._NextAuditor != null)
        {
            this._NextAuditor.Audit(context);
        }
        else
        {
            context.AuditResult = false;
            context.AuditRemark = "不允许请假！";
        }
    }
}

然后创建PM，Charge，Manager，CEO如下：

public class PM : AbstractAuditor
{
    public override void Audit(ApplyContext context)
    {
        Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
        if (context.Hour <= 8)
        {
            context.AuditResult = true;
            context.AuditRemark = "允许请假！";
        }
        else
        {
            base.AuditNext(context);
        }
    }
}

public class Charge: AbstractAuditor
{
    public override void Audit(ApplyContext context)
    {
        Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
        if (context.Hour <= 16)
        {
            context.AuditResult = true;
            context.AuditRemark = "允许请假！";
        }
        else
        {
            base.AuditNext(context);
        }
    }
}

public class Manager : AbstractAuditor
{
    public override void Audit(ApplyContext context)
    {
        Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
        if (context.Hour <= 24)
        {
            context.AuditResult = true;
            context.AuditRemark = "允许请假！";
        }
        else
        {
            base.AuditNext(context);
        }
    }
}

然后进行调用，可以新增一个类组成链子形式的如下：

public class AuditorBuilder
{
    /// <summary>
    /// 那就反射+配置文件
    /// 链子的组成都可以通过配置文件
    /// </summary>
    /// <returns></returns>
    public static AbstractAuditor Build()
    {
        AbstractAuditor pm = new PM()
        {
            Name = "张琪琪"
        };
        AbstractAuditor charge = new Charge()
        {
            Name = "吴可可"
        };         
        AbstractAuditor ceo = new CEO()
        {
            Name = "加菲猫"
        };

        pm.SetNext(pm);
        charge.SetNext(charge);           
        ceo.SetNext(ceo);
        return pm;
    }
}

调用如下：

 ApplyContext context = new ApplyContext()
 {
     Id = 506,
     Name = "小新",
     Hour = 32,
     Description = "我周一要请假回家",
     AuditResult = false,
     AuditRemark = ""
 };

 AbstractAuditor auditor = AuditorBuilder.Build();
 auditor.Audit(context);
 if (!context.AuditResult)
 {
     Console.WriteLine("不干了！");
 }

上面就是所谓的责任链设计模式，如果整个流程审批人修改，不用修改底层逻辑，而是直接把调用的地方修改即可。

以上就是三大类设计模式中典型的设计模式，其实没有什么设计模式是完美无缺的，一个设计模式就是解决一类的问题的，通常设计模式在解决一类问题的同时，还会带来别的问题，我们设计者要做的事儿，就是要扬长避短，充分发挥长处！