适配器模式简介：
将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
在计算机编程中，适配器模式（有时候也称包装样式或者包装）将一个类的接口适配成用户所期待的。一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起，做法是将类自己的接口包裹在一个已存在的类中。
适配器模式结构图：
引入实例进行说明：
以日志记录程序为Demo说明，在任何一套软件中都会有对应的日志管理模块，假如如果我们在开发软件中的日记记录采用第三方的日志组件进行日志记录，它采用的是Log.Write("写日志");的方式我们的程序在开发中，大量实例化日记记录对象，采用的Log.Write()方式进行日志记录，但是现在第三方的日志组件现在不免费了，需要收费了，于是我们打算使用一种新的日志管理模块，只不过它提供给我们的API接口是采用Log.WriteLog("新的写日志的方式");进行日志记录。这个时候问题就出现了，如何应对这种迁移的变化
类适配器模式
1.原来日志的接口，采用的是Write(“写日志”);方法
|
1
2
3
4
5
6
7
8
9
10
|
/// <summary>/// 原来的日志记录接口/// </summary>public interface ILogTarget{ /// <summary> /// 原来的写日志方法 /// </summary> void Write(string info);} |
2.然而现在的写日志的接口，采用的是WriteLog("写日志")；里面实现了写日志的新的方式：将日志写到文件中，数据库中
|
1
2
3
4
5
6
7
8
9
10
|
/// <summary>/// 抽象写日志类/// </summary>public abstract class LogAdaptee{ /// <summary> /// 写日志 /// </summary> public abstract void WriteLog(string info);} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/// <summary>/// 写文件日志记录/// </summary>public class FileLog:LogAdaptee{ /// <summary> /// 写日志到文件中 /// </summary> public override void WriteLog(string info) { Console.WriteLine("记录到文本文件："+info); }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/// <summary>/// 往数据库中写日志/// </summary>public class DatabaseLog:LogAdaptee{ /// <summary> /// 重写写日志方法 /// </summary> public override void WriteLog(string info) { Console.WriteLine("记录到数据库："+info); }} |
3.如何使用者两个新对象中的方式，替换原来的写日志的方式？
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
/// <summary>/// 采用新的写日志的方式，写入到数据库中/// </summary>public class DatabaseLogAdapter:DatabaseLog,ILogTarget{ /// <summary> /// 在重写ILogTarget接口中的的Write方法里面调用新的写日志的方式WriteLog /// </summary> public void Write(string info) { WriteLog(info); }}/// <summary>/// 采用新的写日志的方式，写入到文本文件/// </summary>public class FileLogAdapter : FileLog, ILogTarget{ /// <summary> /// 在重写ILogTarget接口中的的Write方法里面调用新的写日志的方式WriteLog /// </summary> public void Write(string info) { this.WriteLog(info); }} |
4.调用依据使用的原来写日志的方法，但是确实使用的新的写日志的方式：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/// <summary>/// 类 适配器模式（Adapter Pattern）/// </summary>class Program{ static void Main(string[] args) { ILogTarget dbLog = new DatabaseLogAdapter(); dbLog.Write("程序启动成功"); dbLog = new FileLogAdapter(); dbLog.Write("程序启动成功"); }} |
对象适配器模式
1.方式采用的是类适配器的方式实现了新的日志功能的迁移变化，下面我们使用对象适配器，可以区别发现两种方式的特别之处。原来写日志的方法依旧不变：Write("写日志");
|
1
2
3
4
5
6
7
8
9
10
|
/// <summary>/// 原来的日志记录接口/// </summary>public interface ILogTarget{ /// <summary> /// 原来的写日志方法 /// </summary> void Write(string info);} |
2.现在的写日志的接口，采用的是WriteLog("写日志")；里面实现了写日志的新的方式：将日志写到文件中，数据库中：
|
1
2
3
4
5
6
7
8
9
10
|
/// <summary>/// 抽象写日志类/// </summary>public abstract class LogAdaptee{ /// <summary> /// 写日志 /// </summary> public abstract void WriteLog(string info);} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/// <summary>/// 写文件日志记录/// </summary>public class FileLog:LogAdaptee{ /// <summary> /// 写日志到文件中 /// </summary> public override void WriteLog(string info) { Console.WriteLine("记录到文本文件："+info); }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/// <summary>/// 往数据库中写日志/// </summary>public class DatabaseLog:LogAdaptee{ /// <summary> /// 重写写日志方法 /// </summary> public override void WriteLog(string info) { Console.WriteLine("记录到数据库："+info); }} |
3.上面我们添加了FileLogAdapter 类，DatabaseLogAdapter类，继承了FileLog,DatabaseLog, ILogTarget接口，重写Write方法里面调用新的写日志的方式WriteLog，使用这样的方式进行了迁移变化。下面使用对象适配：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/// <summary>/// 对象适配，继承ILogTarget，里面有LogAdaptee抽象日志类对象。/// </summary>public class LogAdapter:ILogTarget{ /// <summary> /// 抽象写日志类 /// </summary> private LogAdaptee _adaptee; public LogAdapter(LogAdaptee adaptee) { this._adaptee = adaptee; } public void Write(string info) { _adaptee.WriteLog(info); }} |
4.在程序中的调用：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/// <summary>/// 对象适配器模式（Adapter Pattern）/// </summary>class Program{ static void Main(string[] args) { ILogTarget dbLog = new LogAdapter(new DatabaseLog()); dbLog.Write("程序启动成功"); ILogTarget fileLog = new LogAdapter(new FileLog()); fileLog.Write("程序启动成功"); }} |
比较两者的迁移变化，在类适配方式中，我们得到的适配器类DatabaseLogAdapter和FileLogAdapter具有它所继承的父类的所有的行为，同时也具有接口ILogTarget的所有行为，这样其实是违背了面向对象设计原则中的类的单一职责原则，而对象适配器则更符合面向对象的精神，所以在实际应用中不太推荐类适配这种方式。假设我们要适配出来的类在记录日志时同时写入文件和数据库，那么用对象适配器我们会这样去写：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
/// <summary>/// 对象适配，继承ILogTarget，里面有LogAdaptee抽象日志类对象。/// </summary>public class LogAdapter:ILogTarget{ /// <summary> /// 抽象写日志类 /// </summary> private LogAdaptee _adapteed; /// <summary> /// 抽象写日志类 /// </summary> private LogAdaptee _adapteef; public LogAdapter(LogAdaptee adapteed, LogAdaptee adapteef) { this._adapteed = adapteed; this._adapteef = adapteef; } public void Write(string info) { _adapteed.WriteLog(info); _adapteef.WriteLog(info); }} |
调用：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
/// <summary>/// 对象适配器模式（Adapter Pattern）/// </summary>class Program{ static void Main(string[] args) { //同时写日志到文件和数据库 ILogTarget dbLog = new LogAdapter(new FileLog(), new DatabaseLog()); dbLog.Write("程序启动成功"); }} |
如果改用类适配器：我们难道使用这样的写法达到目的？
|
1
2
3
4
5
6
7
|
public class DatabaseLogAdapter : DatabaseLog, FileLog, ILogTarget{ public void Write(string info) { this.WriteLog(info); }} |
结果肯定是不能的，一个类不能具有多个基类，这样写明细有错误。所有针对不同的情况，我们应该采用合适的方式去进行适配调度。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
