详细讲解23种设计模式

阳光穿透心脏的1/2处 2023-09-24 21:41 35阅读 0赞

### 工厂方法模式（Factory Method Pattern） ###

工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法把对象的实例化推迟到子类。

代码示例：

csharpCopy codepublic interface IProduct
    {
        void Operation();
    }
    
    public class ProductA : IProduct
    {
        public void Operation()
        {
            Console.WriteLine("Product A operation");
        }
    }
    
    public class ProductB : IProduct
    {
        public void Operation()
        {
            Console.WriteLine("Product B operation");
        }
    }
    
    public abstract class Creator
    {
        public abstract IProduct FactoryMethod();
    }
    
    public class ConcreteCreatorA : Creator
    {
        public override IProduct FactoryMethod()
        {
            return new ProductA();
        }
    }
    
    public class ConcreteCreatorB : Creator
    {
        public override IProduct FactoryMethod()
        {
            return new ProductB();
        }
    }

### 抽象工厂模式（Abstract Factory Pattern） ###

抽象工厂模式是一种创建型设计模式，它提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

代码示例：

csharpCopy codepublic interface IProductA
    {
        void OperationA();
    }
    
    public interface IProductB
    {
        void OperationB();
    }
    
    public class ProductA1 : IProductA
    {
        public void OperationA()
        {
            Console.WriteLine("Product A1 operation");
        }
    }
    
    public class ProductA2 : IProductA
    {
        public void OperationA()
        {
            Console.WriteLine("Product A2 operation");
        }
    }
    
    public class ProductB1 : IProductB
    {
        public void OperationB()
        {
            Console.WriteLine("Product B1 operation");
        }
    }
    
    public class ProductB2 : IProductB
    {
        public void OperationB()
        {
            Console.WriteLine("Product B2 operation");
        }
    }
    
    public interface IAbstractFactory
    {
        IProductA CreateProductA();
        IProductB CreateProductB();
    }
    
    public class ConcreteFactory1 : IAbstractFactory
    {
        public IProductA CreateProductA()
        {
            return new ProductA1();
        }
    
        public IProductB CreateProductB()
        {
            return new ProductB1();
        }
    }
    
    public class ConcreteFactory2 : IAbstractFactory
    {
        public IProductA CreateProductA()
        {
            return new ProductA2();
        }
    
        public IProductB CreateProductB()
        {
            return new ProductB2();
        }
    }

### 单例模式（Singleton Pattern） ###

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供全局访问点。

代码示例：

csharpCopy codepublic sealed class Singleton
    {
        private static Singleton instance = null;
    
        private Singleton() { }
    
        public static Singleton Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
    
                return instance;
            }
        }
    }

### 建造者模式（Builder Pattern） ###

建造者模式是一种创建型设计模式，它可以将一个复杂对象的构建过程和它的表示分离，使得同样的构建过程可以创建不同的表示。

代码示例：

csharpCopy codepublic class Product
    {
        public string PartA { get; set; }
        public string PartB { get; set; }
        public string PartC { get; set; }
    
        public override string ToString()
        {
            return $"{PartA}, {PartB}, {PartC}";
        }
    }
    
    public interface IBuilder
    {
        void BuildPartA();
        void BuildPartB();
        void BuildPartC();
        Product GetResult();
    }
    
    public class ConcreteBuilder : IBuilder
    {
        private Product product = new Product();
    
        public void BuildPartA()
        {
            product.PartA = "Part A";
        }
    
        public void BuildPartB()
        {
            product.PartB = "Part B";
        }
    
        public void BuildPartC()
        {
            product.PartC = "Part C";
        }
    
        public Product GetResult()
        {
            return product;
        }
    }
    
    public class Director
    {
        private IBuilder builder;
    
        public Director(IBuilder builder)
        {
            this.builder = builder;
        }
    
        public void Construct()
        {
            builder.BuildPartA();
            builder.BuildPartB();
            builder.BuildPartC();
        }
    }

### 原型模式（Prototype Pattern） ###

原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而不是通过实例化的方式。

代码示例：

csharpCopy codepublic class Prototype : ICloneable
    {
        public string Value { get; set; }
    
        public object Clone()
        {
            return MemberwiseClone();
        }
    }

### 适配器模式（Adapter Pattern） ###

适配器模式是一种结构型设计模式，它可以将一种类的接口转换成客户端希望的另一种接口。适配器模式允许接口不兼容的类能够合作。

