.net之设计模式

在上一篇文章里我通过具体场景总结了“.net面向对象的设计原则”，其中也多次提到一些设计模式方面的技术，可想而知，设计模式在我们的开发过程中也是必不可少的。今天我们就来简单交流下设计模式。对于设计模式的介绍呢，网上流行这么一句话“想要搞好对象，必须要熟知套路”，所以百度中说设计模式简介时“设计模式一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结”一点也没错，在开发过程中通过渗入一些设计模式，我们的设计效果又会怎么样呢？话不多说，直接进入正题吧！

一、设计模式的分类

GOF一共总结了23套设计模式，大致可以分为以下三类：

• 创造型模式

这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活，该类型包括：单件模式、抽象工厂、建造者模式、工厂方法模式和原型模式等5种。

• 结构型模式

这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式，该类型包括：适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式和代理模式等7种。

• 行为型模式

这些设计模式特别关注对象之间的通信。分为职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法、访问者模式等11种。

二、设计模式解析

常用设计模式浅析：

1、单件模式

结构图 ：     

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

适用性 ：

• 当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
• 当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

示意性代码：

     //单件模式示意性代码
     public class Singleton
     {
         //创建私有对象，保证只有一个对象
         private static Singleton _instance;

         //保护类型的构造函数，子类化可扩展
         protected Singleton() { }

         //提供公共访问点
         public static Singleton Instance()
         {

             // 使用 'Lazy initialization'，为对象实例化
             if (_instance == null)
             {
                 _instance = new Singleton();
             }

             return _instance;
         }
       }

Singleton

特点总结：实例对外唯一、子类可以扩展并且提供 一个公共的访问点访问。

实际应用：

     /// <summary>
     /// 投票选举
     /// </summary>
     public class LoadBalancer
     {
         //实例唯一
         private static LoadBalancer instance;
         //选举人
         private ArrayList servers = new ArrayList();
         //随机数
         private Random random = new Random();
         //用于异步
         private static object syncLock = new object();
         //保护构造函数，创建时添加选举人
         protected LoadBalancer()
         {
             servers.Add("ServerI");
             servers.Add("ServerII");
             servers.Add("ServerIII");
             servers.Add("ServerIV");
             servers.Add("ServerV");
         }
         //公共访问点，初始化投票对象
         public static LoadBalancer GetLoadBalancer()
         {
             if (instance == null)
             {
                 lock (syncLock)
                 {
                     if (instance == null)
                     {
                         instance = new LoadBalancer();
                     }
                 }
             }

             return instance;
         }
         public string Server
         {
             get
             {
                 int r = random.Next(servers.Count);
                 return servers[r].ToString();
             }
         }
      }

LoadBalancer

   public class SingletonMain
     {
         static void Main()
         {
             LoadBalancer b1 = LoadBalancer.GetLoadBalancer();
             LoadBalancer b2 = LoadBalancer.GetLoadBalancer();
             LoadBalancer b3 = LoadBalancer.GetLoadBalancer();
             LoadBalancer b4 = LoadBalancer.GetLoadBalancer();

             if (b1 == b2 && b2 == b3 && b3 == b4)
             {
                 Console.WriteLine("Same instance\n");
             }

             // Load balance 15 server requests
             for (int i = ; i < ; i++)
             {
                 Console.WriteLine(b1.Server);
             }

             Console.ReadKey();
         }
     }

SingletonMain

2、抽象工厂

结构图：

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

适用性 ：

• 个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时

示意性代码：

     public abstract class AbstractFactory
     {
         public abstract AbstractProductA CreateProductA();
         public abstract AbstractProductB CreateProductB();
     }
     public abstract class AbstractProductA { }
     public abstract class AbstractProductB
     {
         public abstract void Interact(AbstractProductA a);
     }
     public class ConcreteFactory1 : AbstractFactory
     {
         public override AbstractProductA CreateProductA()
         {
             return new ProductA1();
         }
         public override AbstractProductB CreateProductB()
         {
             return new ProductB1();
         }
     }
      public class ConcreteFactory2 : AbstractFactory
      {
         public override AbstractProductA CreateProductA()
         {
             return new ProductA2();
         }
         public override AbstractProductB CreateProductB()
         {
             return new ProductB2();
         }
      }
      public  class ProductA1 : AbstractProductA { }
      public class ProductA2 : AbstractProductA { }
      public class ProductB1 : AbstractProductB
      {
         public override void Interact(AbstractProductA a)
         {
             Console.WriteLine(this.GetType().Name + " interacts with " +
             a.GetType().Name);
         }
      }
       public class ProductB2 : AbstractProductB
      {
         public override void Interact(AbstractProductA a)
         {
             Console.WriteLine(this.GetType().Name + " interacts with " +
             a.GetType().Name);
         }
      }

AbstractFactory

    public class Client
     {
         private AbstractProductA _abstractProductA;
         private AbstractProductB _abstractProductB;

         // Constructor
         public Client(AbstractFactory factory)
         {
             _abstractProductB = factory.CreateProductB();
             _abstractProductA = factory.CreateProductA();
         }

         public void Run() => _abstractProductB.Interact(_abstractProductA);
     }

