经典文档-C#23种设计模式.docx

《经典文档-C#23种设计模式.docx》由会员分享，可在线阅读，更多相关《经典文档-C#23种设计模式.docx（260页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、c#23种设计模式China Document 4 Colors1.1 节工期How are you1.1.1 完成日期1.2 节创建型模式1.21 单件模式(Singleton Pattern)动机(Motivation):在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性、以及良好的效率。如何绕过常规的构造器，提供一种机制来保证一个类只创建一个实例？这应该是类设计者的责任，而不是类使用者的责任。结构图：return untquelnsianceSingletonstatic InstanceO o- SingletonOperatkn() G

2、etSingletonData()static uniqueinstance singletonDala意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。305生活的例子：2T n-i j/i适用性：(1)当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。(2)当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。代码实现：(1)单线程Singleton实现class SingleThread_Singletonprivate static SingleThread_Singleton instance = null;private S

3、ingleThread_Singleton()public static SingleThread_Singleton Instance( get (if (instance = null)(instance = new SingleThread_Singleton(); return instance;)1)以上代码在单线程情况下不会出现任何问题。但是在多线程的情况下却不是安全的。如两个线程同时运行到if (instance = null)判断是否被实例化，一个线程判断为True后,在进行创建instance = new SingleThread_Singleton();之前，另一个线程也判

4、断(instance = null),结果也为 True.这样就就违背了 Singleton模式的原则(保证一个类仅有一个实例)。怎样在多线程情况下实现Singleton?(2)多线程Singleton实现：1 class MultiThread_Singleton2 (3 private static volatile MultiThread_Singleton instance = null;4 private static object lockHelper = new object();5 private MultiThread_Singleton()6 public static M

5、ultiThread_Singleton Instance7 (8 get9 10 if (instance = null)11 12 lock (lockHelper)13 14 if(instance=null)15 16 instance = new MultiThread_Singleton();17 )18 )19 )20 returninstance;21 22 )23此程序对多线程是安全的，使用了一个辅助对象lockHelper,保证只有一个线程创建实例(如果 instance 为空，保证只有一个线程 instance = new MultiThread_Singleton();

6、创建唯一的一个实例)。(Double Check)请注意一个关键字volatile,如果去掉这个关键字，还是有可能发生线程不是安全的。volatile保证严格意义的多线程编译器在代码编译时对指令不进行微调。(3)静态Singleton实现3 class Static_Singleton4 (5 publicstatic readonly Static_Singleton instance = new Static_Singleton();6 private Static_Singleton()aConcreteBuilder pBuiWPar1A(yBuiUPadBODuildParlCOGe

7、tResultOT协作(Collaborations):aClientaDirectorXJnew ConcreteBuilder i阳w Oreclor(aConcreleBulder)ConstrucK)生活中的例子:适用性：1 .当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。2 .当构造过程必须允许被构造的对象有不同的表示时。实例代码：Builder 类：1 public abstract class Builder2 (3 publicabstractvoidBuildDoor();4 publicabstractvoidBuildWall();5 publica

8、bstractvoidBuildWindows();6 publicabstractvoidBuildFloor();7 publicabstractvoidBuildHouseCeiling();89 public abstract House GetHouse();10 )Director类：这一部分是组合到一起的算法(相对稳定)。1 public class Director2 3 public void Construct(Builder builder)4 (5 builder.BuildWall();6 builder.BuildHouseCeiling();7 builder.B

9、uildDoor();8 builder.BuildWindows();9 builder.BuildRoor();10 )11 ChineseBuilder 类1 public class ChineseBuilder:Builder2 (3 private House ChineseHouse = new House();4 public override void BuildDoor()Con sole. WriteLine(this Door *s style of Chinese);7 8 publicoverride void BuildWall()9 10 Console.Wri

10、teLine(this Walls style of Chinese);11 )12 publicoverride void BuildWindows()13 14 Console.WriteLine(nthis Windowss style of Chinese);15 )16 publicoverridevoidBuildFloor()17 18 Console.WriteLine(this Floors style of Chinese*);19 )20 publicoverridevoidBuildHouseCeiling()21 22 Console.WriteLine(this C

11、eiling *s style of Chinese);23 )24 public override House GetHouse()25 26 return ChineseHouse;27 )28 )RomanBuilder 类：1 class RomanBuilder:Builder2 (private House RomanHouse = new House();4 publicoverridevoidBuildDoor()5 6 Con sole. WriteLine(nthis Doors style of Roman);7 8 publicoverridevoidBuildWall

12、()9 10 Consol e.WriteLine(this Walls style of Rom anH);12 public override void BuildWindows()13 14 Console.WriteLine(this Windowss style of Roman);15 )16 public override voidBuildRoor()17 18 Console.WriteLine(Hthis Floors style of Roman*);19 20 public override voidBuildHouseCeiling()21 22 Console.Wr