代码示例：

csharpCopy codepublic interface ITarget
    {
        void Request();
    }
    
    public class Adaptee
    {
        public void SpecificRequest()
        {
            Console.WriteLine("Adaptee specific request");
        }
    }
    
    public class Adapter : ITarget
    {
        private readonly Adaptee adaptee;
    
        public Adapter(Adaptee adaptee)
        {
            this.adaptee = adaptee;
        }
    
        public void Request()
        {
            adaptee.SpecificRequest();
        }
    }

### 桥接模式（Bridge Pattern） ###

桥接模式是一种结构型设计模式，它可以将一个大类或一系列紧密相关的类拆分为抽象和实现两个独立的层次结构，从而能在开发时分别使用。

代码示例：

csharpCopy codepublic interface IImplementor
    {
        void OperationImp();
    }
    
    public class ConcreteImplementorA : IImplementor
    {
        public void OperationImp()
        {
            Console.WriteLine("ConcreteImplementorA OperationImp");
        }
    }
    
    public class ConcreteImplementorB : IImplementor
    {
        public void OperationImp()
        {
            Console.WriteLine("ConcreteImplementorB OperationImp");
        }
    }
    
    public abstract class Abstraction
    {
        protected IImplementor implementor;
    
        protected Abstraction(IImplementor implementor)
        {
            this.implementor = implementor;
        }
    
        public abstract void Operation();
    }
    
    public class RefinedAbstraction : Abstraction
    {
        public RefinedAbstraction(IImplementor implementor) : base(implementor)
        {
        }
    
        public override void Operation()
        {
            implementor.OperationImp();
        }
    }

### 组合模式（Composite Pattern） ###

组合模式是一种结构型设计模式，它允许将对象组合成树形结构来表现整体-部分关系。组合能让客户端统一处理单个对象和对象组合。

代码示例：

csharpCopy codepublic abstract class Component
    {
        protected readonly string name;
    
        public Component(string name)
        {
            this.name = name;
        }
    
        public abstract void Operation();
    }
    
    public class Leaf : Component
    {
        public Leaf(string name) : base(name)
        {
        }
    
        public override void Operation()
        {
            Console.WriteLine($"Leaf {name} Operation");
        }
    }
    
    public class Composite : Component
    {
        private readonly List<Component> children = new List<Component>();
    
        public Composite(string name) : base(name)
        {
        }
    
        public override void Operation()
        {
            Console.WriteLine($"Composite {name} Operation");
    
            foreach (var child in children)
            {
                child.Operation();
            }
        }
    
        public void Add(Component component)
        {
            children.Add(component);
        }
    
        public void Remove(Component component)
        {
            children.Remove(component);
        }
    }

### 桥接模式（Bridge Pattern） ###

桥接模式是一种结构型设计模式，它将抽象与实现分离，以便它们可以独立地进行变化。

代码示例：

csharpCopy codepublic interface IImplementor
    {
        void OperationImp();
    }
    
    public class ConcreteImplementorA : IImplementor
    {
        public void OperationImp()
        {
            Console.WriteLine("ConcreteImplementorA OperationImp");
        }
    }
    
    public class ConcreteImplementorB : IImplementor
    {
        public void OperationImp()
        {
            Console.WriteLine("ConcreteImplementorB OperationImp");
        }
    }
    
    public abstract class Abstraction
    {
        protected IImplementor implementor;
    
        public Abstraction(IImplementor implementor)
        {
            this.implementor = implementor;
        }
    
        public abstract void Operation();
    }
    
    public class RefinedAbstraction : Abstraction
    {
        public RefinedAbstraction(IImplementor implementor) : base(implementor)
        {
        }
    
        public override void Operation()
        {
            implementor.OperationImp();
        }
    }

### 外观模式（Facade Pattern） ###

外观模式是一种结构型设计模式，它为复杂的子系统提供简单的接口，从而使子系统更易于使用。

代码示例：

csharpCopy codepublic class SubsystemA
    {
        public void OperationA()
        {
            Console.WriteLine("SubsystemA OperationA");
        }
    }
    
    public class SubsystemB
    {
        public void OperationB()
        {
            Console.WriteLine("SubsystemB OperationB");
        }
    }
    
    public class Facade
    {
        private readonly SubsystemA subsystemA;
        private readonly SubsystemB subsystemB;
    
        public Facade(SubsystemA subsystemA, SubsystemB subsystemB)
        {
            this.subsystemA = subsystemA;
            this.subsystemB = subsystemB;
        }
    
        public void Operation()
        {
            subsystemA.OperationA();
            subsystemB.OperationB();
        }
    }

