适配器模式(Adapter Pattern)

淩亂°似流年 2022-04-13 12:48 166阅读 0赞

[设计模式 - 吕震宇][-]

[.NET设计模式系列文章][.NET]

[薛敬明的专栏][Link 1]

[乐在其中设计模式(C\#)][C]

# [C\#设计模式（10）－Adapter Pattern][C_10_Adapter Pattern] #

结构模式（Structural Pattern）描述如何将类或者对象结合在一起形成更大的结构。结构模式描述两种不同的东西：类与类的实例。根据这一点，结构模式可以分为类的结构模式和对象的结构模式。

后续内容将包括以下结构模式：

*  适配器模式（Adapter）：Match interfaces of different classes
 *  合成模式（Composite）：A tree structure of simple and composite objects
 *  装饰模式（Decorator）：Add responsibilities to objects dynamically
 *  代理模式（Proxy）：An object representing another object
 *  享元模式（Flyweight）：A fine-grained instance used for efficient sharing
 *  门面模式（Facade）：A single class that represents an entire subsystem
 *  桥梁模式（Bridge）：Separates an object interface from its implementation

##    一、 适配器（Adapter）模式 ##

适配器模式把一个类的接口变换成客户端所期待的另一种接口，从而使原本接口不匹配而无法在一起工作的两个类能够在一起工作。

**名称由来**

这很像变压器（Adapter），变压器把一种电压变换成另一种电压。美国的生活用电电压是110V，而中国的电压是220V。如果要在中国使用美国电器，就必须有一个能把220V电压转换成110V电压的变压器。这个变压器就是一个Adapter。

Adapter模式也很像货物的包装过程：被包装的货物的真实样子被包装所掩盖和改变，因此有人把这种模式叫做包装（Wrapper）模式。事实上，大家经常写很多这样的Wrapper类，把已有的一些类包装起来，使之有能满足需要的接口。

**适配器模式的两种形式**

适配器模式有类的适配器模式和对象的适配器模式两种。我们将分别讨论这两种Adapter模式。

##    二、 类的Adapter模式的结构： ##

![Pic57.gif][]

由图中可以看出，Adaptee类没有Request方法，而客户期待这个方法。为了使客户能够使用Adaptee类，提供一个中间环节，即类Adapter类，Adapter类实现了Target接口，并继承自Adaptee，Adapter类的Request方法重新封装了Adaptee的SpecificRequest方法，实现了适配的目的。

因为Adapter与Adaptee是继承的关系，所以这决定了这个适配器模式是类的。

该适配器模式所涉及的角色包括：

目标（Target）角色：这是客户所期待的接口。因为C\#不支持多继承，所以Target必须是接口，不可以是类。  
源（Adaptee）角色：需要适配的类。  
适配器（Adapter）角色：把源接口转换成目标接口。这一角色必须是类。

##    三、 类的Adapter模式示意性实现： ##

下面的程序给出了一个类的Adapter模式的示意性的实现：

![None.gif][] // Class Adapter pattern -- Structural example 
![None.gif][] using System; 
![None.gif][] 
![None.gif][] // "ITarget" 
![None.gif][] interface ITarget 
![ExpandedBlockStart.gif][] \{ 
![InBlock.gif][]// Methods 
![InBlock.gif][]void Request(); 
![ExpandedBlockEnd.gif][]\} 
![None.gif][] 
![None.gif][] // "Adaptee" 
![None.gif][] class Adaptee 
![ExpandedBlockStart.gif][] \{ 
![InBlock.gif][]// Methods 
![InBlock.gif][]publicvoid SpecificRequest() 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][] Console.WriteLine("Called SpecificRequest()" ); 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][] 
![None.gif][] // "Adapter" 
![None.gif][] class Adapter : Adaptee, ITarget 
![ExpandedBlockStart.gif][] \{ 
![InBlock.gif][]// Implements ITarget interface 
![InBlock.gif][]publicvoid Request() 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]// Possibly do some data manipulation 
![InBlock.gif][]// and then call SpecificRequest 
![InBlock.gif][]this.SpecificRequest(); 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][] 
![ExpandedBlockStart.gif][] ///<summary> 
![InBlock.gif][]/// Client test 
![ExpandedBlockEnd.gif][]///</summary> 
![None.gif][] public class Client 
![ExpandedBlockStart.gif][] \{ 
![InBlock.gif][]publicstaticvoid Main(string\[\] args) 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]// Create adapter and place a request 
![InBlock.gif][] ITarget t =new Adapter(); 
![InBlock.gif][] t.Request(); 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\}