13、iteLine(nthis Ceiling *s style of Roman,);23 24 public override House GetHouse()25 26 return RomanHouse;27 )28 )ChineseBuilder和Roman Builder这两个是：这个复杂对象的两个部分经常面临着剧烈的变化。1 public class Client2 (3 public static void Main(string args)4 5 Director director = new Director();67 Builder instance;89 Console.W

14、riteLine(nRease Enter HouseNo:)；1011 string No = Console.ReadLine();1213 string houseType = ConfigurationSettings.AppSettingsfNo+ No;15instance =(Builder) Assem bly.Load(HouseH).Createl nstance(MHouse.+ houseType);1617 director.Construct(instance);1819House house= instance.GetHouse();20house.Show();

15、2122Console.ReadLinef);23)24)1 2 3 4 5 6 7 Builder模式的几个要点：Builder模式主要用于“分步骤构建个复杂的对象”。在这其中“分步骤”是一个稳定的乘法，而复杂对象的各个部分则经常变化。Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。Abstract Factory模式解决“系列对象的需求变化，Builder模式解决“对象部分”的需求变化。Builder械通常和Composite模式组合使用1.24工厂方法模式(Factory Method)耦合关系：耦合关系直接决定着软件面对

16、变化时的行为-模块与模块之间的紧耦合使得软件面对变化时，相关的模块都要随之更改-模块与模块之间的松耦合使得软件面对变化时，一些模块更容易被替换或者更改，但其他模块保持不变动机（Motivation）:在软件系统中，由于需求的变化，”这个对象的具体实现经常面临着剧烈的变化，但它却有比较稳定的接口。如何应对这种变化呢？提供一种封装机制来隔离出这个易变对象”的变化,从而保持系统中其它依赖的对象不随需求的变化而变化。意图（I ntent）:定义一个用户创建对象的接口，让子类决定实例哪一个类。Factory Method使一个类的实例化延迟到子类。设计模式GOF结构图（Struct）:生活实例:适用性：

17、1 .当一个类不知道它所必须创建的对象类的时候。2 .当一个类希望由它子类来指定它所创建对象的时候。个帮助子类是代3 .当类将创建对象的职责委托给多个帮助子类中的某个，并且你希望将哪理者这一信息局部化的时候。实例代码：CarFactory 类：1 public abstract class CarFactory2 (3 public abstract Car CarCreate();4 )Car 类：1 public abstract class Car2 3 public abstractvoidStartUp();4 public abstractvoidRun();5 public ab

18、stractvoidStop();67 )HongQi Car Factory 类：1 public class HongQiCarFactory:CarFactory3 publicoverride Car CarCreate()4 5 return new HongQiCar();6 )7 )BMWCarFactory 类：1 public class BMWCarFactory :CarFactory2 3 publicoverride Car CarCreate()4 (5 return new BMWCar();6 )7 HongQiCar 类:1 public class Hong

19、QiCar:Car2 3 publicoverridevoidStartUp()4 (Console.WriteLine(Test HongQiCar start-up speed!);6 7 publicoverridevoidRun()8 (9 Console.WriteLine(MThe HongQiCar run is very quickly!*);10 11 public override void Stop()12 13 Console.WriteLine(MThe slow stop time is 3 second M);14 )15 )BMWCar 类:1 public c

