2021-8-20 设计模式笔记

详细链接：https://www.cnblogs.com/zhili/p/DesignPatternSummery.html

1、单例模式

#region 单例模式
    /// <summary>
    /// 单例模式要求只有一个任务的时候创建
    /// </summary>
    public class Single
    {
        /// <summary>
        /// 定义一个静态变量保存类的实例
        /// </summary>
        private static Single single;
        /// <summary>
        /// 定义私有构造函数，使外界类不能够创造实例
        /// </summary>
        private Single() {

        }
        /// <summary>
        /// 定义公有方法来创造一个全局访问点
        /// </summary>
        /// <returns></returns>
        public static Single GetInstance() {
            //如果实例不存在就创建，存在就直接返回实例
            if (single == null) {
                single = new Single();
            }
            return single;
        }
    }
    /// <summary>
    /// 多线程下的单例模式（在多线程模式下上面的单一模式会出现多个实例）
    /// </summary>
    public class MulitSingle
    {
        private static MulitSingle mulitSingle;
        private static readonly object locker = new object();
        private MulitSingle() {

        }
        public static MulitSingle GetInstance2() {
            //第一个线程到这里会进行加锁
            //第二个线程检测到是加锁的状态会挂起等待执行完毕
            //当第一个线程执行完毕后解锁，执行第二个线程
            //提前判断可不必在加锁后在判断是否为空，浪费开销
            if (mulitSingle == null) {
                lock (locker) {
                    if (mulitSingle == null)//使用两次判断防止两次解锁后创造了两个实例
                    {
                        mulitSingle = new MulitSingle();
                    }
                }
            }
            return mulitSingle;
        }
    }
    #endregion

2、简单工厂模式

#region 简单工厂模式
    #region 正常

    public class Customer
    {
        public static Food Cook(string foodType) {
            Food food = null;
            if (foodType.Equals("西红柿")) {
                food = new XiHongShi();
            }
            else if (foodType.Equals("土豆炒鸡蛋")) {
                food = new TuDouChaoJiDan();
            }
            return food;
        }
        public  void GetFood() {
            Food food1 = Cook("西红柿");
            food1.Print();
            Food food2 = Cook("土豆炒鸡蛋");
            food2.Print();
        }
    }
    public abstract class Food
    {
        public abstract void Print();
    }
    public class TuDouChaoJiDan : Food
    {
        public override void Print() {
            Console.WriteLine("土豆炒鸡蛋");
        }
    }
    public class XiHongShi : Food
    {
        public override void Print() {
            Console.WriteLine("西红柿");
        }
    }
    #endregion
    #region 简单工厂
    /// <summary>
    /// 优点
    /// 1、与上面区别是实现责任区别
    /// 2、代码复用
    /// 缺点
    /// 1、一旦工厂出了问题会影响很多对象
    /// 2、工厂扩展困难，修改功能会造成逻辑复杂
    /// 使用场景：
    /// 1、创建的对象比较少的时候可以使用
    /// 2、客户不需要管理逻辑，只需传入数据时
    /// </summary>
    public class Customer1
    {
        public void GetFood() {
            Food1 food1 = FoodSingleFactory.CreateCook("西红柿");
            food1.Print();
            Food1 food2 = FoodSingleFactory.CreateCook("土豆炒鸡蛋");
            food2.Print();
        }
    }
    public abstract class Food1
    {
        public abstract void Print();
    }
    public class TuDouChaoJiDan1 : Food1
    {
        public override void Print() {
            Console.WriteLine("土豆炒鸡蛋");
        }
    }
    public class XiHongShi1 : Food1
    {
        public override void Print() {
            Console.WriteLine("西红柿");
        }
    }
    public class FoodSingleFactory
    {
        public static Food1 CreateCook(string foodType) {
            Food1 food = null;
            if (foodType.Equals("西红柿")) {
                food = new XiHongShi1();
            }
            else if (foodType.Equals("土豆炒鸡蛋")) {
                food = new TuDouChaoJiDan1();
            }
            return food;
        }
    }
    #endregion
    #endregion