##       四、 对象的Adapter模式的结构： ##

![Pic58.gif][]

从图中可以看出：客户端需要调用Request方法，而Adaptee没有该方法，为了使客户端能够使用Adaptee类，需要提供一个包装（Wrapper）类Adapter。这个包装类包装了一个Adaptee的实例，从而将客户端与Adaptee衔接起来。由于Adapter与Adaptee是委派关系，这决定了这个适配器模式是对象的。

该适配器模式所涉及的角色包括：

目标（Target）角色：这是客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。  
源（Adaptee）角色：需要适配的类。  
适配器（Adapter）角色：通过在内部包装（Wrap）一个Adaptee对象，把源接口转换成目标接口。

##    五、 对象的Adapter模式示意性实现： ##

下面的程序给出了一个类的Adapter模式的示意性的实现：

![None.gif][] // Adapter pattern -- Structural example 
![None.gif][] using System; 
![None.gif][] 
![None.gif][] // "Target" 
![None.gif][] class Target 
![ExpandedBlockStart.gif][] \{ 
![InBlock.gif][]// Methods 
![InBlock.gif][]virtualpublicvoid Request() 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]// Normal implementation goes here 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][] 
![None.gif][] // "Adapter" 
![None.gif][] class Adapter : Target 
![ExpandedBlockStart.gif][] \{ 
![InBlock.gif][]// Fields 
![InBlock.gif][]private Adaptee adaptee =new Adaptee(); 
![InBlock.gif][] 
![InBlock.gif][]// Methods 
![InBlock.gif][]overridepublicvoid Request() 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]// Possibly do some data manipulation 
![InBlock.gif][]// and then call SpecificRequest 
![InBlock.gif][] adaptee.SpecificRequest(); 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][] 
![None.gif][] // "Adaptee" 
![None.gif][] class Adaptee 
![ExpandedBlockStart.gif][] \{ 
![InBlock.gif][]// Methods 
![InBlock.gif][]publicvoid SpecificRequest() 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][] Console.WriteLine("Called SpecificRequest()" ); 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][] 
![ExpandedBlockStart.gif][] ///<summary> 
![InBlock.gif][]/// Client test 
![ExpandedBlockEnd.gif][]///</summary> 
![None.gif][] public class Client 
![ExpandedBlockStart.gif][] \{ 
![InBlock.gif][]publicstaticvoid Main(string\[\] args) 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]// Create adapter and place a request 
![InBlock.gif][] Target t =new Adapter(); 
![InBlock.gif][] t.Request(); 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\}

##       六、 在什么情况下使用适配器模式 ##

在以下各种情况下使用适配器模式：

1、 系统需要使用现有的类，而此类的接口不符合系统的需要。  
2、 想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。这些源类不一定有很复杂的接口。  
3、 （对对象适配器而言）在设计里，需要改变多个已有子类的接口，如果使用类的适配器模式，就要针对每一个子类做一个适配器，而这不太实际。

##    七、 一个实际应用Adapter模式的例子 ##

下面的程序演示了Class Adapter与Object Adapter的应用。