### 享元模式（Flyweight Pattern） ###

享元模式是一种结构型设计模式，它通过共享尽可能多的数据来最小化内存使用和计算开销。享元模式适用于需要大量对象的情况，同时又要求对象能够轻量化。

代码示例：

csharpCopy codepublic class FlyweightFactory
    {
        private readonly Dictionary<char, Flyweight> flyweights = new Dictionary<char, Flyweight>();
    
        public Flyweight GetFlyweight(char key)
        {
            if (!flyweights.TryGetValue(key, out var flyweight))
            {
                flyweight = new ConcreteFlyweight(key);
                flyweights[key] = flyweight;
            }
    
            return flyweight;
        }
    }
    
    public abstract class Flyweight
    {
        public abstract void Operation();
    }
    
    public class ConcreteFlyweight : Flyweight
    {
        private readonly char intrinsicState;
    
        public ConcreteFlyweight(char intrinsicState)
        {
            this.intrinsicState = intrinsicState;
        }
    
        public override void Operation()
        {
            Console.WriteLine($"ConcreteFlyweight {intrinsicState} Operation");
        }
    }
    
    public class UnsharedConcreteFlyweight : Flyweight
    {
        private readonly string extrinsicState;
    
        public UnsharedConcreteFlyweight(string extrinsicState)
        {
            this.extrinsicState = extrinsicState;
        }
    
        public override void Operation()
        {
            Console.WriteLine($"UnsharedConcreteFlyweight {extrinsicState} Operation");
        }
    }
    ``

### 组合模式（Composite Pattern） ###

组合模式是一种结构型设计模式，允许你将对象组合成树状结构，并且能像使用独立对象一样使用它们。

适用场景：

1.当你想表示对象的部分-整体层次结构时。

2.当你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时。

组合模式中的关键类：

1.  Component（组件）：是组合中的对象声明接口，在适当情况下，实现所有类共有的接口默认行为。声明一个接口用于访问和管理 Component 子部件。
2.  Leaf（叶子）：在组合中表示子节点对象，叶子节点没有子节点。
3.  Composite（容器）：定义有枝节点行为，用来存储子部件，在 Component 接口中实现与子部件有关的操作，比如增加 Add 和删除 Remove。

代码示例：

下面是一个组合模式的示例，我们以一个目录结构为例来实现组合模式。目录中可以包含文件和文件夹，文件夹中又可以包含文件和文件夹。

csharpCopy code// 抽象构件
    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);
    }
    
    // 叶子节点
    public class Leaf : Component
    {
        public Leaf(string name) : base(name) { }
    
        public override void Add(Component c)
        {
            Console.WriteLine("不能向叶子节点添加节点");
        }
    
        public override void Remove(Component c)
        {
            Console.WriteLine("不能从叶子节点移除节点");
        }
    
        public override void Display(int depth)
        {
            Console.WriteLine(new string('-', depth) + name);
        }
    }
    
    // 容器节点
    public class Composite : Component
    {
        private List<Component> children = new List<Component>();
    
        public Composite(string name) : base(name) { }
    
        public override void Add(Component c)
        {
            children.Add(c);
        }
    
        public override void Remove(Component c)
        {
            children.Remove(c);
        }
    
        public override void Display(int depth)
        {
            Console.WriteLine(new string('-', depth) + name);
    
            foreach (Component component in children)
            {
                component.Display(depth + 2);
            }
        }
    }
    
    // 客户端代码
    class Client
    {
        static void Main(string[] args)
        {
            Composite root = new Composite("C:");
            Composite windows = new Composite("Windows");
            Composite programFiles = new Composite("Program Files");
            Leaf file1 = new Leaf("a.txt");
            Leaf file2 = new Leaf("b.txt");
            Leaf file3 = new Leaf("c.txt");
    
            root.Add(windows);
            root.Add(programFiles);
            windows.Add(file1);
            windows.Add(file2);
            programFiles.Add(file3);
    
            root.Display(0);
    
            Console.ReadKey();
        }
    }

### Proxy（代理模式） ###

代理模式为其他对象提供一种代理以控制对这个对象的访问。代理类与实际类具有相同的接口，这样就可以使用代理来代替实际类，使得在不改变原始代码的情况下增加了一些额外的功能。常用的代理模式有远程代理、虚拟代理、保护代理、缓存代理等。

