C#设计模式(三)
👉一、状态模式(State)
介绍:
在Unity中使用状态模式是一种行为设计模式,它允许对象在其内部状态改变时改变其行为。在Unity中,状态模式通常用于实现角色的不同行为状态切换,例如玩家角色的行走、奔跑、跳跃、攻击等。
代码如下:
public interface IState
{
void HandleState(Context context);
}
public class ConcreteStateA : IState
{
public void HandleState(Context context)
{
Debug.Log("Handle State A");
context.State = new ConcreteStateB();
}
}
public class ConcreteStateB : IState
{
public void HandleState(Context context)
{
Debug.Log("Handle State B");
context.State = new ConcreteStateA();
}
}
public class Context
{
public IState State { get; set; }
public Context(IState state)
{
State = state;
}
public void Request()
{
State.HandleState(this);
}
}
👉二、访问者模式(Visitor)
介绍:
Unity中的访问者模式是一种将数据结构和数据操作分离的设计模式,主要用于在不改变数据结构的前提下定义作用于这些元素的新操作。访问者模式的基本思想是针对系统中拥有的某些固定类型的对象结构(元素),在其内部提供一个accept()方法用来接受访问者对象的访问。不同的访问者对同一元素的访问内容不同,因此相同的元素可以产生不同的结果。
代码如下:
public interface IVisitor
{
void Visit(ConcreteElementA element);
void Visit(ConcreteElementB element);
}
public abstract class Element
{
public abstract void Accept(IVisitor visitor);
}
public class ConcreteElementA : Element
{
public override void Accept(IVisitor visitor)
{
visitor.Visit(this);
}
public string OperationA()
{
return "Concrete Element A Operation";
}
}
public class ConcreteElementB : Element
{
public override void Accept(IVisitor visitor)
{
visitor.Visit(this);
}
public string OperationB()
{
return "Concrete Element B Operation";
}
}
public class ConcreteVisitor : IVisitor
{
public void Visit(ConcreteElementA element)
{
Debug.Log(element.OperationA());
}
public void Visit(ConcreteElementB element)
{
Debug.Log(element.OperationB());
}
}
public class ObjectStructure
{
private List<Element> _elements = new List<Element>();
public void AddElement(Element element)
{
_elements.Add(element);
}
public void RemoveElement(Element element)
{
_elements.Remove(element);
}
public void Accept(IVisitor visitor)
{
foreach (Element element in _elements)
{
element.Accept(visitor);
}
}
}
👉三、观察者模式(Observer)
介绍:
观察者模式是软件开发中一种十分常见的设计模式,又被称为发布-订阅模式,属于行为型模式的一种。它定义了一种一对多的依赖关系,让多个观察者对象(Observer)同时监听某一个主题对象(Subject)。这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。
代码如下:
public interface IObserver
{
void Update(ISubject subject);
}
public interface ISubject
{
void Attach(IObserver observer);
void Detach(IObserver observer);
void Notify();
}
public abstract class Subject : ISubject
{
private List<IObserver> _observers = new List<IObserver>();
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(this);
}
}
}
public class ConcreteSubject : Subject
{
private string _state;
public string State
{
get
{
return _state;
}
set
{
_state = value;
Notify();
}
}
}
public class ConcreteObserver : IObserver
{
private string _observerState;
public void Update(ISubject subject)
{
if (subject is ConcreteSubject)
{
ConcreteSubject concreteSubject = (ConcreteSubject)subject;
_observerState = concreteSubject.State;
Debug.Log("Observer State: " + _observerState);
}
}
}
👉四、备忘录模式(Memento)
介绍:
Unity备忘录模式(Memento Pattern)是一种行为设计模式,主要用于在不破坏封装性的情况下捕获对象的内部状态,并在对象之外保存该状态。备忘录模式允许对象在需要时恢复到之前的状态,而不暴露对象的实现细节。
代码如下:
public class Memento
{
public int Level { get; private set; }
public int Score { get; private set; }
public Memento(int level, int score)
{
Level = level;
Score = score;
}
}
public class Originator
{
public int Level { get; set; }
public int Score { get; set; }
public Memento Save()
{
return new Memento(Level, Score);
}
public void Load(Memento memento)
{
Level = memento.Level;
Score = memento.Score;
}
}
public class Caretaker
{
private Dictionary<string, Memento> _mementos = new Dictionary<string, Memento>();
public void SaveState(string savepoint, Memento memento)
{
_mementos.Add(savepoint, memento);
}
public Memento LoadState(string savepoint)
{
if (!_mementos.ContainsKey(savepoint))
{
return null;
}
Memento memento = _mementos[savepoint];
_mementos.Remove(savepoint);
return memento;
}
}
👉五、中介者模式(Mediator)
介绍:
Unity中介者模式是一种行为型设计模式,主要用于减少对象之间的直接交互,通过引入一个中介者对象来封装一组对象的交互行为,从而降低它们之间的耦合度,并简化彼此之间的通信过程。
中介者模式定义了一个中介者对象,该对象封装了一组对象的交互。通过中介者,对象可以发送和接收消息,而不需要直接相互引用,从而减少了它们之间的耦合度。这种模式特别适用于复杂系统中,当多个对象需要频繁交互且直接通信会导致系统难以维护和扩展时。
代码如下:
public abstract class Colleague
{
protected IMediator _mediator;
public Colleague(IMediator mediator)
{
_mediator = mediator;
}
public abstract void Send(string message);
public abstract void Receive(string message);
}
public interface IMediator
{
void AddColleague(Colleague colleague);
void SendMessage(Colleague sender, string message);
}
public class ConcreteColleagueA : Colleague
{
public ConcreteColleagueA(IMediator mediator) : base(mediator)
{
}
public override void Send(string message)
{
_mediator.SendMessage(this, message);
}
public override void Receive(string message)
{
Debug.Log("Concrete Colleague A received message: " + message);
}
}
public class ConcreteColleagueB : Colleague
{
public ConcreteColleagueB(IMediator mediator) : base(mediator)
{
}
public override void Send(string message)
{
_mediator.SendMessage(this, message);
}
public override void Receive(string message)
{
Debug.Log("Concrete Colleague B received message: " + message);
}
}
public class ConcreteMediator : IMediator
{
private List<Colleague> _colleagues = new List<Colleague>();
public void AddColleague(Colleague colleague)
{
_colleagues.Add(colleague);
}
public void SendMessage(Colleague sender, string message)
{
foreach (Colleague colleague in _colleagues)
{
if (colleague != sender)
{
colleague.Receive(message);
}
}
}
}
- 点赞
- 收藏
- 关注作者
评论(0)