07_适配器模式

适配器模式是一种结构型设计模式，它通过将一个类的接口转换成客户端所期望的另一个接口，使得原本由于接口不兼容而不能一起工作的类能够协同工作。

适配器模式有三个主要角色：

1. 目标接口（Target）：定义了客户端所期望的接口。

2. 源接口（Adaptee）：需要被适配的类或接口。

3. 适配器（Adapter）：将源接口转换成目标接口，使得客户端可以使用。

适配器模式的工作原理如下：

1. 客户端通过调用目标接口来请求某个操作。

2. 适配器接收到该请求后，将请求转发给源接口。

3. 源接口执行相应的操作，并将结果返回给适配器。

4. 适配器将结果转换为目标接口所期望的格式，并将结果返回给客户端。

适配器模式的优点包括：

1. 可以让原本不兼容的类能够协同工作。

2. 可以重用已有的类，无需修改其代码。

3. 可以增加新的适配器类，实现不同类型的适配。

适配器模式适用于以下场景：

1. 当需要使用一个已存在的类，但其接口与所需要的接口不一致时，可以使用适配器模式。

2. 当希望创建一个可复用的类，该类与一些不兼容的类协同工作时，可以使用适配器模式。

总结而言，适配器模式通过将一个类的接口转换成另一个接口，使得原本不兼容的类能够协同工作。它提供了一种解决接口不兼容问题的灵活、可复用的方式。

Adaptee

/// <summary>
    /// 车
    /// </summary>
    public interface IVehicle
    {
        /// <summary>
        /// 跑
        /// </summary>
        void Run();
        /// <summary>
        /// 鸣笛
        /// </summary>
        void Whistle();
    }

Target

/// <summary>
    /// 小车
    /// </summary>
    public class Car : IVehicle
    {
        public void Run()
        {
            Console.WriteLine("小车在跑");
        }

        public void Whistle()
        {
            Console.WriteLine("小车在鸣笛");
        }
    }

/// <summary>
    /// 火车
    /// </summary>
    public class Train : IVehicle
    {
        public void Run()
        {
            Console.WriteLine("火车在跑");
        }

        public void Whistle()
        {
            Console.WriteLine("火车在鸣笛");
        }
    }

/// <summary>
    /// 自行车
    /// </summary>
    public class Bicycle
    {
        public void Cycling()
        {
            Console.WriteLine("自行车在骑行");
        }

        public void RingBell()
        {
            Console.WriteLine("自行车在按铃");
        }
    }

Adapter

调用自行车类里面的方法适配器如下

类适配器：

/// <summary>
    /// 类适配器
    /// </summary>
    public class BicycleInheritAdapter : Bicycle, IVehicle
    {
        public void Run()
        {
            base.Cycling();
        }

        public void Whistle()
        {
            base.RingBell();
        }
    }

对象适配器：

/// <summary>
    /// 对象适配器
    /// </summary>
    public class BicycleCombinationAdapter : IVehicle
    {
        private Bicycle _bicycle = null;
        /// <summary>
        /// 属性注入
        /// </summary>
        public Bicycle Bicycle 
        {
            get 
            {
                return _bicycle;
            }
            set
            {
                if(value != null)
                {
                    _bicycle = value;
                }
            }
        }

        /// <summary>
        /// 构造函数注入
        /// </summary>
        /// <param name="bicycle"></param>
        public BicycleCombinationAdapter(Bicycle bicycle =null)
        {
            if (bicycle != null)
            {
                _bicycle = bicycle;
            }
        }

        /// <summary>
        /// 方法注入
        /// </summary>
        /// <param name="bicycle"></param>
        public void SetBicycle(Bicycle bicycle)
        {
            if (bicycle != null)
            {
                _bicycle = bicycle;
            }
        }

        public void Run()
        {
            _bicycle?.Cycling();
        }

        public void Whistle()
        {
            _bicycle?.RingBell();
        }
    }

调用：

 public class Client
    {
        public void Start()
        {//类适配器
            IVehicle bicycle = new BicycleInheritAdapter();
            bicycle.Run();
            bicycle.Whistle();

            //对象适配器
            IVehicle bike = new BicycleCombinationAdapter(new Bicycle());//构造函数注入
            //((BicycleCombinationAdapter)bike).Bicycle = new Bicycle();//属性注入
            //((BicycleCombinationAdapter)bike).SetBicycle(new Bicycle());//方法注入

            bike.Run();
            bike.Whistle();

        }
    }

static void Main(string[] args)
        {
            new Client().Start();

            Console.ReadKey();
        }