代码示例：

csharpCopy code// 实际类
    public class RealSubject : ISubject
    {
        public void Request()
        {
            Console.WriteLine("RealSubject: Handling Request.");
        }
    }
    
    // 代理类
    public class Proxy : ISubject
    {
        private readonly RealSubject _realSubject;
    
        public Proxy(RealSubject realSubject)
        {
            _realSubject = realSubject;
        }
    
        public void Request()
        {
            if (CheckAccess())
            {
                _realSubject.Request();
    
                LogAccess();
            }
        }
    
        private bool CheckAccess()
        {
            Console.WriteLine("Proxy: Checking access prior to firing a real request.");
    
            return true;
        }
    
        private void LogAccess()
        {
            Console.WriteLine("Proxy: Logging the time of request.");
        }
    }
    
    // 接口类
    public interface ISubject
    {
        void Request();
    }
    
    // 使用代理
    static void Main(string[] args)
    {
        var realSubject = new RealSubject();
        var proxy = new Proxy(realSubject);
    
        proxy.Request();
    }

### Command（命令模式） ###

命令模式是一种行为型模式，它通过将请求封装为一个对象来实现请求的发送者和接收者之间的解耦。命令对象包含了要执行的操作以及其相关的数据，可以把命令对象看成是一个操作的载体。常用的命令模式有简单命令、复杂命令、队列请求等。

代码示例：

csharpCopy code// 命令接口
    public interface ICommand
    {
        void Execute();
    }
    
    // 具体命令
    public class ConcreteCommand : ICommand
    {
        private readonly Receiver _receiver;
    
        public ConcreteCommand(Receiver receiver)
        {
            _receiver = receiver;
        }
    
        public void Execute()
        {
            _receiver.Action();
        }
    }
    
    // 接收者
    public class Receiver
    {
        public void Action()
        {
            Console.WriteLine("Receiver: Action.");
        }
    }
    
    // 发送者
    public class Invoker
    {
        private ICommand _command;
    
        public void SetCommand(ICommand command)
        {
            _command = command;
        }
    
        public void ExecuteCommand()
        {
            _command.Execute();
        }
    }
    
    // 使用命令模式
    static void Main(string[] args)
    {
        var receiver = new Receiver();
        var command = new ConcreteCommand(receiver);
        var invoker = new Invoker();
    
        invoker.SetCommand(command);
        invoker.ExecuteCommand();
    }

### 责任链模式（Chain of Responsibility Pattern） ###

责任链模式是一种行为型设计模式，它通过将请求的发送者和接收者解耦，使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理为止。

在责任链模式中，每个处理器都只关心它自己能够处理的请求，并把它转发给下一个处理器。这样，请求者与处理器之间的耦合就被解除了，可以动态地改变请求的处理顺序或者增加/删除处理器。

代码示例：

下面是一个简单的例子，用来演示使用责任链模式实现不同等级的员工申请加薪请求的处理：

csharpCopy codeabstract class Approver
    {
        protected Approver successor;
    
        public void SetSuccessor(Approver successor)
        {
            this.successor = successor;
        }
    
        public abstract void ProcessRequest(Request request);
    }
    
    class Manager : Approver
    {
        public override void ProcessRequest(Request request)
        {
            if (request.Type == RequestType.RaiseSalary && request.Amount <= 500)
            {
                Console.WriteLine($"Manager approved the request for raise of amount {request.Amount}");
            }
            else if (successor != null)
            {
                successor.ProcessRequest(request);
            }
        }
    }
    
    class DepartmentHead : Approver
    {
        public override void ProcessRequest(Request request)
        {
            if (request.Type == RequestType.RaiseSalary && request.Amount <= 1000)
            {
                Console.WriteLine($"Department head approved the request for raise of amount {request.Amount}");
            }
            else if (successor != null)
            {
                successor.ProcessRequest(request);
            }
        }
    }
    
    class CEO : Approver
    {
        public override void ProcessRequest(Request request)
        {
            if (request.Type == RequestType.RaiseSalary && request.Amount <= 5000)
            {
                Console.WriteLine($"CEO approved the request for raise of amount {request.Amount}");
            }
            else
            {
                Console.WriteLine($"The request for raise of amount {request.Amount} cannot be approved by anyone.");
            }
        }
    }
    
    class Request
    {
        public RequestType Type { get; set; }
        public int Amount { get; set; }
    }
    
    enum RequestType
    {
        RaiseSalary
    }
    
    static void Main(string[] args)
    {
        Manager manager = new Manager();
        DepartmentHead departmentHead = new DepartmentHead();
        CEO ceo = new CEO();
    
        manager.SetSuccessor(departmentHead);
        departmentHead.SetSuccessor(ceo);
    
        Request request1 = new Request() { Type = RequestType.RaiseSalary, Amount = 400 };
        manager.ProcessRequest(request1);
    
        Request request2 = new Request() { Type = RequestType.RaiseSalary, Amount = 1500 };
        manager.ProcessRequest(request2);
    
        Request request3 = new Request() { Type = RequestType.RaiseSalary, Amount = 6000 };
        manager.ProcessRequest(request3);
    }

