网站开发市场价,手机改ip地址软件免费,医院网站如何备案,秀洲区住房和城乡建设局网站前言 行为型模式是面向对象设计中的一类设计模式#xff0c;它关注对象之间的通信和相互作用#xff0c;以实现特定的行为或功能。在C#中#xff0c;有许多常见的行为型模式#xff0c;下面将对其中10种行为型模式进行介绍#xff0c;并给出相应的代码示例。 目录 前言1.…前言 行为型模式是面向对象设计中的一类设计模式它关注对象之间的通信和相互作用以实现特定的行为或功能。在C#中有许多常见的行为型模式下面将对其中10种行为型模式进行介绍并给出相应的代码示例。 目录 前言1. 命令模式Command示例代码解释 2. 解释器模式Interpreter示例代码解释 3. 迭代器模式Iterator示例代码解释 4. 中介者模式Mediator示例代码解释 5. 备忘录模式Memento示例代码解释 6. 观察者模式Observer示例代码解释 7. 状态模式State示例代码解释 8. 策略模式Strategy示例代码解释 9. 模板方法模式Template Method示例代码解释 10. 访问者模式Visitor示例代码解释 1. 命令模式Command
命令模式将请求封装成一个对象从而使得请求发送者和接收者解耦。
示例代码
// 命令接口
public interface ICommand
{void Execute();
}// 具体命令类
public class ConcreteCommand : ICommand
{private Receiver _receiver;public ConcreteCommand(Receiver receiver){_receiver receiver;}public void Execute(){_receiver.Action();}
}// 接收者类
public class Receiver
{public void Action(){Console.WriteLine(执行命令);}
}// 客户端类
public class Client
{public void Main(){Receiver receiver new Receiver();ICommand command new ConcreteCommand(receiver);// 客户端只需调用命令的执行方法即可command.Execute();}
}解释
在上面的示例中ICommand接口定义了命令的统一执行方法Execute()ConcreteCommand是具体的命令类通过调用Receiver的Action()方法来实现对请求的处理。客户端通过实例化具体的命令对象并调用其执行方法来发出请求。
2. 解释器模式Interpreter
解释器模式定义了一种语言文法的表示并定义了一个解释器来解释语言中的句子。
示例代码
// 抽象表达式类
public abstract class AbstractExpression
{public abstract void Interpret(Context context);
}// 终结符表达式类
public class TerminalExpression : AbstractExpression
{public override void Interpret(Context context){Console.WriteLine(解释终结符表达式);}
}// 非终结符表达式类
public class NonterminalExpression : AbstractExpression
{public override void Interpret(Context context){Console.WriteLine(解释非终结符表达式);}
}// 上下文类
public class Context
{public string Input { get; set; }public string Output { get; set; }
}// 客户端类
public class Client
{public void Main(){Context context new Context();ListAbstractExpression expressions new ListAbstractExpression();expressions.Add(new TerminalExpression());expressions.Add(new NonterminalExpression());foreach (AbstractExpression expression in expressions){expression.Interpret(context);}}
}解释
在上面的示例中AbstractExpression是抽象表达式类由TerminalExpression和NonterminalExpression继承并分别实现了解释终结符和非终结符表达式的方法。Context类存储解释器的上下文信息。客户端通过实例化具体的解释器对象并调用其解释方法来实现对句子的解释。
3. 迭代器模式Iterator
迭代器模式提供一种顺序访问集合对象元素的方法而不需要暴露集合对象的内部结构。
示例代码
// 迭代器接口
public interface IIteratorT
{bool HasNext();T Next();
}// 集合接口
public interface ICollectionT
{IIteratorT CreateIterator();
}// 具体集合类
public class ConcreteCollectionT : ICollectionT
{private ListT _items new ListT();public void Add(T item){_items.Add(item);}public IIteratorT CreateIterator(){return new ConcreteIteratorT(this);}public T GetItem(int index){return _items[index];}public int Count{get { return _items.Count; }}
}// 具体迭代器类
public class ConcreteIteratorT : IIteratorT
{private ICollectionT _collection;private int _position 0;public ConcreteIterator(ICollectionT collection){_collection collection;}public bool HasNext(){return _position _collection.Count;}public T Next(){T item _collection.GetItem(_position);_position;return item;}
}// 客户端类
public class Client
{public void Main(){ICollectionstring collection new ConcreteCollectionstring();collection.Add(Item 1);collection.Add(Item 2);collection.Add(Item 3);IIteratorstring iterator collection.CreateIterator();while (iterator.HasNext()){string item iterator.Next();Console.WriteLine(item);}}
}解释
在上面的示例中IIteratorT定义了迭代器接口ICollectionT定义了集合接口并包含一个创建迭代器的方法CreateIterator()。ConcreteCollectionT是具体的集合类实现了集合接口并在CreateIterator()方法中返回具体的迭代器对象ConcreteIteratorT。客户端通过调用集合的CreateIterator()方法来获取迭代器并可以通过迭代器的HasNext()和Next()方法依次访问集合中的元素。
4. 中介者模式Mediator
中介者模式定义了一个中介对象来封装一组对象之间的交互使得这些对象之间不需要直接相互通信。
示例代码
// 中介者接口
public interface IMediator
{void SendMessage(string message, Colleague colleague);
}// 同事类
public abstract class Colleague
{protected IMediator _mediator;public Colleague(IMediator mediator){_mediator mediator;}public abstract void ReceiveMessage(string message);public abstract void SendMessage(string message);
}// 具体同事类
public class ConcreteColleagueA : Colleague
{public ConcreteColleagueA(IMediator mediator) : base(mediator) { }public override void ReceiveMessage(string message){Console.WriteLine(Colleague A received: message);}public override void SendMessage(string message){_mediator.SendMessage(message, this);}
}public class ConcreteColleagueB : Colleague
{public ConcreteColleagueB(IMediator mediator) : base(mediator) { }public override void ReceiveMessage(string message){Console.WriteLine(Colleague B received: message);}public override void SendMessage(string message){_mediator.SendMessage(message, this);}
}// 具体中介者类
public class ConcreteMediator : IMediator
{private ConcreteColleagueA _colleagueA;private ConcreteColleagueB _colleagueB;public void SetColleagueA(ConcreteColleagueA colleagueA){_colleagueA colleagueA;}public void SetColleagueB(ConcreteColleagueB colleagueB){_colleagueB colleagueB;}public void SendMessage(string message, Colleague colleague){if (colleague _colleagueA){_colleagueB.ReceiveMessage(message);}else if (colleague _colleagueB){_colleagueA.ReceiveMessage(message);}}
}// 客户端类
public class Client
{public void Main(){ConcreteMediator mediator new ConcreteMediator();ConcreteColleagueA colleagueA new ConcreteColleagueA(mediator);ConcreteColleagueB colleagueB new ConcreteColleagueB(mediator);mediator.SetColleagueA(colleagueA);mediator.SetColleagueB(colleagueB);colleagueA.SendMessage(Hello from Colleague A!);colleagueB.SendMessage(Hi from Colleague B!);}
}解释
在上述示例中IMediator是中介者接口定义了发送消息的方法SendMessage()Colleague是同事类每个同事类都持有一个对中介者的引用。ConcreteColleagueA和ConcreteColleagueB是具体的同事类实现了同事接口并在自己的消息发送方法中调用中介者的SendMessage()方法。ConcreteMediator是具体的中介者类负责将消息转发给其他同事。客户端首先创建中介者对象和同事对象然后通过设置同事的引用到中介者上实现同事之间的消息交互。
5. 备忘录模式Memento
备忘录模式用于保存和恢复对象的状态并在不破坏封装性的前提下将对象状态的保存和恢复功能委托给其他对象。
示例代码
// 备忘录类
public class Memento
{public string State { get; private set; }public Memento(string state){State state;}
}// 发起人类
public class Originator
{public string State { get; set; }public Memento CreateMemento(){return new Memento(State);}public void SetMemento(Memento memento){State memento.State;}
}// 管理者类
public class Caretaker
{private Memento _memento;public void SaveMemento(Memento memento){_memento memento;}public Memento RetrieveMemento(){return _memento;}
}// 客户端类
public class Client
{public void Main(){Originator originator new Originator();Caretaker caretaker new Caretaker();originator.State State 1;caretaker.SaveMemento(originator.CreateMemento());originator.State State 2;caretaker.SaveMemento(originator.CreateMemento());originator.State State 3;caretaker.SaveMemento(originator.CreateMemento());Memento memento caretaker.RetrieveMemento();originator.SetMemento(memento);Console.WriteLine(originator.State); // 输出State 3}
}解释
在上述示例中Memento类是备忘录类用于存储对象的状态Originator类是发起人类负责创建备忘录并根据备忘录恢复对象的状态Caretaker类是管理者类负责保存和获取备忘录。客户端通过创建发起人、管理者和备忘录对象并依次设定发起人的状态并将备忘录保存到管理者中最后可以通过管理者获取备忘录对象并将状态恢复到该备忘录所代表的状态。
6. 观察者模式Observer
观察者模式定义了一种一对多的依赖关系使得当一个对象的状态发生改变时其依赖对象都会收到通知并自动更新。
示例代码
// 主题接口
public interface ISubject
{void Attach(IObserver observer);void Detach(IObserver observer);void Notify();
}// 具体主题类
public class ConcreteSubject : ISubject
{private ListIObserver _observers new ListIObserver();private string _state;public string State{get { return _state; }set{_state value;Notify();}}public void Attach(IObserver observer){_observers.Add(observer);}public void Detach(IObserver observer){_observers.Remove(observer);}public void Notify(){foreach (IObserver observer in _observers){observer.Update();}}
}// 观察者接口
public interface IObserver
{void Update();
}// 具体观察者类
public class ConcreteObserver : IObserver
{private string _name;private ConcreteSubject _subject;public ConcreteObserver(string name, ConcreteSubject subject){_name name;_subject subject;}public void Update(){Console.WriteLine($Observer {_name} received state: {_subject.State});}
}// 客户端类
public class Client
{public void Main(){ConcreteSubject subject new ConcreteSubject();ConcreteObserver observerA new ConcreteObserver(A, subject);ConcreteObserver observerB new ConcreteObserver(B, subject);subject.Attach(observerA);subject.Attach(observerB);subject.State State 1;// 输出:// Observer A received state: State 1// Observer B received state: State 1subject.State State 2;// 输出:// Observer A received state: State 2// Observer B received state: State 2subject.Detach(observerB);subject.State State 3;// 输出:// Observer A received state: State 3}
}解释
在上述示例中ISubject是主题接口定义了对观察者的操作方法ConcreteSubject是具体主题类实现了主题接口并在状态改变时通知所有观察者。IObserver是观察者接口定义了观察者的更新方法ConcreteObserver是具体观察者类实现了观察者接口并在收到通知时输出主题的状态。在客户端中首先创建主题和观察者对象然后将观察者注册到主题上最后可以通过改变主题的状态来触发对应观察者的更新。
7. 状态模式State
状态模式允许对象在其内部状态发生改变时改变其行为使得对象看起来像是在修改了其回归类。
示例代码
// 状态接口
public interface IState
{void Handle(Context context);
}// 具体状态类
public class ConcreteStateA : IState
{public void Handle(Context context){Console.WriteLine(State A handling);context.State new ConcreteStateB();}
}public class ConcreteStateB : IState
{public void Handle(Context context){Console.WriteLine(State B handling);context.State new ConcreteStateA();}
}// 上下文类
public class Context
{public IState State { get; set; }public Context(IState initState){State initState;}public void Request(){State.Handle(this);}
}// 客户端类
public class Client
{public void Main(){Context context new Context(new ConcreteStateA());context.Request();// 输出: State A handlingcontext.Request();// 输出: State B handlingcontext.Request();// 输出: State A handling}
}解释
在上述示例中IState是状态接口定义了状态的处理方法Handle()ConcreteStateA和ConcreteStateB是具体状态类实现了状态接口并根据自身的逻辑处理状态的改变。Context类是上下文类内部存储当前的状态并在请求方法Request()中调用当前状态的处理方法。在客户端中首先创建上下文对象和初始状态对象然后可以通过调用上下文的请求方法来触发状态的改变从而导致不同的行为。
8. 策略模式Strategy
策略模式定义了一系列的算法将每个算法都封装起来并使它们可以相互替换。
示例代码
// 策略接口
public interface IStrategy
{void Execute();
}// 具体策略类
public class ConcreteStrategyA : IStrategy
{public void Execute(){Console.WriteLine(Executing Strategy A);}
}public class ConcreteStrategyB : IStrategy
{public void Execute(){Console.WriteLine(Executing Strategy B);}
}// 上下文类
public class Context
{private IStrategy _strategy;public Context(IStrategy strategy){_strategy strategy;}public void ExecuteStrategy(){_strategy.Execute();}
}// 客户端类
public class Client
{public void Main(){IStrategy strategyA new ConcreteStrategyA();IStrategy strategyB new ConcreteStrategyB();Context context new Context(strategyA);// 输出: Executing Strategy Acontext.ExecuteStrategy();context new Context(strategyB);// 输出: Executing Strategy Bcontext.ExecuteStrategy();}
}解释
在上述示例中IStrategy是策略接口定义了算法的执行方法Execute()ConcreteStrategyA和ConcreteStrategyB是具体策略类分别实现了策略接口并提供不同的算法实现。Context类是上下文类持有一个策略对象并执行策略对象的算法。客户端首先创建不同的策略对象然后根据需要将不同的策略对象传递给上下文并调用上下文的执行方法来执行具体的算法。
9. 模板方法模式Template Method
模板方法模式定义了一个操作中的算法框架将一些步骤延迟到子类中实现。
示例代码
// 抽象类
public abstract class AbstractClass
{public void TemplateMethod(){Console.WriteLine(Template Method - Step 1);PrimitiveOperation1();Console.WriteLine(Template Method - Step 2);PrimitiveOperation2();}protected abstract void PrimitiveOperation1();protected abstract void PrimitiveOperation2();
}// 具体类
public class ConcreteClassA : AbstractClass
{protected override void PrimitiveOperation1(){Console.WriteLine(Concrete Class A - Primitive Operation 1);}protected override void PrimitiveOperation2(){Console.WriteLine(Concrete Class A - Primitive Operation 2);}
}public class ConcreteClassB : AbstractClass
{protected override void PrimitiveOperation1(){Console.WriteLine(Concrete Class B - Primitive Operation 1);}protected override void PrimitiveOperation2(){Console.WriteLine(Concrete Class B - Primitive Operation 2);}
}// 客户端类
public class Client
{public void Main(){AbstractClass abstractClass new ConcreteClassA();// 输出:// Template Method - Step 1// Concrete Class A - Primitive Operation 1// Template Method - Step 2// Concrete Class A - Primitive Operation 2abstractClass.TemplateMethod();abstractClass new ConcreteClassB();// 输出:// Template Method - Step 1// Concrete Class B - Primitive Operation 1// Template Method - Step 2// Concrete Class B - Primitive Operation 2abstractClass.TemplateMethod();}
}解释
在上述示例中AbstractClass是抽象类定义了模板方法TemplateMethod()该方法包含了一系列的步骤并调用了抽象方法PrimitiveOperation1()和PrimitiveOperation2()。ConcreteClassA和ConcreteClassB是具体类继承自抽象类并实现了抽象方法。客户端中首先创建具体类的对象并调用其模板方法从而按照固定的步骤执行特定的算法。
10. 访问者模式Visitor
访问者模式定义了一种在不改变被访问对象结构的前提下可以对该对象的元素进行操作的方法。
示例代码
// 元素接口
public interface IElement
{void Accept(IVisitor visitor);
}// 具体元素类
public class ConcreteElementA : IElement
{public void Accept(IVisitor visitor){visitor.VisitConcreteElementA(this);}
}public class ConcreteElementB : IElement
{public void Accept(IVisitor visitor){visitor.VisitConcreteElementB(this);}
}// 访问者接口
public interface IVisitor
{void VisitConcreteElementA(ConcreteElementA element);void VisitConcreteElementB(ConcreteElementB element);
}// 具体访问者类
public class ConcreteVisitor : IVisitor
{public void VisitConcreteElementA(ConcreteElementA element){Console.WriteLine(Visiting Concrete Element A);}public void VisitConcreteElementB(ConcreteElementB element){Console.WriteLine(Visiting Concrete Element B);}
}// 对象结构类
public class ObjectStructure
{private ListIElement _elements new ListIElement();public void AddElement(IElement element){_elements.Add(element);}public void Accept(IVisitor visitor){foreach (IElement element in _elements){element.Accept(visitor);}}
}// 客户端类
public class Client
{public void Main(){ObjectStructure objectStructure new ObjectStructure();objectStructure.AddElement(new ConcreteElementA());objectStructure.AddElement(new ConcreteElementB());IVisitor visitor new ConcreteVisitor();objectStructure.Accept(visitor);// 输出:// Visiting Concrete Element A// Visiting Concrete Element B}
}解释
在上述示例中IElement是元素接口定义了对元素的访问方法Accept()ConcreteElementA和ConcreteElementB是具体元素类实现了元素接口并在自己的访问方法中调用访问者的具体访问方法。IVisitor是访问者接口定义了访问者的具体访问方法ConcreteVisitor是具体访问者类实现了访问者接口并在每个具体访问方法中对元素进行访问。ObjectStructure是对象结构类包含了需要被访问的元素并提供对外的访问方法。在客户端中首先创建对象结构对象和具体元素对象并将元素对象加入到对象结构中然后通过创建具体访问者对象来访问对象结构中的元素。
