public sealed class Singleton
{
    //創(chuàng)建一個(gè)只讀的靜態(tài)Singleton實(shí)例
    private static readonly Singleton instance = new Singleton();
    // 記錄Singleton的創(chuàng)建次數(shù)
    private static int instanceCounter = 0;
    // 單例實(shí)例的公共訪問(wèn)點(diǎn)
    public static Singleton Instance
    {
        get
        {
            return instance;
        }
    }
    // 私有構(gòu)造函數(shù)
    private Singleton()
    {
        instanceCounter++;
        Console.WriteLine("Instances Created " + instanceCounter);
    }
    // 在此處添加其他的Singleton類方法
    public void LogMessage(string message)
    {
        Console.WriteLine("Message: " + message);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Singleton fromEmployee = Singleton.Instance;
        fromEmployee.LogMessage("Message from Employee");
        Singleton fromBoss = Singleton.Instance;
        fromBoss.LogMessage("Message from Boss");
        Console.ReadLine();
    }
}

// 抽象產(chǎn)品
public interface IProduct
{
    string Operation();
}
// 具體產(chǎn)品A
public class ProductA : IProduct
{
    public string Operation()
    {
        return "{Result of ProductA}";
    }
}
// 具體產(chǎn)品B
public class ProductB : IProduct
{
    public string Operation()
    {
        return "{Result of ProductB}";
    }
}
// 抽象創(chuàng)建者
public abstract class Creator
{
    public abstract IProduct FactoryMethod();
}
// 具體創(chuàng)建者A
public class CreatorA : Creator
{
    public override IProduct FactoryMethod()
    {
        return new ProductA();
    }
}
// 具體創(chuàng)建者B
public class CreatorB : Creator
{
    public override IProduct FactoryMethod()
    {
        return new ProductB();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 創(chuàng)建工廠對(duì)象
        Creator creatorA = new CreatorA();
        Creator creatorB = new CreatorB();
        // 通過(guò)工廠方法創(chuàng)建產(chǎn)品對(duì)象
        IProduct productA = creatorA.FactoryMethod();
        IProduct productB = creatorB.FactoryMethod();
        // 打印結(jié)果
        Console.WriteLine("ProductA says: " + productA.Operation());
        Console.WriteLine("ProductB says: " + productB.Operation());
        Console.ReadLine();
    }
}

// 抽象產(chǎn)品：動(dòng)物
public interface IAnimal
{
    string Speak();
}
// 具體產(chǎn)品：狗
public class Dog : IAnimal
{
    public string Speak()
    {
        return "Bark Bark";
    }
}
// 具體產(chǎn)品：貓
public class Cat : IAnimal
{
    public string Speak()
    {
        return "Meow Meow";
    }
}
// 抽象工廠
public abstract class IAnimalFactory
{
    public abstract IAnimal CreateAnimal();
}
// 具體工廠：狗工廠
public class DogFactory : IAnimalFactory
{
    public override IAnimal CreateAnimal()
    {
        return new Dog();
    }
}
// 具體工廠：貓工廠
public class CatFactory : IAnimalFactory
{
    public override IAnimal CreateAnimal()
    {
        return new Cat();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 創(chuàng)建工廠
        IAnimalFactory dogFactory = new DogFactory();
        IAnimalFactory catFactory = new CatFactory();
        // 使用工廠創(chuàng)建產(chǎn)品
        IAnimal dog = dogFactory.CreateAnimal();
        IAnimal cat = catFactory.CreateAnimal();
        // 打印結(jié)果
        Console.WriteLine("Dog says: " + dog.Speak());
        Console.WriteLine("Cat says: " + cat.Speak());
        Console.ReadLine();
    }
}