![None.gif][] //  Example of implementing the Adapter pattern   
![None.gif][] using  System;  
![None.gif][]  
![None.gif][] //  Target   
![None.gif][] public  interface  ICar  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]void Drive();  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  Direct use without Adapter   
![None.gif][] public  class  CToyota : ICar  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]publicvoid Drive()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] Console.WriteLine("Vroom Vroom, we're off in our Toyota![dot.gif][]");  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  Adaptee   
![None.gif][] public  class  CCessna  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]publicvoid Fly()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] Console.WriteLine("Static runup OK, we're off in our C172![dot.gif][]");  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  Class Adapter   
![None.gif][] public  class  CDrivableCessna : CCessna, ICar  
![ExpandedBlockStart.gif][] \{  
![ExpandedSubBlockStart.gif][]publicvoid Drive() \{ base.Fly(); \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  Object Adapter   
![None.gif][] public  class  CDrivableCessna2 : ICar  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]private CCessna m\_oContained;  
![InBlock.gif][]  
![InBlock.gif][]public CDrivableCessna2()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] m\_oContained =new CCessna();  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]publicvoid Drive() \{ m\_oContained.Fly(); \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  Client   
![None.gif][] public  class  Client  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]publicstaticvoid Main(string\[\] args)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] ICar oCar =new CToyota();  
![InBlock.gif][]  
![InBlock.gif][] Console.Write("Class Adapter: Driving an Automobile![dot.gif][]");  
![InBlock.gif][] oCar.Drive();  
![InBlock.gif][] oCar =new CDrivableCessna();  
![InBlock.gif][] Console.Write("Driving a Cessna![dot.gif][]");  
![InBlock.gif][] oCar.Drive();  
![InBlock.gif][] oCar =new CDrivableCessna2();  
![InBlock.gif][] Console.Write(" Object Adapter: Driving a Cessna![dot.gif][]");  
![InBlock.gif][] oCar.Drive();  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}

##    八、 关于Adapter模式的讨论 ##

Adapter模式在实现时有以下这些值得注意的地方：

1、 目标接口可以省略，模式发生退化。但这种做法看似平庸而并不平庸，它可以使Adaptee不必实现不需要的方法（可以参考Default Adapter模式）。其表现形式就是父类实现缺省方法，而子类只需实现自己独特的方法。这有些像模板（Template）模式。  
2、 适配器类可以是抽象类。  
3、 带参数的适配器模式。使用这种办法，适配器类可以根据参数返还一个合适的实例给客户端。

--------------------

参考文献：  
阎宏，《Java与模式》，电子工业出版社  
\[美\]James W. Cooper，《C\#设计模式》，电子工业出版社  
\[美\]Alan Shalloway James R. Trott，《Design Patterns Explained》，中国电力出版社  
\[美\]Robert C. Martin，《敏捷软件开发－原则、模式与实践》，清华大学出版社  
\[美\]Don Box, Chris Sells，《.NET本质论 第1卷：公共语言运行库》，中国电力出版社

# [.NET设计模式（8）：适配器模式（Adapter Pattern）][.NET_8_Adapter Pattern] #

### 适配器模式（Adapter Pattern） ###

——.NET设计模式系列之八

Terrylee，2006年2月

**概述**

在软件系统中，由于应用环境的变化，常常需要将“一些现存的对象”放在新的环境中应用，但是新环境要求的接口是这些现存对象所不满足的。那么如何应对这种“迁移的变化”？如何既能利用现有对象的良好实现，同时又能满足新的应用环境所要求的接口？这就是本文要说的Adapter 模式。

**意图**

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

**结构图**

![PIC097.jpg][]

图1 类的Adapter模式结构图

![PIC091.jpg][]

图2 对象的Adapter模式结构图

**生活中的例子**

适配器模式允许将一个类的接口转换成客户期望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。扳手提供了一个适配器的例子。一个孔套在棘齿上，棘齿的每个边的尺寸是相同的。在美国典型的边长为1/2''和1/4''。显然，如果不使用一个适配器的话，1/2''的棘齿不能适合1/4''的孔。一个1/2''至1/4''的适配器具有一个1/2''的阴槽来套上一个1/2''的齿，同时有一个1/4的阳槽来卡入1/4''的扳手。

![PIC096.jpg][]

图3使用扳手适配器例子的适配器对象图

**适配器模式解说**

我们还是以日志记录程序为例子说明Adapter模式。现在有这样一个场景：假设我们在软件开发中要使用一个第三方的日志记录工具，该日志记录工具支持数据库日志记录DatabaseLog和文本文件记录FileLog两种方式，它提供给我们的API接口是Write()方法，使用方法如下：

Log.Write("Logging Message!");

