适配器模式（Adapter Pattern）

适配器模式（Adapter Pattern）:
将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原来由于接口不兼容而不能一起工作的
那些类可以一起工作。

/// <summary>
    /// Target类：这是客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。
    /// </summary>
    public class Target
    {
        public virtual void Request()
        {
            Console.WriteLine("普通请求");
        }
    }

    /// <summary>
    /// 需要适配的类
    /// </summary>
    class Adaptee
    {
        public void SpecificRequest()
        {
            Console.WriteLine("特殊请求");
        }
    }

    /// <summary>
    /// 通过在内部包装一个Adaptee对象，把源接口转换成目标接口
    /// </summary>
    class Adapter : Target
    {
        private Adaptee adaptee = new Adaptee();

        //这样就可以把表面上调用Request()方法变成实际调用SpecificRequest()
        public override void Request()
        {
            adaptee.SpecificRequest();
        }
    }

    class Program
    {
        static void Main()
        {
            Target target = new Adapter();
            target.Request();
        }

    }

优势和缺陷：
适配器模式可以将一个类的接口和另一个类的接口匹配起来，使用的前提是你不能修改或不想修改原来的适配器母接口（Adaptee）
。例如，你向第三方购买了一些类、控件，但没有源程序，这是使用适配器模式，可以统一对象的访问接口。但客户调用可能需要
变动。

应用：
(1)对象需要利用现存的并且接口不兼容的类
(2)需要创建可重用的类协作其它接口不一定兼容的类
(3)需要使用若干个现存的子类但又不想派生这些子类中的每一个接口。

实例：篮球翻译

 

/// <summary>
    /// 球员类,有进攻和防守的方法
    /// </summary>
    public abstract class Player
    {
        protected string name;
        public Player(string name)
        {
            this.name = name;
        }
        //进攻
        public abstract void Attack();
        //防守
        public abstract void Defence();
    }

    /// <summary>
    /// 前锋类
    /// </summary>
    public class Forwards : Player
    {
        public Forwards(string name)
            :base(name)
        {
        }

        public override void Attack()
        {
            Console.WriteLine("前锋{0}进攻",name);
        }

        public override void Defence()
        {
            Console.WriteLine("前锋{0}防守",name);
        }
    }

    /// <summary>
    /// 中锋类
    /// </summary>
    public class Center : Player
    {
        public Center(string name)
            : base(name)
        {
        }

        public override void Attack()
        {
            Console.WriteLine("中锋{0}进攻", name);
        }

        public override void Defence()
        {
            Console.WriteLine("中锋{0}防守", name);
        }
    }

    /// <summary>
    /// 后卫类
    /// </summary>
    public class Guards : Player
    {
        public Guards(string name)
            : base(name)
        {
        }

        public override void Attack()
        {
            Console.WriteLine("后卫{0}进攻", name);
        }

        public override void Defence()
        {
            Console.WriteLine("后卫{0}防守", name);
        }
    }

    /// <summary>
    /// 外籍中锋
    /// Adaptee类，需要适配的类
    /// </summary>
    public class ForeignCenter
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        //说明外籍中锋只懂得中文进攻
        public void 进攻()
        {
            Console.WriteLine("外籍中锋{0}进攻",name);
        }
        //外籍中锋只懂得中文防守
        public void 防守()
        {
            Console.WriteLine("外籍中锋{0}防守",name);
        }

    }

    /// <summary>
    /// 翻译类：Adapter类
    /// </summary>
    public class Translator : Player
    {
        private ForeignCenter wjzf = new ForeignCenter();

        public Translator(string name)
            : base(name)
        {
            wjzf.Name = name;
        }

        //翻译者讲Attack翻译为进攻告诉外籍中锋
        public override void Attack()
        {
            wjzf.进攻();
        }

        public override void Defence()
        {
            wjzf.防守();
        }
    }

 

客户端调用

//适配器模式
            AdapterPattern.Player player1 = new AdapterPattern.Forwards("巴蒂尔");
            player1.Attack();

            AdapterPattern.Player player2 = new AdapterPattern.Guards("艾克斯雷迪");
            player2.Attack();

            //翻译告诉姚明，教练要求进攻和防守
            AdapterPattern.Player yaoming = new AdapterPattern.Translator("姚明");
            yaoming.Attack();
            yaoming.Defence();