《大话设计模式》快速学习-CSDN博客

本文链接：https://blog.csdn.net/big_good_boy/article/details/141827017

文章目录

第一章：简单工厂模式
- - 业务的封装：
  - 简单工厂模式：
第二章：策略模式与简单工厂的结合
- - 利用简单工厂和策略模式对简单工厂的改进（见第一章）
第六章：装饰模式
第七章：代理模式
第八章：工厂方法模式
第九章：原型模式
- - 浅赋值
  - 深复制
第十章：模板方法
第十一章：外观模式
第十二章：建造者模式
第十三章：观察者模式（事件委托代替）
第十四章：抽象工厂模式到简单工厂到反射
第十五章：状态模式
第十六章：适配器模式
第十八章：备忘录模式
第十九章：组合模式
二十一章：单例模式
第二十二章：桥接模式
第二十三章：命令模式
第二十四章：职责链模式
第二十五章：中介者模式
第二十六章：享元模式
第二十八章：访问者模式

第一章：简单工厂模式

业务的封装：

业务逻辑与界面逻辑分开，降低耦合度，容易维护或扩展

简单工厂模式：

将类的实例化（以基类作为引用类型以完成功能的子类创建实例）从客户端移到具体的类中，具有相同属性和功能的对象的抽象集合

class Program
{
    static void Main(string[] args)
    {
        // 客户端
        Console.WriteLine("normal,rebate");
        string typeDiscount = Console.ReadLine();
        CashSuper cs = CashFactory.createCashAccept(typeDiscount);
        Console.WriteLine("price:\n");
        double inputnum =  double.Parse(Console.ReadLine());
        double result =  cs.acceptCash(inputnum);
        Console.WriteLine(result);
    }
}

public abstract class CashSuper
{
    public abstract double acceptCash(double money);
}

public class CashNormal : CashSuper
{
    public override double acceptCash(double money)
    {
        return money;
    }
}

public class CashRebate : CashSuper
{
    private double _disCount;
    public CashRebate(double disCount)
    {
        _disCount = disCount;
    }

    public override double acceptCash(double money)
    {
        return money * _disCount;
    }
}

public class CashFactory
{
    public static CashSuper createCashAccept(string cashType)
    {
        CashSuper cashSuper = null;

        switch (cashType)
        {
            case "normal":
                cashSuper = new CashNormal();
                break;
            case "rebate":
                cashSuper = new CashRebate(0.4);
                break;
        }
        return cashSuper;
    }
}

第二章：策略模式与简单工厂的结合

适用场景：工厂不变，策略/算法改变，不同时间点应用不同的业务规则（封装变化点/封装算法）

优点：

定义一系列算法，通过相同的方式调用所有的算法，以不同的方式，完成相同的工作
通过继承析取算法中的公共功能
简化了单元测试，通过算法各自的类，实现接口单独测试

Context：初始化时传入具体的策略对象，根据具体的策略对象调用其算法

利用简单工厂和策略模式对简单工厂的改进（见第一章）

耦合程度更低

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("normal,rebate");
        string typeDiscount = Console.ReadLine();
        CashContext cc = new CashContext(typeDiscount);
        Console.WriteLine("price:\n");
        double inputnum =  double.Parse(Console.ReadLine());
        double result = cc.GetResult(inputnum);
        Console.WriteLine(result);
    }
}


public class CashContext
{
    CashSuper cashSuper = null;
    public CashContext (string cashType)
    {
        switch (cashType)
        {
            case "normal":
                cashSuper = new CashNormal();
                break;
            case "rebate":
                cashSuper = new CashRebate(0.4);
                break;
        }
    }

    public double GetResult(double money)
    {
        return cashSuper.acceptCash(money);
    }

}

第六章：装饰模式

将类的装饰功能（特定情况下的特殊行为）从类中搬移，化简原有类

class Program
{
    static void Main(string[] args)
    {
        Person my = new Person("X");
        Tshirts tshirts = new Tshirts();
        Trouser trouser = new Trouser();
        tshirts.SetComponent(my);
        trouser.SetComponent(tshirts);
        trouser.Show();
    }
}

public class Person
{
    private string _name;
    public Person(string name)
    {
        this._name = name;
    }