当软件系统开发进行到一半时，处于某种原因不能继续使用该日志记录工具了，需要采用另外一个日志记录工具，它同样也支持数据库日志记录DatabaseLog和文本文件记录FileLog两种方式，只不过它提供给我们的API接口是WriteLog()方法，使用方法如下：

Log.WriteLog("Logging Message!");

该日志记录工具的类结构图如下：

![PIC092.jpg][]

图4日志记录工具类结构图

它的实现代码如下：

public abstractclass LogAdaptee

public  abstract void WriteLog();

public class DatabaseLog:LogAdaptee

public  override void WriteLog()

Console.WriteLine("Called WriteLog Method");

public class FileLog:LogAdaptee

public  override void WriteLog()

Console.WriteLine("Called WriteLog Method");

在我们开发完成的应用程序中日志记录接口中（不妨称之为ILogTarget接口，在本例中为了更加清楚地说明，在命名上采用了Adapter模式中的相关角色名字），却用到了大量的Write()方法，程序已经全部通过了测试，我们不能去修改该接口。代码如下：

public interface ILogTarget

void Write();

这时也许我们会想到修改现在的日志记录工具的API接口，但是由于版权等原因我们不能够修改它的源代码，此时Adapter模式便可以派上用场了。下面我们通过Adapter模式来使得该日志记录工具能够符合我们当前的需求。

前面说过，Adapter模式有两种实现形式的实现结构，首先来看一下类适配器如何实现。现在唯一可行的办法就是在程序中引入新的类型，让它去继承LogAdaptee类，同时又实现已有的ILogTarget接口。由于LogAdaptee有两种类型的方式，自然我们要引入两个分别为DatabaseLogAdapter和FileLogAdapter的类。

![PIC093.jpg][]

图5 引入类适配器后的结构图

实现代码如下：

public class DatabaseLogAdapter:DatabaseLog,ILogTarget

public  void Write()

WriteLog();

public class FileLogAdapter:FileLog,ILogTarget

public  void Write()

this.WriteLog();

这里需要注意的一点是我们为每一种日志记录方式都编写了它的适配类，那为什么不能为抽象类LogAdaptee来编写一个适配类呢？因为DatabaseLog和FileLog虽然同时继承于抽象类LogAdaptee，但是它们具体的WriteLog()方法的实现是不同的。只有继承于该具体类，才能保留其原有的行为。

我们看一下这时客户端的程序的调用方法：

public class App

public  static void Main()

ILogTarget dbLog =  new DatabaseLogAdapter();

dbLog.Write("Logging Database...");

ILogTarget fileLog =  new FileLogAdapter();

fileLog.Write("Logging File...");

下面看一下如何通过对象适配器的方式来达到我们适配的目的。对象适配器是采用对象组合而不是使用继承，类结构图如下：

![PIC095.jpg][]

图6引入对象适配器后的结构图

实现代码如下：

public class LogAdapter:ILogTarget

private LogAdaptee \_adaptee;

public LogAdapter(LogAdaptee adaptee)

this.\_adaptee= adaptee;

public  void Write()

\_adaptee.WriteLog();

与类适配器相比较，可以看到最大的区别是适配器类的数量减少了，不再需要为每一种具体的日志记录方式来创建一个适配器类。同时可以看到，引入对象适配器后，适配器类不再依赖于具体的DatabaseLog类和FileLog类，更好的实现了松耦合。

再看一下客户端程序的调用方法：

public class App

public  static void Main()

ILogTarget dbLog =  new LogAdapter(new DatabaseLog());

dbLog.Write("Logging Database...");

ILogTarget fileLog =  new LogAdapter(new FileLog());

fileLog.Write("Logging Database...");

通过Adapter模式，我们很好的实现了对现有组件的复用。对比以上两种适配方式，可以总结出，在类适配方式中，我们得到的适配器类DatabaseLogAdapter和FileLogAdapter具有它所继承的父类的所有的行为，同时也具有接口ILogTarget的所有行为，这样其实是违背了面向对象设计原则中的类的单一职责原则，而对象适配器则更符合面向对象的精神，所以在实际应用中不太推荐类适配这种方式。再换个角度来看类适配方式，假设我们要适配出来的类在记录日志时同时写入文件和数据库，那么用对象适配器我们会这样去写：

