我要评论适配器模式：解决重构的问题，新东西和旧系统不吻合，通过组合/继承进行配
适配器：插座，电源适配器，做个转接的
程序员已经确定好规范ihelper，新增了一个redishelper----第三方，二者规范不一致，就是没实现接口
/// <summary>
/// 数据访问接口
/// </summary>
public interface ihelper
{
void add<t>();
void delete<t>();
void update<t>();
void query<t>();
}
public class mysqlhelper : ihelper
{
public void add<t>()
{
console.writeline("this is {0} add", this.gettype().name);
}
public void delete<t>()
{
console.writeline("this is {0} delete", this.gettype().name);
}
public void update<t>()
{
console.writeline("this is {0} update", this.gettype().name);
}
public void query<t>()
{
console.writeline("this is {0} query", this.gettype().name);
}
}
/// <summary>
/// 第三方提供的 openstack servicestack
/// 不能修改
/// </summary>
public class redishelper
{
public redishelper()
{
console.writeline($"构造redishelper");
}
public void addredis<t>()
{
console.writeline("this is {0} add", this.gettype().name);
}
public void deleteredis<t>()
{
console.writeline("this is {0} delete", this.gettype().name);
}
public void updateredis<t>()
{
console.writeline("this is {0} update", this.gettype().name);
}
public void queryredis<t>()
{
console.writeline("this is {0} query", this.gettype().name);
}
}
继承：既满足了现有的规范，又没有去修改redishelper，适配器，类适配器
public class redishelperinherit : redishelper, ihelper
{
public redishelperinherit()
{
console.writeline($"构造{this.gettype().name}");
}
public void add<t>()
{
base.addredis<t>();
}
public void delete<t>()
{
base.deleteredis<t>();
}
public void query<t>()
{
base.queryredis<t>();
}
public void update<t>()
{
base.updateredis<t>();
}
}
组合：对象适配器
public class redishelperobject : ihelper
{
public redishelperobject()
{
console.writeline($"构造{this.gettype().name}");
}
private redishelper _redishelper = new redishelper();//属性注入 声明写死 一定有
public redishelperobject(redishelper redishelper)//构造函数 可以替换(需要抽象) 一定有(不考虑其他构造函数)
{
this._redishelper = redishelper;
}
public void setobject(redishelper redishelper)//方法注入 可以替换(需要抽象) 不一定有
{
this._redishelper = redishelper;
}
public void add<t>()
{
this._redishelper.addredis<t>();
}
public void delete<t>()
{
this._redishelper.deleteredis<t>();
}
public void query<t>()
{
this._redishelper.queryredis<t>();
}
public void update<t>()
{
this._redishelper.updateredis<t>();
}
}
组合优于继承吗？
二者都会先构造一个redishelper
1、但是，继承有强侵入，父类的东西子类必须有
2、灵活性，继承只为一个类服务，组合可以面向抽象诶多个类型服务
//继承 既满足现有的规范调用，又没有修改redishelper
//类适配器模式
console.writeline("*****************************");
{
ihelper helper = new redishelperinherit();
helper.add<program>();
helper.delete<program>();
helper.update<program>();
helper.query<program>();
}
//组合 既满足现有的规范调用，又没有修改redishelper
//对象适配器
console.writeline("*****************************");
{
ihelper helper = new redishelperobject();
helper.add<program>();
helper.delete<program>();
helper.update<program>();
helper.query<program>();
}
//组合优于继承？
//二者都会先构造一个redishelper，但是继承是强侵入，父类的东西子类必须有
//灵活性，继承只为一个类服务；组合可以面向抽象为多个类型服务
{
redishelperinherit redishelperinherit = new redishelperinherit();
redishelperinherit.deleteredis<program>();
}
{
redishelperobject redishelperobject = new redishelperobject();
redishelperobject.add<program>();
}
您可能感兴趣的文章:
如您对本文有疑问或者有任何想说的，请 点击进行留言回复，万千网友为您解惑！
网友评论