// 產(chǎn)品
public class Car
{
    public string Engine { get; set; }
    public string Wheels { get; set; }
    public string Doors { get; set; }
}
// 建造者抽象類
public abstract class CarBuilder
{
    protected Car car;
    public void CreateNewCar()
    {
        car = new Car();
    }
    public Car GetCar()
    {
        return car;
    }
    public abstract void SetEngine();
    public abstract void SetWheels();
    public abstract void SetDoors();
}
// 具體建造者
public class FerrariBuilder : CarBuilder
{
    public override void SetEngine()
    {
        car.Engine = "V8";
    }
    public override void SetWheels()
    {
        car.Wheels = "18 inch";
    }
    public override void SetDoors()
    {
        car.Doors = "2";
    }
}
// 指揮者
public class Director
{
    public Car Construct(CarBuilder carBuilder)
    {
        carBuilder.CreateNewCar();
        carBuilder.SetEngine();
        carBuilder.SetWheels();
        carBuilder.SetDoors();
        return carBuilder.GetCar();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Director director = new Director();
        CarBuilder builder = new FerrariBuilder();
        Car ferrari = director.Construct(builder);
        Console.WriteLine($"Engine: {ferrari.Engine}, Wheels: {ferrari.Wheels}, Doors: {ferrari.Doors}");
        Console.ReadLine();
    }
}

// 抽象原型
public interface IPrototype
{
    IPrototype Clone();
}
// 具體原型
public class ConcretePrototype : IPrototype
{
    public string Name { get; set; }
    public int Value { get; set; }
    public IPrototype Clone()
    {
        // 實(shí)現(xiàn)深拷貝
        return (ConcretePrototype)this.MemberwiseClone(); // Clones the concrete object.
    }
}

class Program
{
    static void Main(string[] args)
    {
        ConcretePrototype prototype = new ConcretePrototype();
        prototype.Name = "Original";
        prototype.Value = 10;
        Console.WriteLine("Original instance: " + prototype.Name + ", " + prototype.Value);
        ConcretePrototype clone = (ConcretePrototype)prototype.Clone();
        Console.WriteLine("Cloned instance: " + clone.Name + ", " + clone.Value);
        Console.ReadLine();
    }
}

// 實(shí)現(xiàn)類接口
public interface IImplementor
{
    void OperationImp();
}
// 具體實(shí)現(xiàn)類A
public class ConcreteImplementorA : IImplementor
{
    public void OperationImp()
    {
        Console.WriteLine("Concrete Implementor A");
    }
}
// 具體實(shí)現(xiàn)類B
public class ConcreteImplementorB : IImplementor
{
    public void OperationImp()
    {
        Console.WriteLine("Concrete Implementor B");
    }
}
// 抽象類
public abstract class Abstraction
{
    protected IImplementor implementor;
    public Abstraction(IImplementor implementor)
    {
        this.implementor = implementor;
    }
    public virtual void Operation()
    {
        implementor.OperationImp();
    }
}
// 擴(kuò)充的抽象類
public class RefinedAbstraction : Abstraction
{
    public RefinedAbstraction(IImplementor implementor) : base(implementor) { }
    public override void Operation()
    {
        Console.WriteLine("Refined Abstraction is calling implementor's method:");
        base.Operation();
    }
}

class Program
{
    static void Main(string[] args)
    {
        IImplementor implementorA = new ConcreteImplementorA();
        Abstraction abstractionA = new RefinedAbstraction(implementorA);
        abstractionA.Operation();
        IImplementor implementorB = new ConcreteImplementorB();
        Abstraction abstractionB = new RefinedAbstraction(implementorB);
        abstractionB.Operation();
        Console.ReadLine();
    }
}