public class LogAdapter:ILogTarget

private LogAdaptee \_adaptee1;

private LogAdaptee \_adaptee2;

public LogAdapter(LogAdaptee adaptee1,LogAdaptee adaptee2)

this.\_adaptee1= adaptee1;

this.\_adaptee2= adaptee2;

public  void Write()

\_adaptee1.WriteLog();

\_adaptee2.WriteLog();

如果改用类适配器，难道这样去写：

public class DatabaseLogAdapter:DatabaseLog,FileLog,ILogTarget

public  void Write()

//WriteLog();

显然是不对的，这样的解释虽说有些牵强，也足以说明一些问题，当然了并不是说类适配器在任何情况下都不使用，针对开发场景不同，某些时候还是可以用类适配器的方式。

**.NET中的适配器模式**

1．Adapter模式在.NET Framework中的一个最大的应用就是COM Interop。COM Interop就好像是COM和.NET之间的一条纽带，一座桥梁。我们知道，COM组件对象与.NET类对象是完全不同的，但为了使COM客户程序象调用COM组件一样调用.NET对象，使.NET程序

象使用.NET对象一样使用COM组件，微软在处理方式上采用了Adapter模式，对COM对象进行包装，这个包装类就是RCW(Runtime Callable Wrapper)。RCW实际上是runtime生成的一个.NET类，它包装了COM组件的方法，并内部实现对COM组件的调用。如下图所示：

![PIC094.jpg][]

图7 .NET程序与COM互相调用示意图

2．.NET中的另一个Adapter模式的应用就是DataAdapter。ADO.NET为统一的数据访问提供了多个接口和基类，其中最重要的接口之一是IdataAdapter。与之相对应的DataAdpter是一个抽象类，它是ADO.NET与具体数据库操作之间的数据适配器的基类。DataAdpter起到了数据库到DataSet桥接器的作用，使应用程序的数据操作统一到DataSet上，而与具体的数据库类型无关。甚至可以针对特殊的数据源编制自己的DataAdpter，从而使我们的应用程序与这些特殊的数据源相兼容。注意这是一个适配器的变体。

**实现要点**

1．Adapter模式主要应用于“希望复用一些现存的类，但是接口又与复用环境要求不一致的情况”，在遗留代码复用、类库迁移等方面非常有用。

2．Adapter模式有对象适配器和类适配器两种形式的实现结构，但是类适配器采用“多继承”的实现方式，带来了不良的高耦合，所以一般不推荐使用。对象适配器采用“对象组合”的方式，更符合松耦合精神。

3．Adapter模式的实现可以非常的灵活，不必拘泥于GOF23中定义的两种结构。例如，完全可以将Adapter模式中的“现存对象”作为新的接口方法参数，来达到适配的目的。

4．Adapter模式本身要求我们尽可能地使用“面向接口的编程”风格，这样才能在后期很方便的适配。\[以上几点引用自MSDN WebCast\]

**效果**

对于类适配器：

1．用一个具体的Adapter类对Adaptee和Taget进行匹配。结果是当我们想要匹配一个类以及所有它的子类时，类Adapter将不能胜任工作。

2．使得Adapter可以重定义Adaptee的部分行为，因为Adapter是Adaptee的一个子类。

3．仅仅引入了一个对象，并不需要额外的指针一间接得到Adaptee.

对于对象适配器：

1．允许一个Adapter与多个Adaptee，即Adaptee本身以及它的所有子类（如果有子类的话）同时工作。Adapter也可以一次给所有的Adaptee添加功能。

2．使得重定义Adaptee的行为比较困难。这就需要生成Adaptee的子类并且使得Adapter引用这个子类而不是引用Adaptee本身。

**适用性**

在以下各种情况下使用适配器模式：

1．系统需要使用现有的类，而此类的接口不符合系统的需要。

2．想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。这些源类不一定有很复杂的接口。

3．（对对象适配器而言）在设计里，需要改变多个已有子类的接口，如果使用类的适配器模式，就要针对每一个子类做一个适配器，而这不太实际。

**总结**