输出结果：

pythonCopy codeManager approved the request for raise of amount 400
    Department head approved the request for raise of amount 1500
    The request for raise of amount 6000 cannot be approved by anyone.

### 迭代器模式（Iterator Pattern） ###

描述：迭代器模式是一种行为型设计模式， 它可以在不暴露集合底层表现形式（列表、栈和树等）的情况下遍历集合中所有的元素。 示例：

csharpCopy codepublic class IteratorPatternExample
    {
        static void Main(string[] args)
        {
            var collection = new ConcreteAggregate<string>();
            collection[0] = "One";
            collection[1] = "Two";
            collection[2] = "Three";
            collection[3] = "Four";
    
            var iterator = collection.CreateIterator();
            Console.WriteLine("Iterating over collection:");
            while (iterator.MoveNext())
            {
                var element = iterator.Current;
                Console.WriteLine(element);
            }
        }
    }
    
    public interface IIterator<T>
    {
        bool MoveNext();
        T Current { get; }
        void Reset();
    }
    
    public interface IAggregate<T>
    {
        IIterator<T> CreateIterator();
    }
    
    public class ConcreteAggregate<T> : IAggregate<T>
    {
        private List<T> _items = new List<T>();
        public IIterator<T> CreateIterator()
        {
            return new ConcreteIterator<T>(this);
        }
    
        public int Count { get { return _items.Count; } }
    
        public T this[int index]
        {
            get { return _items[index]; }
            set { _items.Insert(index, value); }
        }
    }
    
    public class ConcreteIterator<T> : IIterator<T>
    {
        private ConcreteAggregate<T> _aggregate;
        private int _currentIndex = 0;
    
        public ConcreteIterator(ConcreteAggregate<T> aggregate)
        {
            _aggregate = aggregate;
        }
    
        public T Current
        {
            get { return _aggregate[_currentIndex]; }
        }
    
        public bool MoveNext()
        {
            if (_currentIndex < _aggregate.Count)
            {
                _currentIndex++;
                return true;
            }
            return false;
        }
    
        public void Reset()
        {
            _currentIndex = 0;
        }
    }

### 中介者模式（Mediator Pattern） ###

中介者模式用于降低多个对象之间的通信复杂性。该模式定义一个中介者对象，使得各个对象不需要显式地相互引用，从而降低耦合度，同时可以独立地改变对象之间的交互。

代码示例：

csharpCopy codepublic abstract class Mediator
    {
        public abstract void Send(string message, Colleague colleague);
    }
    
    public class ConcreteMediator : Mediator
    {
        private ConcreteColleague1 colleague1;
        private ConcreteColleague2 colleague2;
    
        public ConcreteColleague1 Colleague1
        {
            set { colleague1 = value; }
        }
    
        public ConcreteColleague2 Colleague2
        {
            set { colleague2 = value; }
        }
    
        public override void Send(string message, Colleague colleague)
        {
            if (colleague == colleague1)
            {
                colleague2.Notify(message);
            }
            else
            {
                colleague1.Notify(message);
            }
        }
    }
    
    public abstract class Colleague
    {
        protected Mediator mediator;
    
        public Colleague(Mediator mediator)
        {
            this.mediator = mediator;
        }
    
        public abstract void Send(string message);
        public abstract void Notify(string message);
    }
    
    public class ConcreteColleague1 : Colleague
    {
        public ConcreteColleague1(Mediator mediator) : base(mediator) { }
    
        public override void Send(string message)
        {
            mediator.Send(message, this);
        }
    
        public override void Notify(string message)
        {
            Console.WriteLine("Colleague1 gets message: " + message);
        }
    }
    
    public class ConcreteColleague2 : Colleague
    {
        public ConcreteColleague2(Mediator mediator) : base(mediator) { }
    
        public override void Send(string message)
        {
            mediator.Send(message, this);
        }
    
        public override void Notify(string message)
        {
            Console.WriteLine("Colleague2 gets message: " + message);
        }
    }