    public Person()
    {

    }

    public virtual void Show()
    {
        Console.WriteLine($"{_name}'s showTime");
    }
}

public class Finery : Person
{
    private Person component;

    // decoration
    public void SetComponent(Person component)
    {
        this.component = component;
    }

    public override void Show()
    {
        component?.Show();
    }
}

public class Tshirts : Finery
{
    public override void Show()
    {
        base.Show();
        // extra function
        Console.WriteLine($"Tshirts ");
    }
}

public class Trouser : Finery
{
    public override void Show()
    {
        base.Show();
        // extra function
        Console.WriteLine($"Trouser ");
    }
}

第七章：代理模式

用途：远程代理、虚拟代理、安全代理、智能代理

class Program
{
    static void Main(string[] args)
    {
        Proxy proxy = new Proxy();
        proxy.Request();
    }
}

public abstract class Subject
{
    public abstract void Request();
}

public class RealSubject : Subject
{
    public override void Request()
    {
        Console.WriteLine($"Real massage");
    }
}

public class Proxy : Subject
{
    private RealSubject rs;

    public override void Request()
    {
        if(rs==null)
            rs = new RealSubject();
        Console.WriteLine($"pass proxy:\n");
        rs.Request();
    }

}

第八章：工厂方法模式

定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类（将实例化延迟到其子类）

简单工厂

优点：工厂类包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关类。客户端减少了对具体产品的依赖
缺点：增加功能时，在工厂类中增加case分支条件，违背了开闭原则

工厂方法模式（先创建工厂接口，在为各自功能创建具体工厂）：

优点：克服开闭原则，保持封装特点
缺点：每增加一个产品需要增加一个产品工厂的类

class Program
    {
        static void Main(string[] args)
        {
            // 客户端
            Console.WriteLine("normal,rebate");
            string typeDiscount = Console.ReadLine();
            IFactory factory;
            if (typeDiscount == "normal")
            {
                factory = new CashNormalFactory();
            }
            else
            {
                factory = new CashRebateFactory();
            }

            CashSuper cs = factory.CreateCashSuper();
            Console.WriteLine("price:\n");
            double inputnum = double.Parse(Console.ReadLine());
            double result = cs.acceptCash(inputnum);
            Console.WriteLine(result);
        }
    }

    

    public interface IFactory
    {
        CashSuper CreateCashSuper();
    }

    public class CashNormalFactory : IFactory
    {
        public CashSuper CreateCashSuper()
        {
            return new CashNormal();
        }
    }

    public class CashRebateFactory : IFactory
    {
        public CashSuper CreateCashSuper()
        {
            return new CashRebate(0.5f);
        }
    }

第九章：原型模式

用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象

浅赋值

值变量复制，引用变量仍然指向原来对象

class Program
{
    static void Main(string[] args)
    {
        Resume resume = new Resume("x");
        resume.SetPersonInfo("boy", "20");
        resume.SetWorkExperience("33", "aaa");


        Resume resume1 = (Resume)resume.Clone();
        resume1.SetWorkExperience("22", "bbb");

        resume.Show();
        resume1.Show();
    }
}

public class Resume : ICloneable
{
    private string _name;
    private string _sex;
    private string _age;

    private WorkExperience we;
    public Resume(string name)
    {
        this._name = name;
        we = new WorkExperience();

    }

    public void SetPersonInfo(string sex,string age)
    {
        this._sex = sex;
        this._age = age;
    }

    public void SetWorkExperience(string timeArea, string company)
    {
        we.Company = company;
        we.WorkDate = timeArea;
    }

    public object Clone()
    {
        return (Resume)this.MemberwiseClone();
    }

    public void Show()
    {
        Console.WriteLine($"{_name} {_sex} {_age}\n工作经历:{we.WorkDate} {we.Company}");
    }
}

public class WorkExperience
{
    private string _workDate;

    public string WorkDate
    {
        get { return _workDate; }
        set { _workDate = value; }
    }

    private string _company;

    public string Company
    {
        get { return _company; }
        set { _company = value; }
    }
}

深复制

引用对象的变量指向复制过的新对象

第十章：模板方法