总之，通过运用Adapter模式，就可以充分享受进行类库迁移、类库重用所带来的乐趣。

**参考资料**

阎宏，《Java与模式》，电子工业出版社

James W. Cooper，《C\#设计模式》，电子工业出版社

Alan Shalloway James R. Trott，《Design Patterns Explained》，中国电力出版社

MSDN WebCast 《C\#面向对象设计模式纵横谈(7)：Adapter 适配器模式(结构型模式)》

## [乐在其中设计模式(C\#) - 适配器模式(Adapter Pattern)][C_ - _Adapter Pattern] ##

乐在其中设计模式(C\#) - 适配器模式(Adapter Pattern)

作者： [webabcd][]  
  
  
介绍  
将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。  
  
  
示例  
有一个Message实体类，某个类对它的操作有Insert()和Get()方法。现在需要把这个类转到另一个接口，分别对应Add()和Select()方法。  
![o_Adapter.png][]  
  
  
MessageModel

![None.gif][] using System; 
![None.gif][] using System.Collections.Generic; 
![None.gif][] using System.Text; 
![None.gif][] 
![None.gif][] namespace Pattern.Adapter 
![ExpandedBlockStart.gif][] \{ 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// Message实体类 
![ExpandedSubBlockEnd.gif][]///</summary> 
![InBlock.gif][]publicclass MessageModel 
![ExpandedSubBlockStart.gif][]\{ 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 构造函数 
![InBlock.gif][]///</summary> 
![InBlock.gif][]///<param name="msg">Message内容</param> 
![ExpandedSubBlockEnd.gif][]///<param name="pt">Message发布时间</param> 
![InBlock.gif][]public MessageModel(string msg, DateTime pt) 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]this.\_message = msg; 
![InBlock.gif][]this.\_publishTime = pt; 
![ExpandedSubBlockEnd.gif][] \} 
![InBlock.gif][] 
![InBlock.gif][]privatestring \_message; 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// Message内容 
![ExpandedSubBlockEnd.gif][]///</summary> 
![InBlock.gif][]publicstring Message 
![ExpandedSubBlockStart.gif][]\{ 
![ExpandedSubBlockStart.gif][]get\{ return \_message; \} 
![ExpandedSubBlockStart.gif][]set\{ \_message = value; \} 
![ExpandedSubBlockEnd.gif][] \} 
![InBlock.gif][] 
![InBlock.gif][]private DateTime \_publishTime; 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// Message发布时间 
![ExpandedSubBlockEnd.gif][]///</summary> 
![InBlock.gif][]public DateTime PublishTime 
![ExpandedSubBlockStart.gif][]\{ 
![ExpandedSubBlockStart.gif][]get\{ return \_publishTime; \} 
![ExpandedSubBlockStart.gif][]set\{ \_publishTime = value; \} 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][]

SqlMessage

![None.gif][] using System; 
![None.gif][] using System.Collections.Generic; 
![None.gif][] using System.Text; 
![None.gif][] 
![None.gif][] namespace Pattern.Adapter 
![ExpandedBlockStart.gif][] \{ 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 源（Adaptee）角色 
![InBlock.gif][]/// Sql方式操作Message 
![ExpandedSubBlockEnd.gif][]///</summary> 
![InBlock.gif][]publicclass SqlMessage 
![ExpandedSubBlockStart.gif][]\{ 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 获取Message 
![InBlock.gif][]///</summary> 
![ExpandedSubBlockEnd.gif][]///<returns></returns> 
![InBlock.gif][]public List<MessageModel> Get() 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][] List<MessageModel> l =new List<MessageModel>(); 
![InBlock.gif][] l.Add(new MessageModel("SQL方式获取Message", DateTime.Now)); 
![InBlock.gif][] 
![InBlock.gif][]return l; 
![ExpandedSubBlockEnd.gif][] \} 
![InBlock.gif][] 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 插入Message 
![InBlock.gif][]///</summary> 
![InBlock.gif][]///<param name="mm">Message实体对象</param> 
![ExpandedSubBlockEnd.gif][]///<returns></returns> 
![InBlock.gif][]publicbool Insert(MessageModel mm) 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]// 代码略 
![InBlock.gif][]returntrue; 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][]