// 抽象組件類
public abstract class Component
{
    protected string name;
    public Component(string name)
    {
        this.name = name;
    }
    public abstract void Add(Component c);
    public abstract void Remove(Component c);
    public abstract void Display(int depth);
}
// 葉節(jié)點(diǎn)類
public class Leaf : Component
{
    public Leaf(string name) : base(name) { }
    public override void Add(Component c)
    {
        Console.WriteLine("Cannot add to a leaf");
    }
    public override void Remove(Component c)
    {
        Console.WriteLine("Cannot remove from a leaf");
    }
    public override void Display(int depth)
    {
        Console.WriteLine(new String('-', depth) + name);
    }
}
// 構(gòu)件容器類
public class Composite : Component
{
    private List<Component> _children = new List<Component>();
    public Composite(string name) : base(name) { }
    public override void Add(Component component)
    {
        _children.Add(component);
    }
    public override void Remove(Component component)
    {
        _children.Remove(component);
    }
    public override void Display(int depth)
    {
        Console.WriteLine(new String('-', depth) + name);
        // 顯示每個(gè)節(jié)點(diǎn)的子節(jié)點(diǎn)
        foreach (Component component in _children)
        {
            component.Display(depth + 2);
        }
    }
}

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 comp = new Composite("Composite X");
        comp.Add(new Leaf("Leaf XA"));
        comp.Add(new Leaf("Leaf XB"));
        root.Add(comp);
        Composite comp2 = new Composite("Composite XY");
        comp2.Add(new Leaf("Leaf XYA"));
        comp2.Add(new Leaf("Leaf XYB"));
        comp.Add(comp2);
        root.Add(new Leaf("Leaf C"));
        // 在組合中添加和刪除
        Leaf leaf = new Leaf("Leaf D");
        root.Add(leaf);
        root.Remove(leaf);
        // 顯示樹(shù)形結(jié)構(gòu)
        root.Display(1);
        Console.ReadLine();
    }
}

// 抽象組件
public abstract class Component
{
    public abstract string Operation();
}
// 具體組件
public class ConcreteComponent : Component
{
    public override string Operation()
    {
        return "ConcreteComponent";
    }
}
// 抽象裝飾器
public abstract class Decorator : Component
{
    protected Component component;
    public Decorator(Component component)
    {
        this.component = component;
    }
    public override string Operation()
    {
        if (component != null)
        {
            return component.Operation();
        }
        else
        {
            return string.Empty;
        }
    }
}
// 具體裝飾器A
public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(Component comp) : base(comp) { }
    public override string Operation()
    {
        return $"ConcreteDecoratorA({base.Operation()})";
    }
}
// 具體裝飾器B
public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(Component comp) : base(comp) { }
    public override string Operation()
    {
        return $"ConcreteDecoratorB({base.Operation()})";
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 基本組件
        Component component = new ConcreteComponent();
        Console.WriteLine("Basic Component: " + component.Operation());
        // 裝飾后的組件
        Component decoratorA = new ConcreteDecoratorA(component);
        Console.WriteLine("A Decorated: " + decoratorA.Operation());
        Component decoratorB = new ConcreteDecoratorB(decoratorA);
        Console.WriteLine("B Decorated: " + decoratorB.Operation());
        Console.ReadLine();
    }
}

// 子系統(tǒng)A
public class SubSystemA
{
    public string OperationA()
    {
        return "SubSystemA, OperationA\n";
    }
}
// 子系統(tǒng)B
public class SubSystemB
{
    public string OperationB()
    {
        return "SubSystemB, OperationB\n";
    }
}
// 子系統(tǒng)C
public class SubSystemC
{
    public string OperationC()
    {
        return "SubSystemC, OperationC\n";
    }
}
// 外觀類
public class Facade
{
    private SubSystemA a = new SubSystemA();
    private SubSystemB b = new SubSystemB();
    private SubSystemC c = new SubSystemC();
    public string OperationWrapper()
    {
        string result = "Facade initializes subsystems:\n";
        result += a.OperationA();
        result += b.OperationB();
        result += c.OperationC();
        return result;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Facade facade = new Facade();
        Console.WriteLine(facade.OperationWrapper());
        Console.ReadLine();
    }
}

// 享元類
public class Flyweight
{
    private string intrinsicState;
    // 構(gòu)造函數(shù)
    public Flyweight(string intrinsicState)
    {
        this.intrinsicState = intrinsicState;
    }
    // 業(yè)務(wù)方法
    public void Operation(string extrinsicState)
    {
        Console.WriteLine($"Intrinsic State = {intrinsicState}, Extrinsic State = {extrinsicState}");
    }
}
// 享元工廠類
public class FlyweightFactory
{
    private Dictionary<string, Flyweight> flyweights = new Dictionary<string, Flyweight>();
    public Flyweight GetFlyweight(string key)
    {
        if (!flyweights.ContainsKey(key))
        {
            flyweights[key] = new Flyweight(key);
        }
        return flyweights[key];
    }
    public int GetFlyweightCount()
    {
        return flyweights.Count;
    }
}