定义一个操作中算法的骨架，将一些步骤延迟到子类中实现

（将不变的行为放到骨架中，将可变的行为放到子类中，以多态的方式完成）

class Program
{
    static void Main(string[] args)
    {
        AbstractClass abstractClass;
        abstractClass = new ConcreteClass();
        abstractClass.TemplateMethod();
    }
}

public abstract class AbstractClass
{
    public void TemplateMethod()
    {
        int a =  PrimitiveOperation1();
        int b = PrimitiveOperation2();
        Console.WriteLine(a+b);
    }

    public abstract int PrimitiveOperation1();

    public abstract int PrimitiveOperation2();
}

public class ConcreteClass: AbstractClass
{
    public override int PrimitiveOperation1()
    {
        return 1;
    }

    public override int PrimitiveOperation2()
    {
        return 2;
    }
}

第十一章：外观模式

使用环境：

设计初期：数据层、业务层、表示层
开发期：将部分类集中组成接口，减少依赖
维护大系统

class Program
{
    static void Main(string[] args)
    {
        Facade facade = new Facade();

        facade.MethodA(); 
        facade.MethodB(); 
    }
}

class Facade
{
    private SubSystemOne one;
    private SubSystemTwo Two;
    private SubSystemThree Three;
    public Facade()
    {
        one = new SubSystemOne();
        Two = new SubSystemTwo();
        Three = new SubSystemThree();
    }

    public void MethodA()
    {
        Console.WriteLine("\nMethodA");
        one.MethodOne();
        Two.MethodTwo();
        Three.MethodThree();
    }

    public void MethodB()
    {
        Console.WriteLine("\nMethodB");
        Two.MethodTwo();
        Three.MethodThree();
        one.MethodOne();
    }
}

class SubSystemOne
{
    public void MethodOne()
    {
        Console.WriteLine($"MethodOne");
    }
}

class SubSystemTwo
{
    public void MethodTwo()
    {
        Console.WriteLine($"MethodTwo");
    }
}

class SubSystemThree
{
    public void MethodThree()
    {
        Console.WriteLine($"MethodThree");
    }
}

第十二章：建造者模式

当创建复杂对象的算法应当独立其组成部分以及装配方法时所适用

class Program
    {
        static void Main(string[] args)
        {
            ConcreteBuilder concreteBuilder = new ConcreteBuilder();
            Director director = new Director(concreteBuilder);
            director.Construct();
        }
    }

    public class Product
    {
        private List<String> partList = new List<string>();

        public void AddPart(string newString)
        {
            partList.Add(newString);
        }

        public void Show()
        {
            foreach (var item in partList)
            {
                Console.WriteLine(item) ;
            }
        }
    }

    public abstract class Builder
    {
       public abstract void PartA();
       public abstract void PartB();
       public abstract void Show();
    }

    public class ConcreteBuilder : Builder
    {
        private Product product = new Product();
        public override void PartA()
        {
            product.AddPart("a");
        }

        public override void PartB()
        {
            product.AddPart("b");
        }

        public override void Show()
        {
            product.Show();
        }
    }

    public class Director {
        private Builder builder;
        public Director(Builder builder)
        {
            this.builder = builder;
        }
        
        public void Construct()
        {
            builder.PartA();
            builder.PartB();
            builder.Show();
        }
    }

第十三章：观察者模式（事件委托代替）

解除耦合，让耦合的双方都依赖抽象

第十四章：抽象工厂模式到简单工厂到反射

单一数据表与单一数据库

抽象工厂模式

多张数据表与多个数据库

下面代码有成员膨胀，可用泛型接口什么的替换…

class Program
{
    static void Main(string[] args)
    {
        User user = new User();
        Department department = new Department();
        IFactory factory = new AccessFactory();
        IUser iUser =  factory.CreateUser();
        iUser.Insert(user);
        iUser.GetUser(1);

        IDepartment iDepartment = factory.CreateDepartment();
        iDepartment.Insert(department);
        iDepartment.GetDepartment(2);
    }
}

public class User {
    private int _id;

    public int ID
    {
        get { return _id; }
        set { _id = value; }
    }

    private int _name;