main执行

  new Customer().GetFood();
  new Customer1().GetFood();
  Console.ReadKey();

 3、工厂模式

 class Program
    {
        static void Main(string[] args) {
            Creator creator = new TuDouChaoJiDanFactory();
            Creator creator1 = new XiHongShiFactory();

            Food food= creator.CreateFoodFactory();
            food.Print();

            Food food1 = creator1.CreateFoodFactory();
            food1.Print();

            Console.ReadKey();
        }
    }
    public abstract class Food
    {
        public abstract void Print();
    }
    public class TuDouChaoJiDan : Food
    {
        public override void Print() {
            Console.WriteLine("土豆炒鸡蛋");
        }
    }
    public class XiHongShi : Food
    {
        public override void Print() {
            Console.WriteLine("西红柿");
        }
    }
    public abstract class Creator
    {
        public abstract Food CreateFoodFactory();

    }
    public class TuDouChaoJiDanFactory : Creator
    {
        public override Food CreateFoodFactory() {
            return new TuDouChaoJiDan();
        }
    }
    public class XiHongShiFactory : Creator
    {
        public override Food CreateFoodFactory() {
            return new XiHongShi();
        }
    }

4、抽象工厂模式

 class Program
    {
        static void Main(string[] args) {
            AbstractFactory abstractFactory = new ShangHaiFactory();
            abstractFactory.CreateYaBo().Print();
            abstractFactory.CreateYaJiao().Print();

            AbstractFactory abstractFactory1 = new NanChangFactory();
            YaBo yaBo = abstractFactory1.CreateYaBo();
            yaBo.Print();

            YaJiao yaJiao = abstractFactory1.CreateYaJiao();
            yaJiao.Print();

            Console.ReadKey();
        }
    }
    /// <summary>
    /// 抽象工厂，创建抽象工厂，提供两个接口
    /// </summary>
    public abstract class AbstractFactory
    {
        public abstract YaBo CreateYaBo();//创建抽象类，包含抽象方法
        public abstract YaJiao CreateYaJiao();
    }
    public class ShangHaiFactory : AbstractFactory
    {
        public override YaBo CreateYaBo() {
            return new ShangHaiYaBo();
        }

        public override YaJiao CreateYaJiao() {
            return new ShangHaiYaJiao();
        }
    }
    public class NanChangFactory : AbstractFactory
    {
        public override YaBo CreateYaBo() {
            return new NanChangYaBo();
        }

        public override YaJiao CreateYaJiao() {
            return new NanChangYaJiao();
        }
    }

    public abstract class YaBo
    {
        public abstract void Print();
    }
    public abstract class YaJiao
    {
        public abstract void Print();
    }
    public class ShangHaiYaBo : YaBo
    {
        public override void Print() {
            Console.WriteLine("上海鸭脖");
        }
    }
    public class NanChangYaBo : YaBo
    {
        public override void Print() {
            Console.WriteLine("南昌鸭脖");
        }
    }
    public class ShangHaiYaJiao : YaJiao
    {
        public override void Print() {
            Console.WriteLine("上海鸭脚");
        }
    }
    public class NanChangYaJiao : YaJiao
    {
        public override void Print() {
            Console.WriteLine("南昌鸭脚");
        }
    }

 5、建造者模式

 class Program
    {
        static void Main(string[] args) {
            Boss boss = new Boss();
            Builder b1 = new ConcreateBuilder1();
            Builder b2 = new ConcreateBuilder2();
            boss.Construct(b1);
            Computer computer = b1.GetComputer();
            computer.Show();

            boss.Construct(b2);
            Computer computer1 = b2.GetComputer();
            computer1.Show();

            Console.ReadKey();
        }
    }
    /// <summary>
    /// 建造者模式
    /// </summary>
    public class Boss
    {
        public void Construct(Builder builder) {
            builder.BuildPartCPU();//调用对应的Builder方法
            builder.BuildPartMainBoard();
        }
    }
    public class Computer
    {
        private IList<string> parts = new List<string>();
        public void Add(string part) {
            parts.Add(part);
        }
        public void Show() {
            Console.WriteLine("电脑开始组装");
            foreach (var item in parts) {
                Console.WriteLine($"组件{item}已经组装好了");
                Thread.Sleep(500);
            }
            Console.WriteLine("组装好了");
        }
    }
    public abstract class Builder
    {
        public abstract void BuildPartCPU();
        public abstract void BuildPartMainBoard();
        public abstract Computer GetComputer();
    }
    /// <summary>
    /// 实现抽象类的抽象方法
    /// </summary>
    public class ConcreateBuilder1 : Builder
    {
        Computer computer = new Computer();
        public override void BuildPartCPU() {
            computer.Add("CPU1");
        }

        public override void BuildPartMainBoard() {
            computer.Add("MainBoard1");
        }

        public override Computer GetComputer() {
            return computer;
        }
    }
    public class ConcreateBuilder2 : Builder
    {
        Computer computer = new Computer();
        public override void BuildPartCPU() {
            computer.Add("CPU2");
        }

        public override void BuildPartMainBoard() {
            computer.Add("MainBoard2");
        }

        public override Computer GetComputer() {
            return computer;
        }
    }

 6、原型模式