### 备忘录模式（Memento Pattern） ###

备忘录模式用于保存一个对象的状态，以便在以后可以恢复到该状态。该模式有三个角色：备忘录（Memento）负责存储对象的状态，原发器（Originator）负责创建备忘录和恢复备忘录，管理者（Caretaker）负责保存和恢复备忘录。

代码示例：

csharpCopy codepublic class Memento
    {
        private string state;
    
        public Memento(string state)
        {
            this.state = state;
        }
    
        public string State
        {
            get { return state; }
        }
    }
    
    public class Originator
    {
        private string state;
    
        public string State
        {
            get { return state; }
            set { state = value; }
        }
    
        public Memento CreateMemento()
        {
            return new Memento(state);
        }
    
        public void SetMemento(Memento memento)
        {
            state = memento.State;
        }
    }
    
    public class Caretaker
    {
        private Memento memento;
    
        public Memento Memento
        {
            get { return memento; }
            set { memento = value; }
        }
    }

### 观察者模式（Observer Pattern） ###

1.  观察者模式（Observer Pattern）：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，所有依赖它的观察者都会自动收到通知并进行更新。

csharpCopy codepublic interface IObserver
    {
        void Update(ISubject subject);
    }
    
    public interface ISubject
    {
        void Attach(IObserver observer);
        void Detach(IObserver observer);
        void Notify();
    }
    
    public class ConcreteSubject : ISubject
    {
        private List<IObserver> observers = new List<IObserver>();
        private int state;
    
        public void Attach(IObserver observer)
        {
            observers.Add(observer);
        }
    
        public void Detach(IObserver observer)
        {
            observers.Remove(observer);
        }
    
        public void Notify()
        {
            foreach (var observer in observers)
            {
                observer.Update(this);
            }
        }
    
        public int GetState()
        {
            return state;
        }
    
        public void SetState(int state)
        {
            this.state = state;
            Notify();
        }
    }
    
    public class ConcreteObserver : IObserver
    {
        private string name;
    
        public ConcreteObserver(string name)
        {
            this.name = name;
        }
    
        public void Update(ISubject subject)
        {
            Console.WriteLine($"{name} received the message from {subject.GetType().Name}, the new state is {((ConcreteSubject)subject).GetState()}");
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            ISubject subject = new ConcreteSubject();
            IObserver observer1 = new ConcreteObserver("Observer 1");
            IObserver observer2 = new ConcreteObserver("Observer 2");
    
            subject.Attach(observer1);
            subject.Attach(observer2);
    
            ((ConcreteSubject)subject).SetState(1);
    
            subject.Detach(observer1);
    
            ((ConcreteSubject)subject).SetState(2);
    
            Console.ReadLine();
        }
    }

### 状态模式（State Pattern） ###

状态模式（State Pattern）是一种行为型设计模式，它允许对象在内部状态发生改变时改变它的行为。状态模式通过将复杂的条件语句转换为对象的形式，使得代码更加灵活、可维护和可扩展。

在状态模式中，一个对象的行为取决于其内部状态，对象会根据不同的状态来执行不同的操作。这种模式是一种行为型模式。

在状态模式中，主要有三种角色：上下文（Context）、抽象状态（State）、具体状态（ConcreteState）。其中，上下文是一个包含状态的对象，抽象状态是一个定义所有具体状态的接口，具体状态是实现状态的具体类。

下面以电视遥控器为例，使用状态模式进行设计。当电视遥控器处于不同状态时，它会对按下的按钮产生不同的响应，例如当电视遥控器处于开机状态时，按下“换台”按钮会切换频道；当电视遥控器处于关机状态时，按下“换台”按钮则没有任何响应。

首先，定义一个抽象状态接口：

csharpCopy codepublic interface ITvState
    {
        void TurnOn();
        void TurnOff();
        void NextChannel();
        void PrevChannel();
    }

接下来，定义具体的状态类，这里定义了两个具体状态类，分别代表电视开机状态和电视关机状态：