    public int name
    {
        get { return _name; }
        set { _name = value; }
    }

}

public class Department
{
    private int _id;

    public int ID
    {
        get { return _id; }
        set { _id = value; }
    }

    private int _name;

    public int name
    {
        get { return _name; }
        set { _name = value; }
    }

}

public interface IDepartment
{
    void Insert(Department department);
    User GetDepartment(int id);
}

public class SqlserverDepartment : IDepartment
{
    public void Insert(Department department)
    {
        Console.WriteLine($"SqlserverUser____insert{department.name},id:{department.ID}");
    }
    public User GetDepartment(int id)
    {
        Console.WriteLine($"SqlserverUser____id:{id},user:...");
        return null;
    }
}

public class AccessDepartment : IDepartment
{
    public void Insert(Department department)
    {
        Console.WriteLine($"AccessUser____insert{department.name},id:{department.ID}");
    }
    public User GetDepartment(int id)
    {
        Console.WriteLine($"AccessUser____id:{id},user:...");
        return null;
    }
}



public interface IUser
{
    void Insert(User user);
    User GetUser(int id);
}

public class SqlserverUser: IUser
{
    public void Insert(User user)
    {
        Console.WriteLine($"SqlserverUser____insert{user.name},id:{user.ID}");
    }
    public User GetUser(int id)
    {
        Console.WriteLine($"SqlserverUser____id:{id},user:...");
        return null;
    }
}

public class AccessUser : IUser
{
    public void Insert(User user)
    {
        Console.WriteLine($"AccessUser____insert{user.name},id:{user.ID}");
    }
    public User GetUser(int id)
    {
        Console.WriteLine($"AccessUser____id:{id},user:...");
        return null;
    }
}


public interface IFactory
{
    IUser CreateUser();
    IDepartment CreateDepartment();
}

public class SqlserverFactory : IFactory
{
    public IDepartment CreateDepartment()
    {
        return new SqlserverDepartment();
    }

    public IUser CreateUser()
    {
        return new SqlserverUser();
    }
}

public class AccessFactory : IFactory
{
    public IDepartment CreateDepartment()
    {
        return new AccessDepartment();
    }

    public IUser CreateUser()
    {
        return new AccessUser();
    }
}

简单工厂模式

class Program
{
    static void Main(string[] args)
    {
        User user = new User();
        Department department = new Department();


        IUser iUser = DataAccess.CreateUser();
        iUser.Insert(user);
        iUser.GetUser(1);

        IDepartment iDepartment = DataAccess.CreateDepartment();
        iDepartment.Insert(department);
        iDepartment.GetDepartment(2);
    }
}


public class DataAccess
{
    private static readonly string db = "sql";

    public static IUser CreateUser()
    {
        IUser result = null;
        switch (db)
        {
            case "sql":
                result = new SqlserverUser();
                break;
            case "access":
                result = new AccessUser();
                break;
        }
        return result;
    }

    public static IDepartment CreateDepartment()
    {
        IDepartment result = null;
        switch (db)
        {
            case "sql":
                result = new SqlserverDepartment();
                break;
            case "access":
                result = new AccessDepartment();
                break;
        }
        return result;
    }
}

反射（取代工厂）

通过反射去除switch或if，解除分支判断带来的耦合

public class DataAccess
{
    //private static readonly string db = "sql";
    private static readonly string AssemblyName = "ConsoleApp4";
    private static readonly string db = "Access";

public static IUser CreateUser()
{
    string className = AssemblyName + "." + db + "User";
    return (IUser)Assembly.Load(AssemblyName).CreateInstance(className);
}

public static IDepartment CreateDepartment()
{
    string className = AssemblyName + "." + db + "Department";
    return (IDepartment)Assembly.Load(AssemblyName).CreateInstance(className);
}

第十五章：状态模式

当一个对象的内在状态改变允许改变其行为，这个对象像是改变了类

适用场景：对象的行为取决于它的状态，在运行时刻根据状态改变它的行为

优点：定义新的子类增加新的状态的转换

class Program
{
    static void Main(string[] args)
    {
        Context context = new Context(new ConcreteStateA());
        context.Request();
        context.Request();
        context.Request();
    }
}

public class Context
{
    private State _state;