using System;

namespace DesignModel
{
    class Program
    {
        static void Main(string[] args)
        {
            //猴王原型
            MonkeyKingPrototype monkeyKing = new CreateProtoType("xunwukong");
            //克隆1
            MonkeyKingPrototype monkeyKing1 = monkeyKing.clone() as CreateProtoType;
            //克隆2
            MonkeyKingPrototype monkeyKing2 = monkeyKing.clone();
            Console.WriteLine(monkeyKing1.ID);
            Console.WriteLine(monkeyKing2.ID);
            Console.ReadKey();
        }
        //原型模式：当需要创建多个实例的时候，而工厂模式会导致系统的复杂性变高，可以使用原型模式，相当于创造一个实例其他的都是copy的
        //特点：减少内存消耗和实例复用
        /// <summary>
        /// 创造原型
        /// </summary>
        public abstract class MonkeyKingPrototype
        {
            public string ID { get; set; }
            public MonkeyKingPrototype(string id)
            {
                this.ID = id;
            }
            public abstract MonkeyKingPrototype clone();
        }
        /// <summary>
        /// 创造具体原型
        /// </summary>
        public class CreateProtoType : MonkeyKingPrototype
        {
            public CreateProtoType(string id):base(id)
            {

            }
            /// <summary>
            /// 浅拷贝
            /// </summary>
            /// <returns></returns>
            public override MonkeyKingPrototype clone()
            {
                //这只是浅拷贝，还有深拷贝
                return (MonkeyKingPrototype)this.MemberwiseClone();
            }
        }
    }
}

 7、适配器模式

using System;

namespace DesignModel2
{
    class Program
    {
        //假设买的电器只有两个插口，而插排只有三个插口，此时需要适配器来转换
        static void Main(string[] args)
        {
            //此时三个插口的接口就可以被两个插口的抽象类使用了
            IThreeHole threeHole = new PowerAdapter();
            threeHole.Request();
            Console.ReadKey();
        }
        /// <summary>
        /// 三个插口
        /// </summary>
        public interface IThreeHole
        {
            void Request();
        }
        /// <summary>
        /// 两个
        /// </summary>
        public abstract class TwoHole
        {
            public void SRequest()
            {
                Console.WriteLine("两插口成功插入");
            }
        }
        /// <summary>
        /// 适配器
        /// </summary>
        public class PowerAdapter : TwoHole, IThreeHole
        {
            /// <summary>
            /// 将两个插口的包装转换，并不展示在前端
            /// </summary>
            public void Request()
            {
                this.SRequest();
            }
        }
    }
}

using System;

namespace DesignModel3
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
    public class ThreeHole
    {
        public virtual void Request()
        {

        }
    }
    public class TwoHole
    {
        public void SRequest()
        {
            Console.WriteLine("两个插口成功插入");
        }
    }
    /// <summary>
    /// 具体情况如上个适配器例子但两个插口不能继承，所以可以使用重载方法实现
    /// </summary>
    public class PowerAdapter:ThreeHole
    {
        public TwoHole twoHole = new TwoHole();
        public override void Request()
        {
            twoHole.SRequest();
        }
    }
}

 8、桥接模式

using System;

namespace DesignModel4
{
    class Program
    {
        static void Main(string[] args)
        {
            TVControl control = new TVControl();//定义遥控器通过该切换TV类型去调用相应的Tv类
            control.Control = new ChangHong();
            control.On();
            control.SetChannel();
            control.Off();

            //切换电视
            control.Control = new SangXing();
            control.On();
            control.SetChannel();
            control.Off();
            Console.ReadKey();
        }
    }