csharpCopy codepublic class TvOnState : ITvState
    {
        public void TurnOn()
        {
            Console.WriteLine("电视已经开机");
        }
    
        public void TurnOff()
        {
            Console.WriteLine("电视关机");
        }
    
        public void NextChannel()
        {
            Console.WriteLine("下一个频道");
        }
    
        public void PrevChannel()
        {
            Console.WriteLine("上一个频道");
        }
    }
    
    public class TvOffState : ITvState
    {
        public void TurnOn()
        {
            Console.WriteLine("电视开机");
        }
    
        public void TurnOff()
        {
            Console.WriteLine("电视已经关机");
        }
    
        public void NextChannel()
        {
            Console.WriteLine("电视已经关机，无法切换频道");
        }
    
        public void PrevChannel()
        {
            Console.WriteLine("电视已经关机，无法切换频道");
        }
    }

最后，定义上下文类，它包含了当前电视的状态，并提供了一些接口供外界使用：

csharpCopy codepublic class TvContext
    {
        private ITvState state;
    
        public TvContext()
        {
            state = new TvOffState();
        }
    
        public void SetState(ITvState state)
        {
            this.state = state;
        }
    
        public void TurnOn()
        {
            state.TurnOn();
            SetState(new TvOnState());
        }
    
        public void TurnOff()
        {
            state.TurnOff();
            SetState(new TvOffState());
        }
    
        public void NextChannel()
        {
            state.NextChannel();
        }
    
        public void PrevChannel()
        {
            state.PrevChannel();
        }
    }

现在，我们就可以使用上下文类来操作电视遥控器了，例如：

csharpCopy codeTvContext context = new TvContext();
    
    context.TurnOn();
    context.NextChannel();
    context.NextChannel();
    context.PrevChannel();
    context.TurnOff();

输出结果为：

Copy code电视开机
    下一个频道
    下一个频道
    上一个频道
    电视关机

### 策略模式（Strategy Pattern） ###

策略模式（Strategy Pattern）是一种行为设计模式，它允许在运行时选择算法的行为。该模式定义了一组算法，将每个算法封装起来，并使它们之间可以相互替换。

下面是使用C\#实现策略模式的示例代码：

csharpCopy code// 抽象策略
    public interface IStrategy
    {
        void Execute();
    }
    
    // 具体策略
    public class ConcreteStrategyA : IStrategy
    {
        public void Execute()
        {
            Console.WriteLine("执行策略A");
        }
    }
    
    // 具体策略
    public class ConcreteStrategyB : IStrategy
    {
        public void Execute()
        {
            Console.WriteLine("执行策略B");
        }
    }
    
    // 上下文
    public class Context
    {
        private IStrategy _strategy;
    
        public Context(IStrategy strategy)
        {
            _strategy = strategy;
        }
    
        public void SetStrategy(IStrategy strategy)
        {
            _strategy = strategy;
        }
    
        public void ExecuteStrategy()
        {
            _strategy.Execute();
        }
    }
    
    // 客户端代码
    public class Client
    {
        public static void Main()
        {
            // 创建上下文并设置初始策略
            Context context = new Context(new ConcreteStrategyA());
    
            // 执行策略A
            context.ExecuteStrategy();
    
            // 切换策略
            context.SetStrategy(new ConcreteStrategyB());
    
            // 执行策略B
            context.ExecuteStrategy();
        }
    }

在这个示例中，`IStrategy`是抽象策略，定义了策略的接口。`ConcreteStrategyA`和`ConcreteStrategyB`是具体策略，实现了策略接口。`Context`是上下文，维护了一个策略对象，并且提供了一些方法来使用该策略。`Client`是客户端代码，使用上下文对象来执行策略。在客户端代码中，我们首先创建了一个上下文对象并设置了一个初始策略。然后我们执行了策略A，接着我们切换了策略并执行了策略B。

### 模板方法模式（Template Method Pattern） ###

在模板方法模式中，有一个抽象类定义了一些抽象的方法和模板方法，模板方法是一个固定的算法流程，而抽象的方法则需要子类去实现。模板方法模式的目的是让子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

下面是一个简单的示例代码：