class Program
{
    static void Main(string[] args)
    {
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight flyweightA = factory.GetFlyweight("A");
        flyweightA.Operation("A operation");
        Flyweight flyweightB = factory.GetFlyweight("B");
        flyweightB.Operation("B operation");
        Flyweight flyweightC = factory.GetFlyweight("A");
        flyweightC.Operation("C operation");
        Console.WriteLine($"Total Flyweights: {factory.GetFlyweightCount()}");
        Console.ReadLine();
    }
}

// 抽象主題接口
public interface ISubject
{
    void Request();
}
// 真實(shí)主題
public class RealSubject : ISubject
{
    public void Request()
    {
        Console.WriteLine("RealSubject: Handling Request.");
    }
}
// 代理
public class Proxy : ISubject
{
    private RealSubject _realSubject;
    public Proxy(RealSubject realSubject)
    {
        this._realSubject = realSubject;
    }
    public void Request()
    {
        if (this.CheckAccess())
        {
            this._realSubject.Request();
            this.LogAccess();
        }
    }
    public bool CheckAccess()
    {
        // 檢查是否有權(quán)限訪問(wèn)
        Console.WriteLine("Proxy: Checking access prior to firing a real request.");
        return true;
    }
    public void LogAccess()
    {
        // 記錄請(qǐng)求
        Console.WriteLine("Proxy: Logging the time of request.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Client: Executing the client code with a real subject:");
        RealSubject realSubject = new RealSubject();
        realSubject.Request();
        Console.WriteLine();
        Console.WriteLine("Client: Executing the same client code with a proxy:");
        Proxy proxy = new Proxy(realSubject);
        proxy.Request();
        Console.ReadLine();
    }
}

// 命令接口
public interface ICommand
{
    void Execute();
}
// 具體命令類
public class ConcreteCommand : ICommand
{
    private Receiver receiver;
    public ConcreteCommand(Receiver receiver)
    {
        this.receiver = receiver;
    }
    public void Execute()
    {
        receiver.Action();
    }
}
// 接收者類
public class Receiver
{
    public void Action()
    {
        Console.WriteLine("Receiver performs an action");
    }
}
// 調(diào)用者或發(fā)送者類
public class Invoker
{
    private ICommand command;
    public void SetCommand(ICommand command)
    {
        this.command = command;
    }
    public void ExecuteCommand()
    {
        command.Execute();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Receiver receiver = new Receiver();
        ICommand command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker();
        invoker.SetCommand(command);
        invoker.ExecuteCommand();
        Console.ReadLine();
    }
}

// 抽象表達(dá)式
public interface IExpression
{
    bool Interpret(string context);
}
// 終結(jié)符表達(dá)式
public class TerminalExpression : IExpression
{
    private string data;
    public TerminalExpression(string data)
    {
        this.data = data;
    }
    public bool Interpret(string context)
    {
        if (context.Contains(data))
        {
            return true;
        }
        return false;
    }
}
// 非終結(jié)符表達(dá)式
public class OrExpression : IExpression
{
    private IExpression expr1 = null;
    private IExpression expr2 = null;
    public OrExpression(IExpression expr1, IExpression expr2)
    {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }
    public bool Interpret(string context)
    {
        return expr1.Interpret(context) || expr2.Interpret(context);
    }
}

class Program
{
    static void Main(string[] args)
    {
        IExpression isMale = GetMaleExpression();
        IExpression isMarriedWoman = GetMarriedWomanExpression();
        Console.WriteLine($"John is male? {isMale.Interpret("John")}");
        Console.WriteLine($"Julie is a married women? {isMarriedWoman.Interpret("Married Julie")}");
        Console.ReadLine();
    }
    // 規(guī)則：Robert 和 John 是男性
    public static IExpression GetMaleExpression()
    {
        IExpression robert = new TerminalExpression("Robert");
        IExpression john = new TerminalExpression("John");
        return new OrExpression(robert, john);
    }
    // 規(guī)則：Julie 是一個(gè)已婚的女性
    public static IExpression GetMarriedWomanExpression()
    {
        IExpression julie = new TerminalExpression("Julie");
        IExpression married = new TerminalExpression("Married");
        return new OrExpression(julie, married);
    }
}

