c#设计模式(6)——适配器模式
一、引言
适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。
这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。
接下来要说个例子来演示适配器模式的使用。其中我们一直在使用sqlserver进行增删查改的操作，突然某一天，感觉性能不行了，想替换成redis这种nosql的增删查改的方式，但是redis的帮助类的并没有和sqlserver查询类的接口命名一致，直接替换成本大，这时就需要一个中间层来适配，使得原来sqlserver的数据库操作无缝对接redis数据库操作。
二、介绍
2.1 定义
下面让我们看看适配器的定义，适配器模式——把一个类的接口变换成客户端所期待的另一种接口，从而使原本接口不匹配而无法一起工作的两个类能够在一起工作。适配器模式有类的适配器模式和对象的适配器模式两种形式，下面我们先来描述一下类适配器模式。
2.2 类适配器
1. 在说适配器前，先展示一下sqlserver帮助类的实现。首先，先定义统一的增删查改帮助类接口。
/// <summary>
/// sql帮助抽象类
/// </summary>
public interface IHelper
{
void Query<T>();
void Add<T>();
void Update<T>();
void Delete<T>();
}
2.接着就是sqlserver帮助类实现IHelper接口.
public class SqlServerHelper : IHelper
{
public SqlServerHelper()
{
Console.WriteLine($"{this.GetType().Name} 被构造");
}
public void Add<T>()
{
Console.WriteLine($"{this.GetType().Name}的Add正在添加数据");
}
public void Delete<T>()
{
Console.WriteLine($"{this.GetType().Name}的Delete正在删除数据");
}
public void Query<T>()
{
Console.WriteLine($"{this.GetType().Name}的Query正在查询数据");
}
public void Update<T>()
{
Console.WriteLine($"{this.GetType().Name}的Update正在更新数据");
}
}
3.sqlserver一直用得好好的，现在业务升级了，数据库撑不住了，关系型数据库性能堪忧，Redis这种nosql很好,但是有个问题Redis有自定义的帮助类，如果需要升级使用Redis，不能直接替换sqlserver的帮助类的接口方法；因为RedisHelper没有实现IHelper接口；遇到一个想要放一起使用但是却不能一起使用的问题。这时我们的适配器就要登场了，先演示一下类适配器。
/// <summary>
/// redis帮助类，由于执行方法与sql的执行方法不一致，需要适配
/// </summary>
public class RedisHelper
{
public RedisHelper()
{
Console.WriteLine($"{this.GetType().Name} 被构造");
}
public void RedisAdd<T>()
{
Console.WriteLine($"{this.GetType().Name}的RedisAdd正在添加数据");
}
public void RedisDelete<T>()
{
Console.WriteLine($"{this.GetType().Name}的RedisDelete正在删除数据");
}
public void RedisQuery<T>()
{
Console.WriteLine($"{this.GetType().Name}的RedisQuery正在查询数据");
}
public void RedisUpdate<T>()
{
Console.WriteLine($"{this.GetType().Name}的RedisUpdate正在更新数据");
}
}
/// <summary>
/// 类适配器
/// </summary>
public class RedisClassHelper : RedisHelper, IHelper
{
// 继承实现了让IHelper 和Redis不兼容的事儿---适配器的一种；
// 继承：
// 1.因为是强继承，具有侵入性
// 2.RedisClassHelper只能为RedisHelper服务；
public void Add<T>()
{
base.RedisAdd<T>();
}
public void Delete<T>()
{
base.RedisDelete<T>();
}
public void Query<T>()
{
base.RedisQuery<T>();
}
public void Update<T>()
{
base.RedisUpdate<T>();
}
}
class Program
{
static void Main(string[] args)
{
// sqlserver查询
IHelper sqlServerHelper = new SqlServerHelper();
sqlServerHelper.Add<DesignPatternStructure>();
sqlServerHelper.Update<DesignPatternStructure>();
sqlServerHelper.Query<DesignPatternStructure>();
sqlServerHelper.Delete<DesignPatternStructure>();
//现在业务升级了，数据库撑不住了，关系型数据库性能堪忧
//Nosql == Redis很好----Redis的帮助类库--ServiceStack
//需要升级使用Redis；----不能直接换了；因为RedisHelper没有实现IHelper接口；
//遇到一个想要放一起使用但是却不能一起使用的问题；
//这时就需要一个适配器了
//类适配器
//继承实现了让IHelper 和Redis不兼容的事儿---适配器的一种；
//继承：
//1.因为是强继承，具有侵入性
//2.RedisClassHelper只能为Redishelper服务；
IHelper redisClassHelper = new RedisClassHelper();
redisClassHelper.Add<DesignPatternStructure>();
redisClassHelper.Update<DesignPatternStructure>();
redisClassHelper.Query<DesignPatternStructure>();
redisClassHelper.Delete<DesignPatternStructure>();
}
}
2.2 对象适配器
4. 以上就是类适配器的实现，但是大家都发现了一个问题，就是虽然解决RedisHelper和IHelper不兼容的问题，但是因为是强继承，具有侵入性RedisClassHelper只能为Redishelper服务，而且想要匹配一 个类以及所有它的子类时，类的适配器模式就不能胜任了；为了解决这个问题，多了一种对象适配器，使得适配类可以兼容多个不同的对象。
为了证明这一点，我写一个继承了RedisHelper类的子类
public class RedisChildHelper: RedisHelper
{
}
然后我写个对象适配器
/// <summary>
/// 对象适配器
/// </summary>
public class RedisObjHelper : IHelper
{
private RedisHelper _redisHelper = null;
/// <summary>
/// 构造函数方式注入
/// 在实例化的时候，必须传入----就可以保障需要适配的对象不会为null
/// </summary>
/// <param name="redisHelper"></param>
public RedisObjHelper(RedisHelper redisHelper)
{
_redisHelper = redisHelper;
}
public void SetRedisHelper(RedisHelper redisHelper)
{
_redisHelper = redisHelper;
}
public void Add<T>()
{
_redisHelper.RedisAdd<T>();
}
public void Delete<T>()
{
_redisHelper.RedisDelete<T>();
}
public void Query<T>()
{
_redisHelper.RedisQuery<T>();
}
public void Update<T>()
{
_redisHelper.RedisUpdate<T>();
}
}
5.演示一下对象适配器的实现
class Program
{
static void Main(string[] args)
{
//对象适配器
//为什么说组合优于继承呢？
//1.没有侵入性
//2.可以为多个类型服务
//3.相对来说要更加灵活一点
//IHelper redisObjHelper = new RedisObjHelper(new RedisHelper());
IHelper redisChildHelper = new RedisObjHelper(new RedisChildHelper());
redisObjHelper.Add<DesignPatternStructure>();
redisObjHelper.Update<DesignPatternStructure>();
redisObjHelper.Query<DesignPatternStructure>();
redisObjHelper.Delete<DesignPatternStructure>();
}
}
三、适配器模式的优缺点
类适配器模式：
1.优点：
可以在不修改原有代码的基础上来复用现有类，很好地符合 “开闭原则”
可以重新定义(被适配的类)的部分行为.
仅仅引入一个对象，并不需要额外的字段来引用RedisHelper实例（这个即是优点也是缺点）
2.缺点：
采用了 “多继承”的实现方式，带来了不良的高耦合。
对象适配器模式：
1.优点：可以在不修改原有代码的基础上来复用现有类，很好地符合 “开闭原则”，采用 “对象组合”的方式，更符合松耦合，以兼容多个不同的对象
