设计模式-适配器模式

适配器模式：解决重构的问题，新东西和旧系统不吻合，通过组合/继承进行配

适配器：插座，电源适配器，做个转接的

程序员已经确定好规范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>();
 }