20、lass BMWCar:Car2 3 public override void StartUp()Console.WriteLine(The BMWCar start-up speed is very quickly,);6 )7 publicoverride void Run()8 (9 Console.WriteLine(The BMWCar run is quitely fast and safe!*);10 )11 public override void Stop()12 13 Console.WriteLine(HThe slow stop time is 2 second);14

21、 )15 ) app.config123456 7 Program 类：1 class Programstatic void Main(string args)Console.WriteLine(HPlease Enter Factory Method No:);Console.WriteLine(,*Con sole. WriteLine(HnoFactory Method);Con sole. WriteLine(H1HongQi CarFactory);Con sole. WriteLine(2BMWCarFactory);10Console.WriteLine(H* * * *);11

22、int no= Int32.Parse(Console.ReadLine().ToString();12string factoryType=ConfigurationManager.AppSettingsNon+ no;13/Car Factory factory = new HongQi Car Factory ();14CarFactory factory = (CarFactory)Assembly.Load(nFactoryMehtod).Createlnstance(FactoryMehtod.+ factoryType);15 Car car=factory.CarCreate(

23、);16 car.StartUp();17 car.Run();18 car.Stop();1920 21 )Factory Method模式的几个要点：Factory Method模式主要用于隔离类对象的使用杵和具体类型之间的耦介关系。而对个经常变化的具体类型，紧耦合关系会导致软件的脆弱。Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展(而非更改)的策略，较好地解决了这种紧耦合关系。Factory Mehtod模式解决单个对象的需求变化，AbstractFactory模式解决系列对象的需求变化，Builder模式解决“对象部分”的需求变

24、化1.25原型模式(Prototype)依赖关系倒置：抽象不应该依赖于实现细节，实现细节应该依赖于抽象。-抽象A直接依赖于实现细节b-抽象A依赖于抽象B,实现细节b依赖于抽象B动机(Motivate):在软件系统中，经常面临着“某些结构复杂的对象”的创建工作；由于需求的变化，这些对象经常面临着剧烈的变化，但是它们却拥有比较稳定一致的接口。如何应对这种变化？如何向“客户程序(使用这些对象的程序)隔离出“这些易变对象”，从而使得“依赖这些易变时象的客户程序”不随着需求改变而改变？意图(Intent):用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。设计模式GOF结构图(Struct

25、):生活例子:适用性:1 .当一个系统应该独立于它的产品创建，构成和表示时12341234567891234567892 .当要实例化的类是在运行时刻指定时，例如，通过动态装载;3 .为了避免创建一个与产品类层次平行的工厂类层次时;4 .当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。示意性代码例子:public abstract class NormalActor(public abstract NormalActor clone();)public class NormalActorA: NormalActor(p

26、ublic override NormalActor clone()|Console.WriteLine(HNormalActorA is call); return (NormalActor)this.MemberwiseClone();)public class NormalActorB : NormalActor(public override NormalActor clone()(Console.WriteLine(H Norm al ActorB was called); return (NormalActor)this.MemberwiseClone();public class

27、 GameSystempublic void Run(NormalActor normalActor)Norm al Actor normal Actorl = normalActor.clone();NormalActor normalActor2= normalActor.clone();NormalActor normalActor3= normalActor.clone();NormalActor normalActor4= normalActor.clone();NormalActor normalActor5= normalActor.clone();)classProgram(s

28、tatic void Main(string args)|GameSystem gameSystem = new GameSystem();gameSystem.Run(new NormalActorA();)如果又需要创建新的对象(flyActor),只需创建此抽象类，然后具体类进行克隆。public abstract class FlyActorpublic abstract FlyActor clone();)public class RyActorB: RyActor/浅拷贝，如果用深拷贝，可使用序列化Ill III public override FlyActor clone()re

29、turn (FlyActor)this.MemberwiseCIone();)此时，调用的Main()函数只需如下：classProgram(static void Main(string args)(GameSystem gameSystem = new GameSystem();gameSystem.Run(new NormalActorA(), new RyActorBO);Prototype的几个要点：Prototype模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些“易变类拥有稳定的接口”。Prototype模式对于“如何创建易变类的实体对象“采用“原

30、型克隆”的方法来做，它使得我们可以非常灵活地动态创建“拥有某些稳定接口中”的新对象一一所需工作仅仅是注册的地方不断地Clone.Prototype模式中的Clone方法可以利用.net中的object类的 memberwiseCloneQ方法或者序列化来实现深拷贝。有关创建型模式的讨论：Singleton模式解决的是实体对象个数的问题。除了 Singleton之外，其他创建型模式解决的是都是new所带来的耦合关系。Factory Method .Abstract Factory,Builder 都需要一个额外的工厂类来负责实例化“易变对象”，而Prototype则是通过原型(一个特殊的工厂类)

31、来克隆“易变对象”。如果遇到“易变类”，起初的设计通常从Factory Mehtod开始，当遇到更多的复杂变化时，再考虑重重构为其他三种工厂模式(AbstractFactory, Builder, Prototype)适配器模式(Adapter Pattern)适配(转换)的概念无处不在适配，即在不改变原有实现的基础上，将原先不兼容的接口转换为兼容的接口。例如：二转换为三箱插头，将高电压转换为低电压等。动机(Motivate):在软件系统中，由于应用环境的变化，常常需耍将“一些现存的对象”放在新的环境中应用，但是新环境要求的接口是这些现存对象所不满足的。那么如何应对这种“迁移的变化”？如何既能

32、利用现有对象的良好实现，同时又能满足新的应用环境所要求的接口？这就是本文要说的Adapter模式。意图(Intent):将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。设计模式GOF结构(Struct):图1:对象适配器Interface图2：类适配器生活中的例子:斡齿1/2,阳槽孔1/4阴槽适配器17彳曲槽1/4,阳槽适用性:1 .系统需要使用现有的类，而此类的接口不符合系统的需要。2 .想要建立个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。这些源类不一定有很复杂的接口。

33、3 .(对对象适配器而言)在设计里，需要改变多个己有子类的接口，如果使用类的适配器模式，就要针对每一个子类做一个适配器，而这不太实际。示意性代码实例：1 interface I Stack2 3 void Push(objectitem);4 void Pop();5 object Peek();6 )1 对象适配器(Adapter与Adaptee组合的关系)2 public class Adapter : I Stack 适配对象3 4 Ar ray Li st adaptee;被适配的对象5 public Adapter()6 7 adaptee = new ArrayList();8 )

34、9 public voidPush(object item)10 11 adaptee.Add(item);12 13public void Pop()14 15 adaptee.RemoveAt(adaptee.Count -1);16 17 public object Peek()18 19 return adapteeadaptee.Count -1;20 21 )类适配器1 public class Adapter : Array List, I Stack2 3 publicvoidPush(object item)4 5 this.Add(item);6 )7 publicvoid