csharpCopy codeusing System;
    
    abstract class AbstractClass
    {
        public void TemplateMethod()
        {
            Operation1();
            Operation2();
        }
    
        public abstract void Operation1();
        public abstract void Operation2();
    }
    
    class ConcreteClassA : AbstractClass
    {
        public override void Operation1()
        {
            Console.WriteLine("ConcreteClassA.Operation1");
        }
    
        public override void Operation2()
        {
            Console.WriteLine("ConcreteClassA.Operation2");
        }
    }
    
    class ConcreteClassB : AbstractClass
    {
        public override void Operation1()
        {
            Console.WriteLine("ConcreteClassB.Operation1");
        }
    
        public override void Operation2()
        {
            Console.WriteLine("ConcreteClassB.Operation2");
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            AbstractClass c1 = new ConcreteClassA();
            AbstractClass c2 = new ConcreteClassB();
    
            c1.TemplateMethod();
            c2.TemplateMethod();
    
            Console.ReadKey();
        }
    }

在上面的代码中，`AbstractClass` 是一个抽象类，它有一个 `TemplateMethod` 方法，该方法调用了两个抽象方法 `Operation1` 和 `Operation2`。具体的子类 `ConcreteClassA` 和 `ConcreteClassB` 分别实现了这两个抽象方法，并且可以在模板方法中按照特定的流程调用它们。

当我们运行这个程序时，输出如下：

Copy codeConcreteClassA.Operation1
    ConcreteClassA.Operation2
    ConcreteClassB.Operation1
    ConcreteClassB.Operation2

这表明模板方法模式确实在两个具体的子类中分别执行了它们的 `Operation1` 和 `Operation2` 方法，但是并没有改变模板方法的算法流程。

### 访问者模式（Visitor Pattern） ###

访问者模式（Visitor Pattern）是一种行为型设计模式，它允许你定义算法（访问者），并将其与一组对象分离。访问者模式最常见的应用场景是在对象结构比较稳定的情况下，需要对对象结构中的对象进行各种不同的操作，且经常添加新的操作。

下面是一个使用访问者模式的示例代码：

csharpCopy codeusing System;
    using System.Collections.Generic;
    
    // 访问者接口
    interface IVisitor
    {
        void Visit(ConcreteElementA elementA);
        void Visit(ConcreteElementB elementB);
    }
    
    // 抽象元素类
    abstract class Element
    {
        public abstract void Accept(IVisitor visitor);
    }
    
    // 具体元素类 A
    class ConcreteElementA : Element
    {
        public override void Accept(IVisitor visitor)
        {
            visitor.Visit(this);
        }
    
        public void OperationA()
        {
            Console.WriteLine("ConcreteElementA.OperationA()");
        }
    }
    
    // 具体元素类 B
    class ConcreteElementB : Element
    {
        public override void Accept(IVisitor visitor)
        {
            visitor.Visit(this);
        }
    
        public void OperationB()
        {
            Console.WriteLine("ConcreteElementB.OperationB()");
        }
    }
    
    // 具体访问者类
    class ConcreteVisitor : IVisitor
    {
        public void Visit(ConcreteElementA elementA)
        {
            elementA.OperationA();
        }
    
        public void Visit(ConcreteElementB elementB)
        {
            elementB.OperationB();
        }
    }
    
    // 对象结构类
    class ObjectStructure
    {
        private List<Element> elements = new List<Element>();
    
        public void Attach(Element element)
        {
            elements.Add(element);
        }
    
        public void Detach(Element element)
        {
            elements.Remove(element);
        }
    
        public void Accept(IVisitor visitor)
        {
            foreach (Element element in elements)
            {
                element.Accept(visitor);
            }
        }
    }
    
    // 客户端代码
    class Client
    {
        static void Main()
        {
            ObjectStructure objectStructure = new ObjectStructure();
            objectStructure.Attach(new ConcreteElementA());
            objectStructure.Attach(new ConcreteElementB());
    
            ConcreteVisitor visitor = new ConcreteVisitor();
            objectStructure.Accept(visitor);
    
            Console.ReadKey();
        }
    }

在上面的示例中，`IVisitor` 定义了访问者的接口，包含了对每个具体元素类的访问方法。`Element` 是抽象元素类，定义了 `Accept` 方法，接受访问者的访问。

`ConcreteElementA` 和 `ConcreteElementB` 是具体元素类，实现了 `Accept` 方法，并且定义了各自的操作方法。`ConcreteVisitor` 是具体访问者类，实现了 `IVisitor` 接口，实现了对每个具体元素的操作。`ObjectStructure` 是对象结构类，包含了元素对象集合，并提供了 `Accept` 方法，接受访问者的访问。客户端代码通过创建 `ObjectStructure` 对象，向其中添加具体元素对象，并创建 `ConcreteVisitor` 对象进行访问操作。