设计模式--观察者模式与命令模式

观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生改变时，会通知所有观察者对象，使他们能够自动更新自己。 

 

命令模式：

将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
作用：
1、它能较容易地设计一个命令队列；
2、在需要的情况下，可以较容易地将命令记入日志；
3、允许接收请求的一方决定是否要否决请求；
4、可以容易地实现对请求的撤销和重做；
5、由于加进新的具体命令类不影响其他的类，因此增加新的具体命令类很容易。

 

区别：

命令模式发起通知方内部只有命令的对象，通过命令来完成。--通知的是命令。

观察者模式发起通知的内部是接收通知的对象，通过调用接受对象的方法来完成。--通知的是接收对象，由接收对象自己执行对应的方法。

 

观察者模式：

//抽象观察者
abstract class Observer
{
public abstract void Update();
}

//观察者实现

class ConcreteObserver : Observer
{
string name;
public string observerState="";
ConcreteSubject subject;

public ConcreteObserver(ConcreteSubject subject, string name)
{
this.subject = subject;
this.name = name;
this.observerState = name + "做自己的事";
}

public override void Update()
{
observerState = subject.SubjectState;
Console.WriteLine("观察者{0}的新状态{1}",name,observerState);
}

public ConcreteSubject Subject { get { return subject; } set { subject = value; } }

}

//抽象主题
abstract class Subject
{
IList<Observer> observers = new List<Observer>();

public void Attach(Observer obs)
{
observers.Add(obs);
}

public void Detach(Observer obs)
{
observers.Remove(obs);
}

public void Notify()
{
foreach (Observer item in observers)
{
item.Update();
}
}

}

//主题具体实现

class ConcreteSubject:Subject
{
public string SubjectState { get; set; }
}

调用：

ConcreteSubject subject = new ConcreteSubject();
ConcreteObserver obs1 = new ConcreteObserver(subject, "name1");
Console.WriteLine(obs1.observerState);
ConcreteObserver obs2= new ConcreteObserver(subject, "name2");
Console.WriteLine(obs2.observerState);
subject.Attach(obs1);
subject.Attach(obs2);
Console.WriteLine("更新状态");
subject.SubjectState = "abc";
subject.Notify();

 

 

 

命令模式：

//基本

//知道如何实施与执行一个与请求相关的操作，任何类都可能作为一个接收者。
class Receiver
{
public void Action()
{
Console.WriteLine("执行请求！");
}
public void Action1()
{
Console.WriteLine("执行请求2！");
}
}

//声明执行操作的接口
abstract class Command
{
protected Receiver receiver;

public Command(Receiver receiver)
{
this.receiver = receiver;
}

abstract public void Execute();

}

//将一个接收者对象绑定于一个动作，调用接收者相应的操作，以实现Execute。
class ConcreteCommand : Command
{
public ConcreteCommand(Receiver receiver) : base(receiver)
{
}

public override void Execute()
{
receiver.Action();
}
}

class Concrete1Command : Command
{
public Concrete1Command(Receiver receiver) : base(receiver)
{
}

public override void Execute()
{
receiver.Action1();
}
}

 

class Invoker//（调用者）
{
List<Command> cmds = new List<Command>();
public void SetCommand(Command cmd)
{
cmds.Add(cmd);
}
public void CancleCommand(Command cmd)
{
cmds.Remove(cmd);
}
public void ExecuteCommand()
{
foreach (Command item in cmds)
{
item.Execute();
}
}

}

调用：

Receiver r = new Receiver();
Command c = new ConcreteCommand(r);
Command c1 = new Concrete1Command(r);
Command c0 = new Concrete1Command(r);
Invoker i = new Invoker();
i.SetCommand(c);
i.SetCommand(c1);
i.SetCommand(c0);
i.ExecuteCommand();
Console.WriteLine("移除命令后：");
i.CancleCommand(c0);
i.ExecuteCommand();

  

 

转载于:https://www.cnblogs.com/buzhidaojiaoshenme/p/6731523.html