    #region 遥控器类
    public class RemoteControl
    {
        private TV control;
        public TV Control
        {
            get { return control; }
            set { control = value; }
        }
        public virtual void On()
        {
            control.On();
        }
        public virtual void Off()
        {
            control.Off();
        }
        public virtual void SetChannel()
        {
            control.Turn();
        }
    }
    public class TVControl : RemoteControl
    {
        public override void SetChannel()
        {
            Console.WriteLine("----------------------------------");
            base.SetChannel();
            Console.WriteLine("----------------------------------");
        }
    }
    #endregion
    #region TV创建
    public abstract class TV
    {
        public abstract void On();
        public abstract void Off();
        public abstract void Turn();
    }
    public class ChangHong : TV
    {
        public override void Off()
        {
            Console.WriteLine("关闭长虹");
        }

        public override void On()
        {
            Console.WriteLine("打开长虹");
        }

        public override void Turn()
        {
            Console.WriteLine("长虹换台");
        }
    }
    public class SangXing : TV
    {
        public override void Off()
        {
            Console.WriteLine("三星关闭");
        }

        public override void On()
        {
            Console.WriteLine("三星开启");
        }

        public override void Turn()
        {
            Console.WriteLine("三星换台");
        }
    }
    #endregion
}

 9、装饰者模式

namespace DesignModel5
{
    class Program
    {
        /// <summary>
        /// 装饰者模式
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Phone phone = new ApplePhone();
            //贴膜
            DressClass dressPhone = new Sticker(phone);
            //dressPhone.Print();

            DressClass dressPhone2 = new Pendant(dressPhone);
            dressPhone2.Print();
            Console.ReadKey();
        }
    }
    public abstract class Phone
    {
        public abstract void Print();
    }
    public class ApplePhone : Phone
    {
        public override void Print()
        {
            Console.WriteLine("我有苹果手机");
        }
    }
    /// <summary>
    /// 装饰者类
    /// </summary>
    public abstract class DressClass : Phone
    {
        private Phone phone;
        public DressClass(Phone p)
        {
            this.phone = p;
        }
        public override void Print()
        {
            if (phone!=null)
            {
                phone.Print();
            }
        }
    }

    public class Sticker : DressClass
    {
        public Sticker(Phone phone) : base(phone)
        {

        }
        public override void Print()
        {
            base.Print();
            AddDress();
        }
        public void AddDress()
        {
            Console.WriteLine("贴膜");
        }
    }
    public class Pendant : DressClass
    {
        public Pendant(Phone phone) : base(phone)
        {

        }
        public override void Print()
        {
            base.Print();
            AddDress();
        }
        public void AddDress()
        {
            Console.WriteLine("挂件");
        }
    }
}

10、组合模式

namespace DesignModel6
{
    /// <summary>
    /// 组合模式
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            ComplexGraphics complexGraphics = new ComplexGraphics("复杂图形");
            complexGraphics.Add(new Line("线段1"));
            ComplexGraphics complexGraphics1 = new ComplexGraphics("圆和条线");
            complexGraphics1.Add(new Circle("圆形1"));
            complexGraphics1.Add(new Line("线段2"));

            complexGraphics.Add(complexGraphics1);
            complexGraphics.Remove(complexGraphics1);
            Line n = new Line("线段3");
            
