详细讲解23种设计模式
Posted dotNET跨平台
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了详细讲解23种设计模式相关的知识，希望对你有一定的参考价值。
工厂方法模式（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.当你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时。
组合模式中的关键类：
Component（组件）：是组合中的对象声明接口，在适当情况下，实现所有类共有的接口默认行为。声明一个接口用于访问和管理 Component 子部件。
Leaf（叶子）：在组合中表示子节点对象，叶子节点没有子节点。
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）
观察者模式（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 对象进行访问操作。
来着token的分享
技术交流群：737776595
以上是关于详细讲解23种设计模式的主要内容，如果未能解决你的问题，请参考以下文章