IMessage

Message

![None.gif][] using System; 
![None.gif][] using System.Collections.Generic; 
![None.gif][] using System.Text; 
![None.gif][] 
![None.gif][] namespace Pattern.Adapter 
![ExpandedBlockStart.gif][] \{ 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 适配器（Adapter）角色 
![InBlock.gif][]/// 类适配器 
![InBlock.gif][]/// 把源适配到这个类 
![ExpandedSubBlockEnd.gif][]///</summary> 
![InBlock.gif][]publicclass Message : SqlMessage, IMessage 
![ExpandedSubBlockStart.gif][]\{ 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 获取Message 
![InBlock.gif][]///</summary> 
![ExpandedSubBlockEnd.gif][]///<returns></returns> 
![InBlock.gif][]public List<MessageModel> Select() 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]returnbase.Get(); 
![ExpandedSubBlockEnd.gif][] \} 
![InBlock.gif][] 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 插入Message 
![InBlock.gif][]///</summary> 
![InBlock.gif][]///<param name="mm">Message实体对象</param> 
![ExpandedSubBlockEnd.gif][]///<returns></returns> 
![InBlock.gif][]publicbool Add(MessageModel mm) 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]returnbase.Insert(mm); 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][]

Message2

![None.gif][] using System; 
![None.gif][] using System.Collections.Generic; 
![None.gif][] using System.Text; 
![None.gif][] 
![None.gif][] namespace Pattern.Adapter 
![ExpandedBlockStart.gif][] \{ 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 适配器（Adapter）角色 
![InBlock.gif][]/// 对象适配器 
![InBlock.gif][]/// 把源适配到这个类 
![ExpandedSubBlockEnd.gif][]///</summary> 
![InBlock.gif][]publicclass Message2 : IMessage 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]private SqlMessage \_sqlMessage; 
![InBlock.gif][] 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 构造函数 
![ExpandedSubBlockEnd.gif][]///</summary> 
![InBlock.gif][]public Message2() 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][] \_sqlMessage =new SqlMessage(); 
![ExpandedSubBlockEnd.gif][] \} 
![InBlock.gif][] 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 获取Message 
![InBlock.gif][]///</summary> 
![ExpandedSubBlockEnd.gif][]///<returns></returns> 
![InBlock.gif][]public List<MessageModel> Select() 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]return \_sqlMessage.Get(); 
![ExpandedSubBlockEnd.gif][] \} 
![InBlock.gif][] 
![ExpandedSubBlockStart.gif][]///<summary> 
![InBlock.gif][]/// 插入Message 
![InBlock.gif][]///</summary> 
![InBlock.gif][]///<param name="mm">Message实体对象</param> 
![ExpandedSubBlockEnd.gif][]///<returns></returns> 
![InBlock.gif][]publicbool Add(MessageModel mm) 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][]return \_sqlMessage.Insert(mm); 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][]

client

![None.gif][] using System; 
![None.gif][] using System.Data; 
![None.gif][] using System.Configuration; 
![None.gif][] using System.Collections; 
![None.gif][] using System.Web; 
![None.gif][] using System.Web.Security; 
![None.gif][] using System.Web.UI; 
![None.gif][] using System.Web.UI.WebControls; 
![None.gif][] using System.Web.UI.WebControls.WebParts; 
![None.gif][] using System.Web.UI.HtmlControls; 
![None.gif][] 
![None.gif][] using Pattern.Adapter; 
![None.gif][] 
![None.gif][] public partial class Adapter : System.Web.UI.Page 
![ExpandedBlockStart.gif][] \{ 
![InBlock.gif][]protectedvoid Page\_Load(object sender, EventArgs e) 
![ExpandedSubBlockStart.gif][]\{ 
![InBlock.gif][] IMessage m; 
![InBlock.gif][] 
![InBlock.gif][] m =new Message(); 
![InBlock.gif][] Response.Write("类适配器方式 "); 
![InBlock.gif][] Response.Write(m.Add(new MessageModel("插入", DateTime.Now))); 
![InBlock.gif][] Response.Write(" "); 
![InBlock.gif][] Response.Write(m.Select()\[0\].Message \+""\+ m.Select()\[0\].PublishTime.ToString()); 
![InBlock.gif][] Response.Write(" "); 
![InBlock.gif][] 
![InBlock.gif][] m =new Message2(); 
![InBlock.gif][] Response.Write("对象适配器方式 "); 
![InBlock.gif][] Response.Write(m.Add(new MessageModel("插入", DateTime.Now))); 
![InBlock.gif][] Response.Write(" "); 
![InBlock.gif][] Response.Write(m.Select()\[0\].Message \+""\+ m.Select()\[0\].PublishTime.ToString()); 
![InBlock.gif][] Response.Write(" "); 
![ExpandedSubBlockEnd.gif][] \} 
![ExpandedBlockEnd.gif][]\} 
![None.gif][]