            complexGraphics.Add(n);
            complexGraphics.Remove(n);
            complexGraphics.Draw();
            Console.ReadKey();
        }
    }
    #region 透明式组合模式
    //public abstract class Graphics
    //{
    //    public string name;
    //    public Graphics(string _name)
    //    {
    //        this.name = _name;
    //    }
    //    public abstract void Draw();
    //    public abstract void Add(Graphics graphics);
    //    public abstract void Remove(Graphics graphics);
    //}
    //public class Line : Graphics
    //{
    //    public Line(string _name):base(_name)
    //    {

    //    }
    //    public override void Add(Graphics graphics)
    //    {
    //        throw new NotImplementedException("不能向简单图形Line添加其他图形");
    //    }

    //    public override void Draw()
    //    {
    //        Console.WriteLine("画"+name);
    //    }

    //    public override void Remove(Graphics graphics)
    //    {
    //        throw new NotImplementedException("不能向简单图形Line移除其他图形");
    //    }
    //}
    //public class Circle : Graphics
    //{
    //    public Circle(string _name):base(_name)
    //    {

    //    }
    //    public override void Add(Graphics graphics)
    //    {
    //        throw new NotImplementedException("不能向简单图形Line添加其他图形");
    //    }

    //    public override void Draw()
    //    {
    //        Console.WriteLine("画"+name);
    //    }

    //    public override void Remove(Graphics graphics)
    //    {
    //        throw new NotImplementedException("不能向简单图形Line移除其他图形");
    //    }
    //}
    //public class ComplexGraphics : Graphics
    //{
    //    public List<Graphics> graphicss = new List<Graphics>();
    //    public ComplexGraphics(string Name):base(Name)
    //    {

    //    }
    //    public override void Add(Graphics graphics)
    //    {
    //        graphicss.Add(graphics);
    //    }

    //    public override void Draw()
    //    {
    //        foreach (var item in graphicss)
    //        {
    //            Graphics graphics = item as Graphics;
    //            graphics.Draw();
    //        }
    //    }

    //    public override void Remove(Graphics graphics)
    //    {
    //        graphicss.Remove(graphics);
    //    }
    //}
    #endregion

    #region 透明式组合模式
    public abstract class Graphics
    {
        public string name;
        public Graphics(string _name)
        {
            this.name = _name;
        }
        public abstract void Draw();
    }
    public class Line : Graphics
    {
        public Line(string _name) : base(_name)
        {

        }
        public override void Draw()
        {
            Console.WriteLine("画" + name);
        }
    }
    public class Circle : Graphics
    {
        public Circle(string _name) : base(_name)
        {

        }
        public override void Draw()
        {
            Console.WriteLine("画" + name);
        }
    }
    public class ComplexGraphics : Graphics
    {
        public List<Graphics> graphicss = new List<Graphics>();
        public ComplexGraphics(string Name) : base(Name)
        {

        }
        public void Add(Graphics graphics)
        {
            graphicss.Add(graphics);
        }

        public override void Draw()
        {
            foreach (var item in graphicss)
            {
                Graphics graphics = item as Graphics;
                graphics.Draw();
            }
        }

        public void Remove(Graphics graphics)
        {
            graphicss.Remove(graphics);
        }

    }
    #endregion

}

11、享元模式

namespace DesignModel7
{
    /// <summary>
    /// 享元模式：享元模式主要用来解决由于大量的细粒度对象所造成的内存开销的问题，它在实际的开发中并不常用，可以作为底层的提升性能的一种手段。
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            int extstate = 10;
            FlyWeightFactory flyWeightFactory = new FlyWeightFactory();
            FlyWeight flyWeightA = flyWeightFactory.GetFlyWeight("A");
            if (flyWeightA != null)
            {
                flyWeightA.Operation(--extstate);
            }
            FlyWeight flyWeightB = flyWeightFactory.GetFlyWeight("B");
            if (flyWeightB != null)
            {
                flyWeightB.Operation(--extstate);
            }
            FlyWeight flyWeightC = flyWeightFactory.GetFlyWeight("C");
            if (flyWeightC != null)
            {
                flyWeightC.Operation(--extstate);
            }
            FlyWeight flyWeightD = flyWeightFactory.GetFlyWeight("D");
            if (flyWeightD != null)
            {
                flyWeightD.Operation(--extstate);
            }
            else
            {
                Console.WriteLine("不存在D");
                ConCreateFlyWeight conCreateFlyWeightD = new ConCreateFlyWeight("D");
                flyWeightFactory.hashtable.Add("D",conCreateFlyWeightD);
            }
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 享元工厂，负责创建和管理共享享元
    /// </summary>
    public class FlyWeightFactory
    {
        public Hashtable hashtable = new Hashtable();
        public FlyWeightFactory()
        {
            hashtable.Add("A", new ConCreateFlyWeight("A"));
            hashtable.Add("B", new ConCreateFlyWeight("B"));
            hashtable.Add("C", new ConCreateFlyWeight("C"));
        }
        public FlyWeight GetFlyWeight(String key)
        {
            return hashtable[key] as FlyWeight;
        }
    }
    /// <summary>
    /// 抽象享元类，提供享元具体方法
    /// </summary>
    public abstract class FlyWeight
    {
        public abstract void Operation(int extstate);
    }
    /// <summary>
    /// 具体享元对象，使实例的时候共享同一个字段（内部状态）
    /// </summary>
    public class ConCreateFlyWeight : FlyWeight
    {
        private string _intstate;
        public ConCreateFlyWeight(string intstate)
        {
            this._intstate = intstate;
        }
        public override void Operation(int extstat)
        {
            Console.WriteLine("内{0},外{1}", _intstate, extstat);
        }
    }
}