// 抽象聚合類
public interface IAggregate
{
    IIterator CreateIterator();
    void Add(string item);
    int Count { get; }
    string this[int index] { get; set; }
}
// 具體聚合類
public class ConcreteAggregate : IAggregate
{
    private List<string> items = new List<string>();
    public IIterator CreateIterator()
    {
        return new ConcreteIterator(this);
    }
    public int Count
    {
        get { return items.Count; }
    }
    public string this[int index]
    {
        get { return items[index]; }
        set { items.Insert(index, value); }
    }
    public void Add(string item)
    {
        items.Add(item);
    }
}
// 抽象迭代器
public interface IIterator
{
    string First();
    string Next();
    bool IsDone { get; }
    string CurrentItem { get; }
}
// 具體迭代器
public class ConcreteIterator : IIterator
{
    private ConcreteAggregate aggregate;
    private int current = 0;
    public ConcreteIterator(ConcreteAggregate aggregate)
    {
        this.aggregate = aggregate;
    }
    public string First()
    {
        return aggregate[0];
    }
    public string Next()
    {
        string ret = null;
        if (current < aggregate.Count - 1)
        {
            ret = aggregate[++current];
        }
        return ret;
    }
    public string CurrentItem
    {
        get { return aggregate[current]; }
    }
    public bool IsDone
    {
        get { return current >= aggregate.Count; }
    }
}

class Program
{
    static void Main(string[] args)
    {
        IAggregate aggregate = new ConcreteAggregate();
        aggregate.Add("Item A");
        aggregate.Add("Item B");
        aggregate.Add("Item C");
        aggregate.Add("Item D");
        IIterator iterator = aggregate.CreateIterator();
        Console.WriteLine("Iterating over collection:");
        string item = iterator.First();
        while (item != null)
        {
            Console.WriteLine(item);
            item = iterator.Next();
        }
        Console.ReadLine();
    }
}

// Mediator 接口聲明了與組件交互的方法。
public interface IMediator
{
    void Notify(object sender, string ev);
}
// 具體 Mediators 實(shí)現(xiàn)協(xié)作行為，它負(fù)責(zé)協(xié)調(diào)多個(gè)組件。
public class ConcreteMediator : IMediator
{
    private Component1 _component1;
    private Component2 _component2;
    public ConcreteMediator(Component1 component1, Component2 component2)
    {
        _component1 = component1;
        _component1.SetMediator(this);
        _component2 = component2;
        _component2.SetMediator(this);
    }
    public void Notify(object sender, string ev)
    {
        if (ev == "A")
        {
            Console.WriteLine("Mediator reacts on A and triggers following operations:");
            this._component2.DoC();
        }
        if (ev == "D")
        {
            Console.WriteLine("Mediator reacts on D and triggers following operations:");
            this._component1.DoB();
            this._component2.DoC();
        }
    }
}

public abstract class BaseComponent
{
    protected IMediator _mediator;
    public BaseComponent(IMediator mediator = null)
    {
        _mediator = mediator;
    }
    public void SetMediator(IMediator mediator)
    {
        this._mediator = mediator;
    }
}
// 具體 Components 實(shí)現(xiàn)各種功能。它們不依賴于其他組件。
// 它們也不依賴于任何具體 Mediator 類。
public class Component1 : BaseComponent
{
    public void DoA()
    {
        Console.WriteLine("Component 1 does A.");
        this._mediator.Notify(this, "A");
    }
    public void DoB()
    {
        Console.WriteLine("Component 1 does B.");
        this._mediator.Notify(this, "B");
    }
}
public class Component2 : BaseComponent
{
    public void DoC()
    {
        Console.WriteLine("Component 2 does C.");
        this._mediator.Notify(this, "C");
    }
    public void DoD()
    {
        Console.WriteLine("Component 2 does D.");
        this._mediator.Notify(this, "D");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // The client code.
        Component1 component1 = new Component1();
        Component2 component2 = new Component2();
        new ConcreteMediator(component1, component2);
        Console.WriteLine("Client triggers operation A.");
        component1.DoA();
        Console.WriteLine();
        Console.WriteLine("Client triggers operation D.");
        component2.DoD();
    }
}

