設計模式-適配器模式

適配器模式：解決重構的問題，新東西和舊系統不吻合，通過組合/繼承進行配

適配器：插座，電源適配器，做個轉接的

程式員已經確定好規範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>();
 }