23种设计模式的定义和应用场景：
单例模式（Singleton）、工厂方法模式（Factory Method）、抽象工厂模式（Abstract Factory）、建造者模式（Builder）、原型模式（Prototype）
适配器模式（Adapter）、桥接模式（Bridge）、组合模式（Composite）、装饰器模式（Decorator）、外观模式（Facade）、享元模式（Flyweight）、代理模式（Proxy）
责任链模式（Chain of Resposibility）、命令模式（Command）、解释器模式（Interpreter）、迭代器模式（Iterator）、中介者模式（Mediator）、备忘录模式（Mementor）、观察者模式（Oberver）、状态模式（State）、策略模式（Strategy）、模板方法模式（Template Method）、访问者模式 (Visitor）
3-行为型模式-C#代码
3. 行为型模式
3.1 责任链模式 (Chain of Responsibility)
定义: 使多个对象都有机会处理请求，从而避免请求的发送者与接收者耦合。
应用场景: 日志记录、异常处理。
public abstract class Handler
{
protected Handler _successor;
public void SetSuccessor(Handler successor) => _successor = successor;
public abstract void HandleRequest(int request);
}
public class ConcreteHandler1 : Handler
{
public override void HandleRequest(int request)
{
if (request >= 0 && request < 10)
{
Console.WriteLine($"{this.GetType().Name} handled request {request}");
}
else if (_successor != null)
{
_successor.HandleRequest(request);
}
}
}
public class ConcreteHandler2 : Handler
{
public override void HandleRequest(int request)
{
if (request >= 10 && request < 20)
{
Console.WriteLine($"{this.GetType().Name} handled request {request}");
}
else if (_successor != null)
{
_successor.HandleRequest(request);
}
}
}3.2 命令模式 (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("Receiver Action");
}
public class Invoker
{
private ICommand _command;
public void SetCommand(ICommand command) => _command = command;
public void ExecuteCommand() => _command.Execute();
}3.3 解释器模式 (Interpreter)
定义: 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
应用场景: 正则表达式、SQL解析。
public interface IExpression
{
bool Interpret(string context);
}
public class TerminalExpression : IExpression
{
private string _data;
public TerminalExpression(string data) => _data = data;
public bool Interpret(string context) => context.Contains(_data);
}
public class OrExpression : IExpression
{
private IExpression _expr1;
private IExpression _expr2;
public OrExpression(IExpression expr1, IExpression expr2)
{
_expr1 = expr1;
_expr2 = expr2;
}
public bool Interpret(string context) => _expr1.Interpret(context) || _expr2.Interpret(context);
}3.4 迭代器模式 (Iterator)
定义: 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。
应用场景: 遍历集合。
public interface IIterator
{
bool HasNext();
object Next();
}
public interface IAggregate
{
IIterator CreateIterator();
}
public class ConcreteAggregate : IAggregate
{
private List<object> _items = new List<object>();
public IIterator CreateIterator() => new ConcreteIterator(this);
public int Count => _items.Count;
public object this[int index]
{
get => _items[index];
set => _items.Insert(index, value);
}
}
public class ConcreteIterator : IIterator
{
private ConcreteAggregate _aggregate;
private int _current = 0;
public ConcreteIterator(ConcreteAggregate aggregate) => _aggregate = aggregate;
public bool HasNext() => _current < _aggregate.Count;
public object Next() => _aggregate[_current++];
}3.5 中介者模式 (Mediator)
定义: 用一个中介对象来封装一系列的对象交互。
应用场景: 聊天室、事件分发系统。
public abstract class Mediator
{
public abstract void Send(string message, Colleague colleague);
}
public abstract class Colleague
{
protected Mediator _mediator;
public Colleague(Mediator mediator) => _mediator = mediator;
}
public class ConcreteColleague1 : Colleague
{
public ConcreteColleague1(Mediator mediator) : base(mediator) { }
public void Send(string message) => _mediator.Send(message, this);
public void Notify(string message) => Console.WriteLine($"Colleague1 gets message: {message}");
}
public class ConcreteColleague2 : Colleague
{
public ConcreteColleague2(Mediator mediator) : base(mediator) { }
public void Send(string message) => _mediator.Send(message, this);
public void Notify(string message) => Console.WriteLine($"Colleague2 gets message: {message}");
}
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);
}
}
}3.6 备忘录模式 (Memento)
定义: 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
应用场景: 撤销操作、游戏存档。
public class Memento
{
public string State { get; }
public Memento(string state) => State = state;
}
public class Originator
{
public string State { get; set; }
public Memento CreateMemento() => new Memento(State);
public void SetMemento(Memento memento) => State = memento.State;
}
public class Caretaker
{
public Memento Memento { get; set; }
}3.7 观察者模式 (Observer)
定义: 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
应用场景: 事件处理系统、消息队列。
public interface IObserver
{
void Update();
}
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 string _state;
public string State
{
get => _state;
set
{
_state = value;
Notify();
}
}
public void Attach(IObserver observer) => _observers.Add(observer);
public void Detach(IObserver observer) => _observers.Remove(observer);
public void Notify() => _observers.ForEach(o => o.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} has been updated with state {_subject.State}");
}3.8 状态模式 (State)
定义: 允许一个对象在其内部状态改变时改变它的行为。
应用场景: 订单状态、游戏角色状态。
public interface IState
{
void Handle(Context context);
}
public class ConcreteStateA : IState
{
public void Handle(Context context) => context.State = new ConcreteStateB();
}
public class ConcreteStateB : IState
{
public void Handle(Context context) => context.State = new ConcreteStateA();
}
public class Context
{
public IState State { get; set; }
public Context(IState state) => State = state;
public void Request() => State.Handle(this);
}3.9 策略模式 (Strategy)
定义: 定义一系列算法，将它们一个个封装起来，并且使它们可以互相替换。
应用场景: 排序算法、支付方式、商品折扣。
public interface IStrategy
{
void AlgorithmInterface();
}
public class ConcreteStrategyA : IStrategy
{
public void AlgorithmInterface() => Console.WriteLine("ConcreteStrategyA Algorithm");
}
public class ConcreteStrategyB : IStrategy
{
public void AlgorithmInterface() => Console.WriteLine("ConcreteStrategyB Algorithm");
}
public class Context
{
private IStrategy _strategy;
public Context(IStrategy strategy) => _strategy = strategy;
public void ContextInterface() => _strategy.AlgorithmInterface();
}商品折扣代码示例：（电商平台促销策略（打折和满减）示例代码）:
public interface IPromotionStrategy
{
decimal ApplyApromotion(decimal originalPrice);
}
/// <summary>
/// 打折促销策略
/// </summary>
public class DiscountPromition : IPromotionStrategy
{
private readonly decimal _discountRate;
public DiscountPromition(decimal discountRate)
{
_discountRate = discountRate;
}
public decimal ApplyApromotion(decimal originalPrice)
{
return originalPrice * (1 - _discountRate);
}
}
/// <summary>
/// 满减促销策略
/// </summary>
public class FullReductionPromition : IPromotionStrategy
{
private readonly decimal _fullAmount;
private readonly decimal _reductionAmout;
public FullReductionPromition(decimal fullAmount, decimal reductionAmout)
{
_fullAmount = fullAmount;
_reductionAmout = reductionAmout;
}
public decimal ApplyApromotion(decimal originalPrice)
{
if (originalPrice >= _fullAmount)
{
return originalPrice - _reductionAmout;
}
return originalPrice;
}
}
/// <summary>
/// 购物车类，使用促销策略
/// </summary>
public class ShopingCart
{
private readonly IPromotionStrategy _promotionStrategy;
public ShopingCart(IPromotionStrategy promotionStrategy)
{
_promotionStrategy = promotionStrategy;
}
public decimal CalculationTotal(decimal originalPrice)
{
return _promotionStrategy.ApplyApromotion(originalPrice);
}
}
/// <summary>
/// Demo call
/// </summary>
class Program
{
static void Main()
{
// 创建打折促销策略，打8折
IPromotionStrategy promotionStrategy = new DiscountPromition(0.2m);
ShopingCart shopingCart = new ShopingCart(promotionStrategy);
var discountedPrice = shopingCart.CalculationTotal(100);
Console.WriteLine($"打折后的价格:{discountedPrice}");// 80
// 创建满减促销策略
IPromotionStrategy promotionStrategy2 = new FullReductionPromition(100m, 10m);
ShopingCart shopingCart2 = new ShopingCart(promotionStrategy2);
var fullReducedPrice = shopingCart2.CalculationTotal(100);
Console.WriteLine($"满减后的价格:{fullReducedPrice}");// 90
Console.ReadLine();
}
}3.10 模板方法模式 (Template Method)
定义: 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
应用场景: 框架设计、算法流程固定但某些步骤可变。
public abstract class AbstractClass
{
public void TemplateMethod()
{
PrimitiveOperation1();
PrimitiveOperation2();
}
public abstract void PrimitiveOperation1();
public abstract void PrimitiveOperation2();
}
public class ConcreteClass : AbstractClass
{
public override void PrimitiveOperation1() => Console.WriteLine("ConcreteClass PrimitiveOperation1");
public override void PrimitiveOperation2() => Console.WriteLine("ConcreteClass PrimitiveOperation2");
}3.11 访问者模式 (Visitor)
定义: 表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
应用场景: 编译器、文档处理。
using System;
using System.Collections.Generic;
// 元素接口
interface IElement
{
void Accept(IVisitor visitor);
}
// 具体元素A
class ConcreteElementA : IElement
{
public void Accept(IVisitor visitor)
{
visitor.VisitConcreteElementA(this);
}
public void OperationA()
{
Console.WriteLine("ConcreteElementA: OperationA");
}
}
// 具体元素B
class ConcreteElementB : IElement
{
public void Accept(IVisitor visitor)
{
visitor.VisitConcreteElementB(this);
}
public void OperationB()
{
Console.WriteLine("ConcreteElementB: OperationB");
}
}
// 访问者接口
interface IVisitor
{
void VisitConcreteElementA(ConcreteElementA element);
void VisitConcreteElementB(ConcreteElementB element);
}
// 具体访问者1
class ConcreteVisitor1 : IVisitor
{
public void VisitConcreteElementA(ConcreteElementA element)
{
Console.WriteLine("ConcreteVisitor1: Visiting ConcreteElementA");
element.OperationA();
}
public void VisitConcreteElementB(ConcreteElementB element)
{
Console.WriteLine("ConcreteVisitor1: Visiting ConcreteElementB");
element.OperationB();
}
}
// 具体访问者2
class ConcreteVisitor2 : IVisitor
{
public void VisitConcreteElementA(ConcreteElementA element)
{
Console.WriteLine("ConcreteVisitor2: Visiting ConcreteElementA");
element.OperationA();
}
public void VisitConcreteElementB(ConcreteElementB element)
{
Console.WriteLine("ConcreteVisitor2: Visiting ConcreteElementB");
element.OperationB();
}
}
// 对象结构
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);
}
}
}
// 客户端代码
class Program
{
static void Main(string[] args)
{
// 创建对象结构
ObjectStructure objectStructure = new ObjectStructure();
objectStructure.Attach(new ConcreteElementA());
objectStructure.Attach(new ConcreteElementB());
// 创建访问者
ConcreteVisitor1 visitor1 = new ConcreteVisitor1();
ConcreteVisitor2 visitor2 = new ConcreteVisitor2();
// 使用访问者1访问对象结构
objectStructure.Accept(visitor1);
// 使用访问者2访问对象结构
objectStructure.Accept(visitor2);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