// Originator 類可以生成一個(gè)備忘錄，并且可以通過(guò)備忘錄恢復(fù)其狀態(tài)。
public class Originator
{
    private string _state;
    public Originator(string state)
    {
        this._state = state;
        Console.WriteLine($"Originator: My initial state is: {_state}");
    }
    public void DoSomething()
    {
        Console.WriteLine("Originator: I'm doing something important.");
        _state = GenerateRandomString(30);
        Console.WriteLine($"Originator: and my state has changed to: {_state}");
    }
    private string GenerateRandomString(int length = 10)
    {
        string allowedSymbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        string result = string.Empty;
        while (length > 0)
        {
            result += allowedSymbols[new Random().Next(0, allowedSymbols.Length)];
            length--;
        }
        return result;
    }
    public IMemento Save()
    {
        return new ConcreteMemento(_state);
    }
    public void Restore(IMemento memento)
    {
        _state = memento.GetState();
        Console.WriteLine($"Originator: My state has changed to: {_state}");
    }
}
// 備忘錄接口提供了獲取備忘錄和原發(fā)器狀態(tài)的方法。但在該接口中并未聲明所有的方法，一些方法只在原發(fā)器中聲明。
public interface IMemento
{
    string GetName();
    string GetState();
    DateTime GetDate();
}
// Concrete Memento 存儲(chǔ)原發(fā)器狀態(tài)，并通過(guò)原發(fā)器實(shí)現(xiàn)備份。備忘錄是不可變的，因此，沒(méi)有 set 方法。
public class ConcreteMemento : IMemento
{
    private string _state;
    private DateTime _date;
    public ConcreteMemento(string state)
    {
        _state = state;
        _date = DateTime.Now;
    }
    public string GetState()
    {
        return _state;
    }
    public string GetName()
    {
        return $"{_date} / ({_state.Substring(0, 9)})...";
    }
    public DateTime GetDate()
    {
        return _date;
    }
}
// Caretaker 不依賴于具體備忘錄類。結(jié)果，它不會(huì)有任何訪問(wèn)原發(fā)器狀態(tài)的權(quán)利，它只能獲取備忘錄的元數(shù)據(jù)。
public class Caretaker
{
    private List<IMemento> _mementos = new List<IMemento>();
    private Originator _originator = null;
    public Caretaker(Originator originator)
    {
        this._originator = originator;
    }
    public void Backup()
    {
        Console.WriteLine("\nCaretaker: Saving Originator's state...");
        _mementos.Add(_originator.Save());
    }
    public void Undo()
    {
        if (_mementos.Count == 0)
        {
            return;
        }
        var memento = _mementos.Last();
        _mementos.Remove(memento);
        Console.WriteLine("Caretaker: Restoring state to: " + memento.GetName());
        try
        {
            _originator.Restore(memento);
        }
        catch (Exception)
        {
            Undo();
        }
    }
    public void ShowHistory()
    {
        Console.WriteLine("Caretaker: Here's the list of mementos:");
        foreach (var memento in _mementos)
        {
            Console.WriteLine(memento.GetName());
        }
    }
}
// 客戶端代碼
class Program
{
    static void Main(string[] args)
    {
        Originator originator = new Originator("Super-duper-super-puper-super.");
        Caretaker caretaker = new Caretaker(originator);
        caretaker.Backup();
        originator.DoSomething();
        caretaker.Backup();
        originator.DoSomething();
        caretaker.Backup();
        originator.DoSomething();
        Console.WriteLine();
        caretaker.ShowHistory();
        Console.WriteLine("\nClient: Now, let's rollback!\n");
        caretaker.Undo();
        Console.WriteLine("\nClient: Once more!\n");
        caretaker.Undo();
    }
}

