08_桥接模式

桥接模式是一种结构型设计模式，它将抽象和实现分离，使它们可以独立地变化。桥接模式通过将实现细节从抽象中分离出来，使得抽象和实现可以独立地进行扩展和修改。

桥接模式有四个主要角色：

1. 抽象类（Abstraction）：定义了抽象类的接口，并包含一个对实现类的引用。

2. 实现类接口（Implementor）：定义了实现类的接口，具体实现留给具体的实现类。

3. 具体实现类（Concrete Implementor）：实现实现类接口，并提供具体的实现逻辑。

4. 修正抽象类（Refined Abstraction）：扩展抽象类，提供更多特定功能的方法。

桥接模式的工作原理如下：

1. 抽象类包含一个对实现类接口的引用，通过该引用调用实现类的方法。

2. 实现类接口定义了具体实现类的方法。

3. 具体实现类实现实现类接口，并提供具体的实现逻辑。

4. 修正抽象类扩展了抽象类，可以提供更多特定功能的方法。

桥接模式的优点包括：

1. 可以将抽象和实现解耦，使它们可以独立地进行变化。

2. 可以提高系统的可扩展性，可以方便地添加新的抽象类和实现类。

3. 可以在运行时动态地将抽象和实现进行组合。

桥接模式适用于以下场景：

1. 当需要在抽象和实现之间存在多对多的关系时，可以使用桥接模式。

2. 当需要将抽象和实现分离，使它们可以独立地进行变化时，可以使用桥接模式。

总结而言，桥接模式通过将抽象和实现分离，使它们可以独立地进行变化。它提供了一种解决抽象和实现之间耦合关系的方式，提高了系统的可扩展性和灵活性。

以一杯咖啡为例，以容量为中杯和大杯，以口味分为原味，加奶，加糖。
实际上最终顾客可以买到6种咖啡。它们分别是：
中杯原味，中杯加奶，中杯加糖。
大杯原味，大杯加奶，大杯加糖。
中杯、大杯(抽象)
原味，加奶，加糖(行为)

Implementor

/// <summary>
    /// 行为层接口
    /// </summary>
    public abstract  class CoffeeBase
    {
        /// <summary>
        /// 制作咖啡
        /// </summary>
        /// <returns></returns>
        public abstract string Making();
    }

Concrete Implementor

public class MilkCoffee : CoffeeBase
    {
        public override string Making()
        {
            return "牛奶咖啡";
        }
    }

public class OriginalCoffee : CoffeeBase
    {
        public override string Making()
        {
            return "原味咖啡";
        }
    }

public class SugarCoffee : CoffeeBase
    {
        public override string Making()
        {
            return "加糖咖啡";
        }
    }

Abstraction

/// <summary>
    /// 抽象层接口
    /// </summary>
    public abstract  class CupBase 
    {
        private CoffeeBase coffeeBase;

        public CupBase(CoffeeBase coffeeBase)
        {
            this.coffeeBase = coffeeBase;
        }

        public CoffeeBase CoffeeBase()
        {
            return coffeeBase;
        }

        /// <summary>
        /// 这个方法调用CoffeeBase里面的成员
        /// </summary>
        public abstract void Sale();

        public void SetCoffee(CoffeeBase coffeeBase)
        {
            this.coffeeBase=coffeeBase;
        }
    }

实现CupBase

/// <summary>
    /// 中杯咖啡
    /// </summary>
    public class MediumCupCoffee : CupBase
    {
        public MediumCupCoffee(CoffeeBase coffeeBase) : base(coffeeBase)
        {
        }

        public override void Sale()
        {
            string result = $"中杯{this.CoffeeBase().Making()}";
            Console.WriteLine(result);
        }
    }

/// <summary>
    /// 大杯咖啡
    /// </summary>
    public class LargeCupCoffee : CupBase
    {
        public LargeCupCoffee(CoffeeBase coffeeBase) : base(coffeeBase)
        {
        }

        public override void Sale()
        {
            string result = $"大杯{this.CoffeeBase().Making()}";
            Console.WriteLine(result);
        }
    }

Refined Abstraction

public class Cup : CupBase
    {
        public Cup(CoffeeBase coffeeBase) : base(coffeeBase)
        {
        }

        public override void Sale()
        {
            Console.WriteLine("统一正常杯"+CoffeeBase().Making());
        }
    }

调用

internal class Client
    {
        public void Start()
        {
            Console.WriteLine("顾客A想买大杯加糖的咖啡");
            var largeCupCoffee = new LargeCupCoffee(new SugarCoffee());
            largeCupCoffee.Sale();

            Console.WriteLine("顾客B想买大杯加奶的咖啡");
            var milkCupCoffee = new LargeCupCoffee(new MilkCoffee());
            milkCupCoffee.Sale();

            Console.WriteLine("顾客C想买大杯原味的咖啡");
            var originaeCupCoffee = new LargeCupCoffee(new OriginalCoffee());
            originaeCupCoffee.Sale();

            Console.WriteLine("---------------------------------------------------");


            CupBase cup = new Cup(null);

            cup.SetCoffee(new SugarCoffee());
            cup.Sale();

            cup.SetCoffee(new MilkCoffee());
            cup.Sale();

            cup.SetCoffee(new OriginalCoffee());
            cup.Sale();
        }
    }

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

            Console.ReadKey();
        }