Client

    class AbstractFactoryMain
     {
         public static void Main()
         {
             // Abstract factory #1
             AbstractFactory factory1 = new ConcreteFactory1();
             Client c1 = new Client(factory1);
             c1.Run();

             // Abstract factory #2
             AbstractFactory factory2 = new ConcreteFactory2();
             Client c2 = new Client(factory2);
             c2.Run();

             Console.ReadKey();
         }
     }

AbstractFactoryMain

特点总结：抽象，多态，一系列相关关联。

3、代理模式

结构图：

意图：为其他对象提供一种代理以控制对这个对象的访问。

适用性 ：

• 在需要用比较通用和复杂的对象指针代替简单的指针的时候，使用 Proxy 模式。

示意性代码：

    public abstract class Subject
     {
         public abstract void Request();
     }

      public class RealSubject : Subject
     {
         public override void Request()
         {
             Console.WriteLine("Called RealSubject.Request()");
         }
     }

     public class Proxy : Subject
     {
         RealSubject realSubject;

         public override void Request()
         {
             // Use 'lazy initialization'
             if (realSubject == null)
             {
                 realSubject = new RealSubject();
             }

             realSubject.Request();
         }
     }

Proxy

实际应用：

     /// <summary>
     /// Subject接口
     /// </summary>
     public interface IMath
     {
         //加法操作
         double Add(double x, double y);
         //减法操作
         double Sub(double x, double y);
         //乘法操作
         double Mul(double x, double y);
         //除法操作
         double Div(double x, double y);
      }

     /// <summary>
     /// 具体实现类
     /// </summary>
     public class Math : IMath
     {
         public double Add(double x, double y)
         {
             return x + y;
         }
         public double Sub(double x, double y)
         {
             return x - y;
         }
         public double Mul(double x, double y)
         {
             return x * y;
         }
         public double Div(double x, double y)
         {
             return x / y;
         }
      }
     /// <summary>
     /// 代理类
     /// </summary>
     public class MathProxy : IMath
     {
         Math math;
         public MathProxy() { math = new Math(); }

         public double Add(double x, double y) { return math.Add(x, y); }
         public double Sub(double x, double y) { return math.Sub(x, y); }
         public double Mul(double x, double y) { return math.Mul(x, y); }
         public double Div(double x, double y) { return math.Div(x, y); }
     }

MathProxy

4、观察者模式

结构图：

意图：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

适用性 ：

• 当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用

• 当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。

• 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

示意性代码：

     /// <summary>
     /// 操作抽象类
     /// </summary>
     public abstract class Subject
     {
         //观察者数组
         private ArrayList observers = new ArrayList();
         //添加观察者
         public void Attach(Observer observer) => observers.Add(observer);
         //删除观察者
         public void Detach(Observer observer) => observers.Remove(observer);
         //通知观察者们
         public void Notify()
         {
             foreach (Observer o in observers)
             {
                 o.Update();
             }
         }
     }
     /// <summary>
     /// 具体操作类
     /// </summary>
     public class ConcreteSubject : Subject
     {
         // Property
         public string SubjectState { get; set; }
     }
     /// <summary>
     /// 观察者类
     /// </summary>
     public abstract class Observer
     {
         //更新
         public abstract void Update();
     }

     /// <summary>
     /// 具体的观察者
     /// </summary>
     public class ConcreteObserver : Observer
     {
         private string name;
         private string observerState;

         // Constructor
         public ConcreteObserver(ConcreteSubject subject, string name)
         {
             this.Subject = subject;
             this.name = name;
         }

         public override void Update()
         {
             observerState = Subject.SubjectState;
             Console.WriteLine("Observer {0}'s new state is {1}", name,
                  observerState);
         }

         // Property
         public ConcreteSubject Subject { get; set; }
     }

Observer

   实际应用：

     /// <summary>
     /// 拍卖类
     /// </summary>
     public abstract class Stock
     {
         protected string symbol;
         protected double price;
         private ArrayList investors = new ArrayList();

         public Stock(string symbol, double price)
         {
             this.symbol = symbol;
             this.price = price;
         }

         public void Attach(Investor investor)
         {
             investors.Add(investor);
         }
         public void Detach(Investor investor)
         {
             investors.Remove(investor);
         }

         public void Notify()
         {
             foreach (Investor investor in investors)
             {
                 investor.Update(this);
             }
             Console.WriteLine("");
         }

         // Properties
         public double Price
         {
             get
             {
                 return price;
             }
             set
             {
                 price = value;
                 Notify();
             }
         }

         public string Symbol
         {
             get
             {
                 return symbol;
             }
             set
             {
                 symbol = value;
             }
         }
      }
      /// <summary>
      /// IBM拍卖
      /// </summary>
      public class IBM : Stock
      {
         public IBM(string symbol, double price) : base(symbol, price)
         {
         }
      }
     /// <summary>
     /// 投资商接口
     /// </summary>
     interface IInvestor { void Update(Stock stock); }
      /// <summary>
      /// 投资商
      /// </summary>
     public  class Investor : IInvestor
     {
         private string name; private Stock stock;

         public Investor(string name)
         {
             this.name = name;
         }

         public void Update(Stock stock)
         {
             Console.WriteLine("Notified {0} of {1}'s " + "change to {2:C}", name,
                     stock.Symbol, stock.Price);
         }

         public Stock Stock
         {
             get { return stock; }
             set { stock = value; }
         }
     }

ObserverExample

特点总结：抽象，依赖，一个方面依赖于另一方面。

好了，今天就总结到这里了欢迎纠错，谢谢！！！