/// <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);
     }
 }

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  
 //类适配器模式
 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>();
 }