12、代理模式

namespace DesignModel8
{
    /// <summary>
    /// 代理模式
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Person buyPerson = new BuyPerson();
            buyPerson.BuyAny();
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 抽象类定义购物方法
    /// </summary>
    public abstract class Person
    {
        public abstract void BuyAny();
    }
    /// <summary>
    /// 购买人
    /// </summary>
    public class WantBuyPerson : Person
    {
        public override void BuyAny()
        {
            Console.WriteLine("杰克：帮我买一个手机");
        }
    }
    /// <summary>
    /// 代购人
    /// </summary>
    public class BuyPerson : Person
    {
        /// <summary>
        /// 定义被代理的类
        /// </summary>
        WantBuyPerson wantBuyPerson;
        public override void BuyAny()
        {
            if (wantBuyPerson==null)
            {
                wantBuyPerson = new WantBuyPerson();//类的实例化
            }
            this.PreBuyAny();
            //通过实例代理调用
            wantBuyPerson.BuyAny();
            this.PostBuyAny();
        }
        public void PreBuyAny()
        {
            Console.WriteLine("肉丝开始罗列清单：");
        }
        public void PostBuyAny()
        {
            Console.WriteLine("肉丝采购后分配给杰克");
        }
    }
}

13、模板模式

namespace DesignModel9
{
    /// <summary>
    /// 模板模式
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            CookFood cookFoodEgg = new Egg();
            cookFoodEgg.CookVegetable();
            cookFoodEgg = new JianJiao();
            cookFoodEgg.CookVegetable();
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 模板类
    /// </summary>
    public abstract class CookFood
    {
        public void CookVegetable()
        {
            this.PourOil();
            this.HotOil();
            AddVegetable();
            this.Fire();
        }
        void PourOil()
        {
            Console.WriteLine("倒油");
        }
        void HotOil()
        {
            Console.WriteLine("油温加热");
        }
       public abstract void AddVegetable();
        void Fire()
        {
            Console.WriteLine("翻炒");
        }
    }
    /// <summary>
    /// 模板类继承
    /// </summary>
    public class Egg : CookFood
    {
        public override void AddVegetable()
        {
            Console.WriteLine("煎蛋");
        }
    }
    public class JianJiao : CookFood
    {
        public override void AddVegetable()
        {
            Console.WriteLine("煎饺");
        }
    }
}

14、命令者模式

namespace DesignModel91
{
    /// <summary>
    /// 命令者模式
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Recevicer recevicer = new Recevicer();
            Command command = new ConCommand(recevicer);
            Invoke invoke = new Invoke(command);
            invoke.ExecuteCommand();
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 命令接收执行者
    /// </summary>
    public class Recevicer
    {
        public void Run()
        {
            Console.WriteLine("好的");
        }
    }
    public abstract class Command
    {
        protected Recevicer _recevicer;
        public Command(Recevicer recevicer)
        {
            this._recevicer = recevicer;
        }
        public abstract void Action();
    }
    /// <summary>
    /// 托管人
    /// </summary>
    public class Invoke
    {
        private Command _command;
        public Invoke(Command command)
        {
           this._command = command;
        }
        public void ExecuteCommand()
        {
            _command.Action();
        }
    }
    public class ConCommand : Command
    {
        public ConCommand(Recevicer recevicer):base(recevicer)
        {

        }
        public override void Action()
        {
            _recevicer.Run();
        }
    }
}

15、迭代模式