35、Pop()8 9 this.RemoveAt(this.Count -1);10 )11 public object Peek()12 13 return thisthis.Count -1;14 )15 )Adapter模式的几个要点：Adapter模式主要应用于“希望第用一些现存的类，但是接口又与复用环境要求不一致的情况”，在遗留代码复用、类库迁移等方面非常有用。GOF23定义了两种Adapter模式的实现结构：对象适配器和类适配器。但类适配器采用“多继承”的实现方式，带来不良的高耦合，所以一般不推荐使用。对象适配器采用“对象组合”的方式，更符合松耦合精神。Adapter模式可以实现的非常

36、灵活，不必拘泥于GOF23中定义的两种结构。例如，完全可以将Adapter模式中的“现存对象”作为新的接口方法参数，来达到适配的目的。Adapter模式本身要求我们尽可能地使用”面向接口的编程”风格，这样才能在后期很方便的适配。.NET框架中的Adapter应用：(1)在.Net中复用com对象：Com对象不符合.net对象的接口使用 tlbimp. exe 来创建一个 Runtime Callable Wrapper (RCW)以使其符合.net 对象的接口。(2).NET数据访问类(Adapter变体)：各种数据库并没有提供DataSet接口使用DBDataAdapter可以将任何各数据库

37、访问/存取适配到一个DataSet对象上。(3)集合类中对现有对象的排序(Adapter变体)；现有对象未实现IComparable接口实现一个排序适配器(继承【Comparer接口)，然后在其Compare方法中对两个对象进行比较。桥接模式(Bridge Pattern)动机(Motivate):在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度的变化”？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化,而又不引入额外的复杂度？意图(Intent):将抽象部分与实现部分分离，使它们都可以独立的变化。设计模式GOF结构图(Struct):