运行结果  
类适配器方式  
True  
SQL方式获取Message 2007-4-8 20:59:29  
  
对象适配器方式  
True  
SQL方式获取Message 2007-4-8 20:59:29  
  
  
参考  
[http://www.dofactory.com/Patterns/PatternAdapter.aspx][http_www.dofactory.com_Patterns_PatternAdapter.aspx]  
  
  
OK  
[\[源码下载\]][Link 2]

[-]: http://www.cnblogs.com/zhenyulu/category/6930.html
[.NET]: http://www.cnblogs.com/Terrylee/archive/2006/07/17/334911.html
[Link 1]: http://blog.csdn.net/rocket5725/article/category/559017
[C]: http://www.cnblogs.com/webabcd/category/82668.html
[C_10_Adapter Pattern]: http://www.cnblogs.com/zhenyulu/articles/39386.html
[Pic57.gif]: /images/20220413/cba06287159d4d95bd5eb489256edf30.png
[None.gif]: /images/20220413/c427cca3766e41c886fec5382e40c28d.png
[ExpandedBlockStart.gif]: /images/20220413/3db745791d13436f97d5b27f6ecb33cb.png
[InBlock.gif]: /images/20220413/d0980e14262548448791595ee3ff6f63.png
[ExpandedBlockEnd.gif]: /images/20220413/9291d6be209146ed974eb32e1eedbc82.png
[ExpandedSubBlockStart.gif]: /images/20220413/2a86c73dc5ea4237ba27394091ffec16.png
[ExpandedSubBlockEnd.gif]: /images/20220413/7fa34f38b59a45a58a3939b8ba89a476.png
[Pic58.gif]: /images/20220413/30f205397a8d437fa9402cd10a4fb683.png
[dot.gif]: /images/20220413/edcf24d6dfc544a1a71e902648c3d35a.png
[.NET_8_Adapter Pattern]: http://www.cnblogs.com/Terrylee/archive/2006/02/18/333000.html
[PIC097.jpg]: /images/20220413/b4142a6d00e743f8883be3b16e6c73bd.png
[PIC091.jpg]: /images/20220413/06fe5ab9b1d7464c97daf295e70e5cf1.png
[PIC096.jpg]: /images/20220413/091a6bc787bf47b080bba8927a3078f3.png
[PIC092.jpg]: /images/20220413/4ba141740db54fadae1aa1491e065575.png
[PIC093.jpg]: /images/20220413/78bc235892b4455e8c1a43288581e8d4.png
[PIC095.jpg]: /images/20220413/c97c905072f14b5098f5a4d2d16ebe85.png
[PIC094.jpg]: /images/20220413/b1371eaaf316464fa273f581f22dc183.png
[C_ - _Adapter Pattern]: http://www.cnblogs.com/webabcd/archive/2007/04/08/704916.html
[webabcd]: http://webabcd.cnblogs.com/
[o_Adapter.png]: /images/20220413/146977e6ba404c7ead716ecdb93e31e5.png
[http_www.dofactory.com_Patterns_PatternAdapter.aspx]: http://www.dofactory.com/Patterns/PatternAdapter.aspx
[Link 2]: http://files.cnblogs.com/webabcd/Pattern.rar

适配器模式(Adapter Pattern)

发表评论取消回复

还没有评论，来说两句吧...

相关阅读