// 抽象觀察者
public interface IObserver
{
    void Update();
}
// 具體觀察者
public class ConcreteObserver : IObserver
{
    private string name;
    public ConcreteObserver(string name)
    {
        this.name = name;
    }
    public void Update()
    {
        Console.WriteLine($"{name} received an update!");
    }
}
// 抽象主題
public interface ISubject
{
    void RegisterObserver(IObserver observer);
    void RemoveObserver(IObserver observer);
    void NotifyObservers();
}
// 具體主題
public class ConcreteSubject : ISubject
{
    private List<IObserver> observers = new List<IObserver>();
    public void RegisterObserver(IObserver observer)
    {
        observers.Add(observer);
    }
    public void RemoveObserver(IObserver observer)
    {
        if (observers.Contains(observer))
        {
            observers.Remove(observer);
        }
    }
    public void NotifyObservers()
    {
        foreach (var observer in observers)
        {
            observer.Update();
        }
    }
    public void ChangeState()
    {
        // 觸發(fā)狀態(tài)變化，通知所有觀察者
        NotifyObservers();
    }
}

class Program
{
    static void Main(string[] args)
    {
        ConcreteSubject subject = new ConcreteSubject();
        subject.RegisterObserver(new ConcreteObserver("Observer 1"));
        subject.RegisterObserver(new ConcreteObserver("Observer 2"));
        subject.RegisterObserver(new ConcreteObserver("Observer 3"));
        subject.ChangeState();
        Console.ReadLine();
    }
}

public interface IAccountState
{
    void Deposit(Action addToBalance);
    void Withdraw(Action subtractFromBalance);
    void ComputeInterest();
}

public class NormalState : IAccountState
{
    public void Deposit(Action addToBalance)
    {
        addToBalance();
        Console.WriteLine("Deposit in NormalState");
    }
    public void Withdraw(Action subtractFromBalance)
    {
        subtractFromBalance();
        Console.WriteLine("Withdraw in NormalState");
    }
    public void ComputeInterest()
    {
        Console.WriteLine("Interest computed in NormalState");
    }
}
public class OverdrawnState : IAccountState
{
    public void Deposit(Action addToBalance)
    {
        addToBalance();
        Console.WriteLine("Deposit in OverdrawnState");
    }
    public void Withdraw(Action subtractFromBalance)
    {
        Console.WriteLine("No withdraw in OverdrawnState");
    }
    public void ComputeInterest()
    {
        Console.WriteLine("Interest and fees computed in OverdrawnState");
    }
}

public class BankAccount
{
    private IAccountState _state;
    private double _balance;
    public BankAccount(IAccountState state)
    {
        _state = state;
        _balance = 0;
    }
    public void Deposit(double amount)
    {
        _state.Deposit(() => _balance += amount);
        StateChangeCheck();
    }
    public void Withdraw(double amount)
    {
        _state.Withdraw(() => _balance -= amount);
        StateChangeCheck();
    }
    public void ComputeInterest()
    {
        _state.ComputeInterest();
    }
    private void StateChangeCheck()
    {
        if (_balance < 0.0)
            _state = new OverdrawnState();
        else
            _state = new NormalState();
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        var account = new BankAccount(new NormalState());
        account.Deposit(1000); // Deposit in NormalState
        account.Withdraw(2000); // Withdraw in NormalState; No withdraw in OverdrawnState
        account.Deposit(100); // Deposit in OverdrawnState
        account.ComputeInterest(); // Interest and fees computed in OverdrawnState
        Console.ReadKey();
    }
}

public interface ISortStrategy
{
    void Sort(List<int> list);
}

public class QuickSort : ISortStrategy
{
    public void Sort(List<int> list)
    {
        list.Sort();  // Quick sort is in-place but here we are using built-in method
        Console.WriteLine("QuickSorted list ");
    }
}
public class BubbleSort : ISortStrategy
{
    public void Sort(List<int> list)
    {
        int n = list.Count;
        for (int i = 0; i < n - 1; i++)
            for (int j = 0; j < n - i - 1; j++)
                if (list[j] > list[j + 1])
                {
                    // swap temp and list[i]
                    int temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                }
        Console.WriteLine("BubbleSorted list ");
    }
}