38、生活中的例子：我想大家小时候都有用蜡笔画画的经历吧。红红绿绿的蜡笔一大盒，根据想象描绘出格式图样。而毛笔下的国画更是工笔写意，各展风采。而今天我们的故事从蜡笔与毛笔说起。设想要绘制一幅图画，蓝天、白云、绿树、小鸟，如果画面尺寸很大，那么用蜡笔绘制就会遇到点麻烦。毕竟细细的蜡笔要涂出一片蓝天，是有些麻烦。如果有可能，最好有套大号蜡笔，粗粗的蜡笔很快能涂抹完成。至于色彩吗，最好每种颜色来支粗的，除了蓝天还有绿地呢。这样,如果一套12种颜色的蜡笔，我们需要两套24支，同种颜色的一粗一细。呵呵，画还没画，开始做梦了：要是再有一套中号蜡笔就更好了，这样，不多不少总共36支蜡笔。再看看毛笔这一边，居然如此

39、简陋：一套水彩12色，外加大中小三支毛笔。你可别小瞧这简陋”的组合，画蓝天用大毛笔，画小鸟用小毛笔，各具特色。呵呵，您是不是已经看出来了，不错，我今天要说的就是Bridge模式。为了一幅画，我们需要准备36支型号不同的蜡笔，而改用毛笔三支就够了，当然还要搭配上12种颜料。通过 Bridge模式，我们把乘法运算3x 12=36改为了加法运算3+12=15,这一改进可不小。那么我们这里蜡笔和毛笔到底有什么区别呢？实际上，蜡笔和毛笔的关键一个区别就在于笔和颜色是否能够分离。GOF95】桥梁模式的用意是将抽象化(Abstraction)9实现化(Implementation)脱耦，使得二者可以独立地变

40、化关键就在于能否脱耦。蜡笔的颜色和蜡笔本身是分不开的，所以就造成必须使用36支色彩、大小各异的蜡笔来绘制图画。而毛笔与颜料能够很好的脱耦，各自独立变化，便简化了操作。在这里，抽象层面的概念是：毛笔用颜料作画，而在实现时，毛笔有大中小三号，颜料有红绿蓝等12种，于是便可出现3x 12种组合。每个参与者(毛笔与颜料)都可以在自己的自由度上随意转换。123456781234512345123412蜡笔由于无法将笔与颜色分离，造成笔与颜色两个自由度无法单独变化，使得只有创建36种对象才能完成任务。Bridge模式将继承关系转换为组合关系，从而降低了系统间的耦合，减少了代码编写量。代码实现:abstra

41、ct class Brushprotected Color c;public abstract void Paint();public void SetColor(Color c) this.c = c;class BigBrush : Brush(public override void Paint() Console.WriteLine(HUsing big brush and color 0 painting*, c.color);)class SmallBrush : Brush(public override void Paint() Console.WriteLine(Using

42、small brush and color 0 painting, c.color);class Color(public string color;3451234512345123456789101112131415161718public Red() this.color =,red,;class Green : Color(public Green() this.color =green;)class Blue : Color(public Blue() this.color =blue；)class Program(public static void Main()(Brush b = new BigBrush(); b.SetColor(new Red();b.Paintf);b.SetColor(new Blue。)； b.Paint();b.SetColor(new Green(); b.Paint();b = new SmallBrush(); b.SetColor(new Red(); b.Paint();b.SetColor(new Blue();b.Paint();b.SetColor(new Green();19 b.Paint(