    public State State
    {
        get { return _state; }
        set { _state = value; }
    }

    public Context(State currentState)
    {
        _state = currentState;
    }

    public void SetState(State nextState)
    {
        _state = nextState;
    }

    public void Request()
    {
        _state.Handle(this);
    }
}


public abstract class State
{
    public abstract void Handle(Context context);
}

public class ConcreteStateA : State
{
    public override void Handle(Context context)
    {
        Console.WriteLine("ConcreteState:A\nnext:\n");
        context.SetState(new ConcreteStateB());
    }
}

public class ConcreteStateB : State
{
    public override void Handle(Context context)
    {
        Console.WriteLine("ConcreteState:B\nnext:\n");
        context.SetState(new ConcreteStateA());
    }
}

第十六章：适配器模式

两个类做相同或相似的事情，具有不同的接口

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

public class Target
{
    public virtual void Request() { Console.WriteLine("NormalRequest!"); };
}

public class Adapter : Target
{
    private Adaptee adaptee;
    public override void Request()
    {
        adaptee.SpecificRequest();
    }
}

public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("SpecificRequest!");
    }
}

第十八章：备忘录模式

不破坏封装性的前提下，捕获一个对象内部状态，在对象之外保存状态

状态数据过大，会很消耗内存

class Program
{
    static void Main(string[] args)
    {
        Originator o = new Originator();
        o.State = "On";
        o.Show();

        Caretaker c = new Caretaker();
        c.Memento = o.CreateMemento();

        o.State = "Off";
        o.Show();

        o.SetMemento(c.Memento);
        o.Show();
    }
}

class Originator
{
    private string _state;

    public string State
    {
        get { return _state; }
        set { _state = value; }
    }

    public void SetMemento(Memento memento)
    {
        _state = memento.State;
    }

    public Memento CreateMemento()
    {
        return new Memento(_state);
    }

    public void Show()
    {
        Console.WriteLine(_state);
    }
}

class Memento
{
    public string State { get; private set; }

    public Memento(string state)
    {
        State = state;
    }
}

class Caretaker
{
    private Memento memento;

    public Memento Memento
    {
        get { return memento; }
        set { memento = value; }
    }

}

第十九章：组合模式

对象组合成树形结构表示，用户对单个对象和组合对象的使用具有一致性

class Program
{
    static void Main(string[] args)
    {
        Composite root = new Composite("Root");
        root.Add(new Leaf("leaf A"));
        root.Add(new Leaf("leaf B"));

        Composite composite1 = new Composite("composite1");
        composite1.Add(new Leaf("leaf C"));
        composite1.Add(new Leaf("leaf D"));

        root.Add(composite1);

        Composite composite2 = new Composite("composite2");
        composite2.Add(new Leaf("leaf E"));
        composite2.Add(new Leaf("leaf F"));

        composite1.Add(composite2);

        root.Display(1);
    }
}

public abstract class Component
{
    protected string _name;
    public Component(string name)
    {
        _name = name;
    }

    public abstract void Add(Component component);
    public abstract void Remove(Component component);
    public abstract void Display(int depth);
}

public class Leaf : Component
{
    public Leaf(string Name):base(Name)
    {
    }

    public override void Add(Component component)
    {
    }

    public override void Display(int depth)
    {
        Console.WriteLine(new string('-',depth) + _name);
    }

    public override void Remove(Component component)
    {
    }
}

public class Composite : Component
{
    private List<Component> components = new List<Component>();
    public Composite(string name) : base(name)
    {
    }

    public override void Add(Component component)
    {
        components.Add(component);
    }


    public override void Display(int depth)
    {
        Console.WriteLine(new string('-', depth) + _name);
        foreach (var item in components)
        {
            item.Display(depth + 2);
        }
    }

    public override void Remove(Component component)
    {
        components.Remove(component);
    }
}

二十一章：单例模式

一个类仅有一个实例，并提供一个全局访问点（全局访问和实例化控制）

原理：

私有化构造器，外界不能用new创建实例
创建公共方法获得实例的全局访问点
让类自身负责保存它的唯一实例

单线程锁定