namespace DesignModel92
{
    /// <summary>
    /// 迭代模式
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Iterator iterator;
            IListConnection list = new ConCreateList();
            iterator = list.GetIterator();
            while (iterator.MoveNext())
            {
                int i = (int)iterator.GetCurrent();
                Console.WriteLine(i.ToString());
                iterator.Next();
            }
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 迭代抽象类
    /// </summary>
    public interface Iterator
    {
        void Next();
        bool MoveNext();
        object GetCurrent();
        void Reset();
    }
    /// <summary>
    /// 抽象聚合类
    /// </summary>
    public interface IListConnection
    {
        Iterator GetIterator();
    }
    /// <summary>
    /// 具体聚合类
    /// </summary>
    public class ConCreateList : IListConnection
    {
        int[] collection;
        public ConCreateList()
        {
            collection = new int[] { 1, 2, 3, 4, 5, 6 };
        }
        public Iterator GetIterator()
        {
            return new ConCreateIterator(this);
        }
        public int Length
        {
            get { return collection.Length; }
        }
        public int GetElement(int index)
        {
            return collection[index];
        }
    }
    /// <summary>
    /// 具体迭代器类
    /// </summary>
    public class ConCreateIterator : Iterator
    {
        private ConCreateList _conCreateList;
        private int _index;
        public ConCreateIterator(ConCreateList conCreateList)
        {
            this._conCreateList = conCreateList;
            _index = 0;
        }
        public object GetCurrent()
        {
            return _conCreateList.GetElement(_index);
        }

        public bool MoveNext()
        {
            if (_index<_conCreateList.Length)
            {
                return true;
            }
            return false;
        }

        public void Next()
        {
            if (_index<_conCreateList.Length)
            {
                _index++;
            }
        }

        public void Reset()
        {
            _index = 0;
        }
    }
}

16、 观察者模式

namespace DesignModel93
{
    /// <summary>
    /// 观察者模式
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            WeGame weGame = new WeGame();
            Subscriber subscriber = new Subscriber("小明");
            weGame.subscriber = subscriber;
            weGame.Symbol = "wegame";
            weGame.Info = "上古更新了";
            //发布者更新给订阅者
            weGame.Update();
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 发布者
    /// </summary>
    public class WeGame
    {
        public Subscriber subscriber;
        public string Symbol { get; set; }
        public string Info { get; set; }
        public void Update()
        {
            if (subscriber!=null)
            {
                subscriber.ReceiveAndPrintf(this);
            }
        }

    }
    /// <summary>
    /// 订阅者
    /// </summary>
    public class Subscriber
    {
        public string _name;
        public Subscriber(string name)
        {
            this._name = name;
        }
        public void ReceiveAndPrintf(WeGame weGame)
        {
            Console.WriteLine($"{_name}收到{weGame.Symbol}的{weGame.Info}");
        }
    }
}

17、中介者模式

namespace DesignModel94
{
    /// <summary>
    /// 中介者模式
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            PeopleA peopleA = new PeopleA();
            PeopleB peopleB = new PeopleB();
            peopleA.MoneyCount = 200;
            peopleB.MoneyCount = 50;
            peopleB.ChangeCount(20,peopleA);
            Console.WriteLine(peopleA.MoneyCount);
            Console.WriteLine(peopleB.MoneyCount);

            Console.ReadKey();
        }
    }
    public abstract class YinHang
    {
        public int MoneyCount { get; set; }
        public YinHang()
        {
            MoneyCount = 0;
        }
        public abstract void ChangeCount(int count,YinHang yinHang);
    }
    public class PeopleA : YinHang
    {
        public override void ChangeCount(int count, YinHang yinHang)
        {
            this.MoneyCount +=count;
            yinHang.MoneyCount -=count;
        }
    }
    public class PeopleB : YinHang
    {
        public override void ChangeCount(int count, YinHang yinHang)
        {
            this.MoneyCount +=count;
            yinHang.MoneyCount -=count;
        }
    }
}

18、状态模式