public class SortedList
{
    private List<int> _list = new List<int>();
    private ISortStrategy _sortstrategy;
    public void SetSortStrategy(ISortStrategy sortstrategy)
    {
        this._sortstrategy = sortstrategy;
    }
    public void Add(int num)
    {
        _list.Add(num);
    }
    public void Sort()
    {
        _sortstrategy.Sort(_list);
        // Print sorted list
        foreach (int num in _list)
        {
            Console.Write(num + " ");
        }
        Console.WriteLine();
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        SortedList sortedList = new SortedList();
        sortedList.Add(1);
        sortedList.Add(5);
        sortedList.Add(3);
        sortedList.Add(4);
        sortedList.Add(2);
        sortedList.SetSortStrategy(new QuickSort());
        sortedList.Sort();  // Output: QuickSorted list 1 2 3 4 5 
        sortedList.SetSortStrategy(new BubbleSort());
        sortedList.Sort();  // Output: BubbleSorted list 1 2 3 4 5 
        Console.ReadKey();
    }
}

public abstract class CookingProcedure
{
    // The 'Template method' 
    public void PrepareDish()
    {
        PrepareIngredients();
        Cook();
        CleanUp();
    }
    public void PrepareIngredients()
    {
        Console.WriteLine("Preparing the ingredients...");
    }
    // These methods will be overridden by subclasses
    public abstract void Cook();
    public void CleanUp()
    {
        Console.WriteLine("Cleaning up...");
    }
}

public class CookPasta : CookingProcedure
{
    public override void Cook()
    {
        Console.WriteLine("Cooking pasta...");
    }
}
public class BakeCake : CookingProcedure
{
    public override void Cook()
    {
        Console.WriteLine("Baking cake...");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        CookingProcedure cookingProcedure = new CookPasta();
        cookingProcedure.PrepareDish();
        Console.WriteLine();
        cookingProcedure = new BakeCake();
        cookingProcedure.PrepareDish();
        Console.ReadKey();
    }
}

// 訪問(wèn)者接口
public interface IVisitor
{
    void VisitConcreteElementA(ConcreteElementA concreteElementA);
    void VisitConcreteElementB(ConcreteElementB concreteElementB);
}
// 具體訪問(wèn)者A
public class ConcreteVisitorA : IVisitor
{
    public void VisitConcreteElementA(ConcreteElementA concreteElementA)
    {
        Console.WriteLine($"{concreteElementA.GetType().Name} is being visited by {this.GetType().Name}");
    }
    public void VisitConcreteElementB(ConcreteElementB concreteElementB)
    {
        Console.WriteLine($"{concreteElementB.GetType().Name} is being visited by {this.GetType().Name}");
    }
}
// 具體訪問(wèn)者B
public class ConcreteVisitorB : IVisitor
{
    public void VisitConcreteElementA(ConcreteElementA concreteElementA)
    {
        Console.WriteLine($"{concreteElementA.GetType().Name} is being visited by {this.GetType().Name}");
    }
    public void VisitConcreteElementB(ConcreteElementB concreteElementB)
    {
        Console.WriteLine($"{concreteElementB.GetType().Name} is being visited by {this.GetType().Name}");
    }
}
// 元素接口
public interface IElement
{
    void Accept(IVisitor visitor);
}
// 具體元素A
public class ConcreteElementA : IElement
{
    public void Accept(IVisitor visitor)
    {
        visitor.VisitConcreteElementA(this);
    }
}
// 具體元素B
public class ConcreteElementB : IElement
{
    public void Accept(IVisitor visitor)
    {
        visitor.VisitConcreteElementB(this);
    }
}
// 對(duì)象結(jié)構(gòu)
public class ObjectStructure
{
    private List<IElement> _elements = new List<IElement>();
    public void Attach(IElement element)
    {
        _elements.Add(element);
    }
    public void Detach(IElement element)
    {
        _elements.Remove(element);
    }
    public void Accept(IVisitor visitor)
    {
        foreach (var element in _elements)
        {
            element.Accept(visitor);
        }
    }
}

public class Program
{
    public static void Main()
    {
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.Attach(new ConcreteElementA());
        objectStructure.Attach(new ConcreteElementB());
        ConcreteVisitorA visitorA = new ConcreteVisitorA();
        ConcreteVisitorB visitorB = new ConcreteVisitorB();
        objectStructure.Accept(visitorA);
        objectStructure.Accept(visitorB);
        Console.ReadKey();
    }
}