class Program
{
    static void Main(string[] args)
    {
        Singleton s1 = Singleton.GetInstance();
        Singleton s2 = Singleton.GetInstance();
        Console.WriteLine(s1==s2? "true":"false");
    }
}

class Singleton {
    // 让类自身负责保存它的唯一实例
    private static Singleton instance;
    // 私有化构造器，外界不能用new创建实例
    private Singleton()
    {

    }
    // 创建公共方法获得实例的全局访问点
    public static Singleton GetInstance()
    {
        if(instance == null)
        {
            instance =  new Singleton();
        }
        return instance;
    }

}

多线程下的双重锁定（被引用实例化）

单锁模式：每次调用实例方法都要进行lock，影响性能
双锁模式：只有第一次进行实例化时进行锁定，并且是lock多线程锁定

class Singleton {
    private static Singleton instance;
    private static readonly object syncRoot = new object();
    private Singleton()
    {

    }
    public static Singleton GetInstance()
    {
        // 双锁
        if (instance == null)
        {
            // 单锁
            lock (syncRoot)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

静态初始化（被加载实例化）

sealed 防止派生
readonly 被加载实例化

public sealed class Singleton {
    private static readonly Singleton instance = new Singleton();
    private Singleton(){}
    public static Singleton GetInstance()
    {
    	return instance;
    }
}

第二十二章：桥接模式

将抽象部分与实现部分分离/实现系统多角度分类时，每种分类都有变化可能，通过分离独立，减少耦合

class Program
{
    static void Main(string[] args)
    {
        Brand brand;
        brand = new M();
        brand.SetSoft(new Game());
        brand.Run();
    }
}

public abstract class Soft
{
    public abstract void Run();
}

public class Game : Soft
{
    public override void Run()
    {
        Console.WriteLine("Run game");
    }
}

public class Address:Soft
{
    public override void Run()
    {
        Console.WriteLine("Run Address");
    }
}

public abstract class Brand
{
    public abstract void Run();

    protected Soft _soft;

    public void SetSoft(Soft soft)
    {
        this._soft = soft;
    }
}
public class M : Brand
{
    public override void Run()
    {
        _soft.Run();
    }
}

public class N : Brand
{
    public override void Run()
    {
        _soft.Run();
    }
}

第二十三章：命令模式

请求封装为对象，对不同请求参数化：排队、记录、可撤销

真正需要撤销或恢复操作时，进行重构

class Program
{
    static void Main(string[] args)
    {
        Barbecuer boy = new Barbecuer();
        BakeChickenWingCommand wingCommand = new BakeChickenWingCommand(boy);
        BakeMuttonCommand muttonCommand = new BakeMuttonCommand(boy);
        Waiter waiter = new Waiter();

        waiter.Order(wingCommand);
        waiter.Order(muttonCommand);
        waiter.Order(muttonCommand);
        waiter.Order(wingCommand);
        waiter.Order(wingCommand);
        waiter.CancelOrder(wingCommand);

        waiter.Notify();

    }
}

public class Waiter
{
    private List<Command> commands = new List<Command>();
    public void Order(Command command)
    {
        if (command.ToString() == "ConsoleApp3.BakeMuttonCommand")
        {
            Console.WriteLine("no Mutton!");
        }
        else
        {
            commands.Add(command);
            Console.WriteLine($"add:{command.ToString()},Time:{DateTime.UtcNow.ToString()}");
        }
    }

    public void CancelOrder(Command command)
    {
        if (commands.Contains(command))
        {
            commands.Remove(command);
            Console.WriteLine($"remove:{command.ToString()},Time:{DateTime.UtcNow.ToString()}");
        }
    }

    public void Notify()
    {
        foreach (var command in commands)
        {
            command.ExcuteCommand();
        }
    }
}

public abstract class Command
{
    protected Barbecuer barbecuer;
    public Command(Barbecuer barbecuer)
    {
        this.barbecuer = barbecuer;
    }

    public abstract void ExcuteCommand();
}

public class BakeMuttonCommand : Command
{
    public BakeMuttonCommand(Barbecuer barbecuer):base(barbecuer)
    {

    }

    public override void ExcuteCommand()
    {
        barbecuer.BakeMutton();
    }
}

public class BakeChickenWingCommand : Command
{
    public BakeChickenWingCommand(Barbecuer barbecuer) : base(barbecuer)
    {

    }

    public override void ExcuteCommand()
    {
        barbecuer.BakeChickenWing();
    }
}

public class Barbecuer
{
    public void BakeMutton()
    {
        Console.WriteLine("BakeMutton");
    }

    public void BakeChickenWing()
    {
        Console.WriteLine("BakeChickenWing");
    }
}

第二十四章：职责链模式

多个对象都有机会处理请求，避免请求的发送者与接收者之间的耦合关系

好处：保持一个后继者的引用，不需要保持所有候选者的引用

重点：设置后继者，处理请求的判断（处理Or转移）

class Program
{
    static void Main(string[] args)
    {
        JL jL = new JL("jL");
        ZJ zJ = new ZJ("ZJ");
        ZJL zJL = new ZJL("ZJL");
        jL.SetSuperior(zJ);
        zJ.SetSuperior(zJL);

        Request request1 = new Request() 
        { Amount = 9, RequestContent = "leave", RequestType = "normal" };
        jL.RequestApp(request1);

        Request request2 = new Request()
        { Amount = 29, RequestContent = "leave", RequestType = "normal" };
        jL.RequestApp(request2);

        Request request3 = new Request()
        { Amount = 49, RequestContent = "leave", RequestType = "normal" };
        jL.RequestApp(request3);

        Request request4 = new Request()
        { Amount = 69, RequestContent = "leave", RequestType = "normal" };
        jL.RequestApp(request4);
    }
}

public class Request
{
    private string requestType;

    public string RequestType
    {
        get { return requestType; }
        set { requestType = value; }
    }

    private string requestContent;

    public string RequestContent
    {
        get { return requestContent; }
        set { requestContent = value; }
    }

    private int amount;

    public int Amount
    {
        get { return amount; }
        set { amount = value; }
    }

}

public abstract class Manager
{
    private string _name;

    public Manager(string name)
    {
        _name = name;
    }

    protected Manager superior;

    public void SetSuperior(Manager manager)
    {
        superior = manager;
    }

    public abstract void RequestApp(Request request);
}

public class JL : Manager
{
    public JL(string name) : base(name)
    {
    }

    public override void RequestApp(Request request)
    {
        Console.WriteLine("\n new request:\n");
        if (request.Amount<=10)
        {
            Console.WriteLine($"your {request.Amount} request is accepted by JL");
        }
        else
        {
            Console.WriteLine("JL can't accept those requests...");
            superior.RequestApp(request);
        }
    }
}

public class ZJ : Manager
{
    public ZJ(string name) : base(name)
    {
    }

    public override void RequestApp(Request request)
    {
        if (request.Amount <= 30)
        {
            Console.WriteLine($"your {request.Amount} request is accepted by ZJ");
            }
            else
            {
                Console.WriteLine("ZJ can't accept those requests...");
                superior.RequestApp(request);
            }
        }
    }

    public class ZJL : Manager
    {
        public ZJL(string name) : base(name)
        {
        }

        public override void RequestApp(Request request)
        {
            if (request.Amount <= 50)
            {
                Console.WriteLine($"your {request.Amount} request is accepted by ZJL");
            }
            else
            {
                Console.WriteLine("ZJL can't accept those requests...");
            }
        }
    }

第二十五章：中介者模式

过程：

中介需要知道所有同事
同事需要订阅中介
发送消息都是通过中介

class Program
{
    static void Main(string[] args)
    {
        ALH unityConsitite = new ALH();
        American a = new American(unityConsitite);
        China c = new China(unityConsitite);

        unityConsitite.American = a;
        unityConsitite.China = c;

        a.Send("hhh");
        c.Send("www");
    }
}

public abstract class Country
{
    protected UnityConsitite unityConsitite;

    public Country(UnityConsitite unityConsitite)
    {
        this.unityConsitite = unityConsitite;
    }

}

public class American : Country
{
    public American(UnityConsitite unityConsitite):base(unityConsitite)
    {
    }

    public void Notify(string Message)
    {
        Console.WriteLine($"American recive:{Message}");
    }

    public void Send(string Message)
    {
        unityConsitite.Send(Message,this);
    }
}

public class China : Country
{
    public China(UnityConsitite unityConsitite) : base(unityConsitite)
    {
    }

    public void Notify(string Message)
    {
        Console.WriteLine($"China recive:{Message}");
    }

    public void Send(string Message)
    {
        unityConsitite.Send(Message, this);
    }
}

public abstract class UnityConsitite
{
    public abstract void Send(string Message, Country country);
}

public class ALH : UnityConsitite
{


    private American american;

    public American American
    {
        get { return american; }
        set { american = value; }
    }

    private China china;

    public China China
    {
        get { return china; }
        set { china = value; }
    }


    public override void Send(string Message, Country country)
    {
        if(country == american)
        {
            china.Notify(Message);
        }
        else
        {
            american.Notify(Message);
        }
    }
}

第二十六章：享元模式

运用共享技术有效地支持大量细粒度的对象

应用场合：大量的对象造成存储开销，对象大多数状态可以外部状态，利用较少的共享对象

class Program
{
    static void Main(string[] args)
    {
        WebFactory webFactory = new WebFactory();
        Web web1 = webFactory.Register("web1");
        web1.Use(new User("People1"));
        web1.Use(new User("People2"));

        Web web2 = webFactory.Register("web2");
        web2.Use(new User("People3"));
        web2.Use(new User("People4"));

        webFactory.Show();
    }
}

public class WebFactory
{
    private Hashtable flyweights = new Hashtable();
    public Web Register(string key)
    {
        if (!flyweights.ContainsKey(key))
        {
            flyweights.Add(key, new Concrete(key));
        }
        return (Web)flyweights[key];
    }

    public void Show()
    {
        Console.WriteLine(flyweights.Count);
    }
}

public abstract class Web
{
    public abstract void Use(User user);
}

public class Concrete : Web
{
    private string name = "";
    public Concrete(string name)
    {
        this.name = name;
    }
    public override void Use(User user)
    {
        Console.WriteLine($"{name}:{user.Name}");
    }
}

public class User {

    private string name;

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

    public User(string name)
    {
        this.name = name;
    }
}

第二十八章：访问者模式

作用于某对象结构中的各元素操作，在不改变各元素的类前提下，定义作用于这些元素的新操作

数据结构不变时

class Program
{
    static void Main(string[] args)
    {
        ObjectStructure o = new ObjectStructure();
        o.Attach(new ConcreteElementA());
        o.Attach(new ConcreteElementB());

        ConcreteVisitor1 v1 = new ConcreteVisitor1();
        ConcreteVisitor2 v2 = new ConcreteVisitor2();
        o.Accept(v1);
        o.Accept(v2);
    }
}

public abstract class Visitor
{
    public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);
    public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
}

public class ConcreteVisitor1 : Visitor
{
    public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
    {
        Console.WriteLine($"{concreteElementA.GetType().Name}被{this.GetType().Name}访问");
    }

    public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
    {
        Console.WriteLine($"{concreteElementB.GetType().Name}被{this.GetType().Name}访问");
    }
}

public class ConcreteVisitor2 : Visitor
{
    public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
    {
        Console.WriteLine($"{concreteElementA.GetType().Name}被{this.GetType().Name}访问");
    }

    public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
    {
        Console.WriteLine($"{concreteElementB.GetType().Name}被{this.GetType().Name}访问");
    }
}

public abstract class Element {
    public abstract void Accept(Visitor visitor);
}

public class ConcreteElementA : Element
{
    public override void Accept(Visitor visitor)
    {
        visitor.VisitConcreteElementA(this);
    }
}

public class ConcreteElementB : Element
{
    public override void Accept(Visitor visitor)
    {
        visitor.VisitConcreteElementB(this);
    }
}

public class ObjectStructure {
    private IList<Element> elements = new List<Element>();

    public void Attach(Element element)
    {
        elements.Add(element);
    }

    public void Remove(Element element)
    {
        elements.Remove(element);
    }

    public void Accept(Visitor visitor)
    {
        foreach (var e in elements)
        {
            e.Accept(visitor);
        }
    }

}