namespace DesignModel95
{
    //状态模式
    class Program
    {
        static void Main(string[] args)
        {
            Account account = new Account("奖金");
            account.Deposit(200.00);
            account.Deposit(3000.00);
            account.PayInterest();
            account.Withdraw(3200.00);
            account.Withdraw(300.00);
            account.Deposit(5000000.00);
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 状态抽象类
    /// </summary>
    public abstract class State
    {
        public Account Account { get; set; }
        public double Balance { get; set; } //余额
        public double Interest { get; set; } //利率
        public double LowerLimit { get; set; } //下限
        public double UpperLimit { get; set; } //上限
        public abstract void Deposit(double amount); //存款
        public abstract void Withdraw(double amount); //取钱
        public abstract void PayInterest(); //获得的利息
    }
    /// <summary>
    /// 红色状态，透支，无利息，无法取款
    /// </summary>
    public class RedState : State
    {
        public RedState(State state)
        {
            this.Balance = state.Balance;
            this.Account = state.Account;
            Interest = 0.00;
            LowerLimit = -100.00;
            UpperLimit = 0.00;
        }
        public override void Deposit(double amount)
        {
            Balance += amount;
            StateChangeCheck();
        }

        public override void PayInterest()
        {
            throw new NotImplementedException();
        }

        public override void Withdraw(double amount)
        {
            Console.WriteLine("没有钱可以取了");
        }
        private void StateChangeCheck()
        {
            if (Balance>1000.00)
            {
                Account.state = new GoldState(this);
            }
           else if (Balance > UpperLimit)
            {
                Account.state = new SilverState(this);
            }
            
        }
    }
    /// <summary>
    /// 银色状态，正常，无利息
    /// </summary>
    public class SilverState : State
    {
        public SilverState(State state) : this(state.Balance, state.Account)
        {
        }
        public SilverState(double balance, Account account)
        {
            this.Balance = balance;
            this.Account = account;
            Interest = 0.00;
            LowerLimit = 0.00;
            UpperLimit = 1000.00;
        }
        public override void Deposit(double amount)
        {
            Balance += amount;
            StateChangeCheck();
        }

        public override void PayInterest()
        {
            Balance += Interest * Balance;
            StateChangeCheck();
        }

        public override void Withdraw(double amount)
        {
            Balance -= amount;
            StateChangeCheck();
        }
        private void StateChangeCheck()
        {
            if (Balance > UpperLimit)
            {
                Account.state = new GoldState(this);
            }
            else if (Balance < LowerLimit)
            {
                Account.state = new RedState(this);
            }
        }
    }
    /// <summary>
    /// 金色状态，有利息
    /// </summary>
    public class GoldState : State
    {
        public GoldState(State state)
        {
            this.Balance = state.Balance;
            this.Account = state.Account;
            Interest = 0.05;
            LowerLimit = 1000.00;
            UpperLimit = 1000000.00;

        }
        public override void Deposit(double amount)
        {
            Balance += amount;
            StateChangeCheck();
        }

        public override void PayInterest()
        {
            Balance += Interest * Balance;
            StateChangeCheck();
        }

        public override void Withdraw(double amount)
        {
            Balance -= amount;
            StateChangeCheck();
        }
        private void StateChangeCheck()
        {
            if (Balance < 0.00)
            {
                Account.state = new RedState(this);
            }
            else if (Balance < LowerLimit)
            {
                Account.state = new SilverState(this);
            }
        }
    }
    /// <summary>
    /// 账户
    /// </summary>
    public class Account
    {
        public State state { get; set; }
        public string Owner { get; set; }
        public Account(string owner)
        {
            this.Owner = owner;
            this.state = new SilverState(0.00, this);
        }
        public double Balance { get { return state.Balance; } }//余额
        //存款
        public void Deposit(double amount)
        {
            state.Deposit(amount);
            Console.WriteLine($"存入金额为{amount:C}");
            Console.WriteLine($"存款为{Balance:C}");
            Console.WriteLine($"账户状态为{this.state.GetType().Name}");
            Console.WriteLine();
        }
        public void Withdraw(double amount)
        {
            state.Withdraw(amount);
            Console.WriteLine($"取出金额为{amount:C}");
            Console.WriteLine($"存款为{Balance:C}");
            Console.WriteLine($"账户状态为{this.state.GetType().Name}");
            Console.WriteLine();
        }
        public void PayInterest()
        {
            state.PayInterest();
            Console.WriteLine($"---计算利息---");
            Console.WriteLine($"存款为{Balance:C}");
            Console.WriteLine($"账户状态为{this.state.GetType().Name}");
            Console.WriteLine();
        }
    }
}