Definición del modo de observador (publicación / suscripción): también conocido como modo de publicación-suscripción, que define una relación de dependencia de uno a muchos, lo que permite que varios objetos observadores supervisen un determinado objeto sujeto al mismo tiempo. Cuando el objeto sujeto cambia, será notificado Todos los objetos observadores les permiten actualizarse automáticamente.
ventaja:
- El desacoplamiento permite que ambas partes se acoplen para depender de la abstracción en lugar de la especificidad, de modo que sus cambios no afecten a los cambios de la otra parte, lo que se ajusta al principio de inversión de la dependencia.
Desventajas:
- El informador abstracto todavía se basa en el observador abstracto y no se puede desacoplar más El método de mejora es utilizar la delegación.
Escenario de uso : cuando el cambio de un objeto necesita cambiar otros objetos al mismo tiempo, no puede asumir quiénes son los otros objetos. En otras palabras, no desea que estos objetos estén estrechamente acoplados.
Antecedentes del código : Los dos empleados de la empresa siempre están monitoreando si el jefe está de vuelta, porque quieren aprovechar la ausencia del jefe para hacer sus propias cosas. Si alguien les informa que el jefe ha vuelto, dejarán de lado las cosas. en sus manos y seguir trabajando. Desafortunadamente, esta vez los dos empleados notificados por el propio jefe, él está aquí.
Notificador: Jefe.
Observador: Dos empleados actúan de manera diferente según el contenido del aviso.
Notificador abstracto : todas las referencias a objetos observadores (Adjuntar, Separar, Notificar) se almacenan en una colección. Cada tema puede tener cualquier número de observadores. El tema abstracto proporciona una interfaz para agregar y eliminar objetos observadores., Y no es necesario saber quién es el observador específico, y cualquier observador específico no necesita conocer la existencia de otros observadores.
interface Subject //通知者接口
{
void Attach(Observer observer);
void Detach(Observer observer);
void Notify();
string SubjectState //通知者状态
{
get;
set;
}
}
Observador abstracto : el observador puede ser cualquier objeto, use la abstracción para aumentar la escalabilidad del código (o use la interfaz)
abstract class Observer
{
protected string name;
protected Subject sub;
public Observer (string name,Subject sub)
{
this.name = name;
this.sub = sub;
}
public abstract void Update();
}
Categoría de jefe: temas específicos
class Boss:Subject //实现接口
{
//同事列表
private IList<Observer> observers = new List<Observer >();
private string action;
//增加要通知的对象
public void Attach(Observer observer)
{
observers.Add(observer);
}
//减少要通知的对象
public void Detach(Observer observer)
{
observers.Remove(observer);
}
//通知（包含了员工的Update方法，一旦被通知，员工就执行Update方法）
public void Notify ()
{
foreach (Observer o in observers)//遍历所有要通知的对象，然他们依次执行Update方法
o.Update();
}
//老板状态（重写接口）
public string SubjectState
{
get {
return action;}
set {
action = value;}
}
}
Categoría de empleado: observador específico
class StockObserver:Observer ///看股票的员工
{
public StockObserver(string name, Subject sub) : base(name, sub)//抽象观察者，观察者本来就可以是任何人
{
}
public override void Update() //重写更新方法
{
Console.WriteLine("{0}{1}关闭股票行情，继续工作！", sub.SubjectState , name);
}
}
class NBAobserver : Observer //看NBA的员工
{
public NBAobserver(string name, Subject sub) : base(name, sub)
{
}
public override void Update() //重写更新方法
{
Console.WriteLine("{0}{1}关闭NBA直播，继续工作！", sub.SubjectState, name);
}
}
Cliente:
static void Main(string[] args)
{
//老板
Boss bazong = new Boss();
//摸鱼的同事
StockObserver tongshi1 = new StockObserver("江小鱼",bazong);
NBAobserver tongshi2 = new NBAobserver ("李建刚", bazong);
//老板默默记下要通知的两位同事
bazong.Attach(tongshi1);
bazong.Attach(tongshi2);
//老板大意了，江小鱼没听见，没被通知到，所以减去这个人
bazong.Detach(tongshi1);
//老板状态改变
bazong.SubjectState = "我霸道总裁回来了！";
//发出通知，员工执行Update方法
bazong.Notify();
Console.Read();
}
}
En el ejemplo, no hay notificación sobre cambios de estado y datos, sino que simplemente notifica a cada observador, diciéndoles que el observador tiene una acción.
Hay dos versiones del modo de observador en la realización específica de la comunicación entre el rol de destino y el rol de observador.
- Una situación es que después de que cambia el rol de destino, solo le dice al rol de observador "He cambiado" Si el rol de observador desea conocer los detalles específicos del cambio, debe obtenerlo de la interfaz del rol de destino. Este modo se llama vívidamente: modo de extracción, es decir, la información cambiante es "extraída" activamente del rol de destino por el rol de observador.
- Hay otra forma, es decir, mi rol de destino "servicio de ventanilla única", al notificarle que hay un cambio, los detalles del cambio se pasan al rol de observador a través de un parámetro. Este es el "modo push", lo quieras o no, te lo daré primero.
El uso de estos dos modos depende de las necesidades del diseño del sistema. Si el rol de destino es más complejo y el rol de observador debe obtener algunos cambios específicos al actualizar, el "modo push" es más apropiado. Si el rol de destino es relativamente simple, el "modo de extracción" es apropiado.
Definición de delegado (delegado) : Un delegado es una clase que define el tipo de un método, por lo que el método se puede pasar como un parámetro de otro método. Este método de asignar dinámicamente un método a un parámetro puede evitarse en el programa Usar si -Else (Switch) declaraciones extensivamente, y al mismo tiempo hacen que el programa tenga una mejor escalabilidad.
El delegado es un tipo de método de referencia, una vez que el delegado asigna el método, el delegado tendrá el mismo comportamiento que el método.
//Update是事件，EventHandler是委托类型，tongshi1.CloseGameMarket是被委托的方法
//表示将tongshi1的CloseGameMarket方法通过实例化委托EventHandler登记到laoban的事件Update当中。
//+=表示add_CatShout,增加委托实例对象
laoban.Update += new EventHandler(tongshi1.CloseGameMarket );
Los delegados son la encapsulación de funciones, y se puede dar un nombre a las características del método ("EventHandler" en el siguiente ejemplo).
El evento es una forma especial de delegación. Cuando ocurre un evento (el "Jefe para inspeccionar" en el siguiente ejemplo), el tipo de delegación (el objeto de procesamiento de eventos, es decir, el "EventHandler" en el siguiente ejemplo) proceso de notificación (tongshi1.CloseGameMarket en el siguiente ejemplo), Tongshi2.CloseZbObserver).
Compañeros jugando juegos:
class GameObserver
{
private string name;
private Subject sub;
public GameObserver(string name,Subject sub)
{
this.name = name;
this.sub = sub;
}
//关闭游戏
public void CloseGameMarket()
{
Console.WriteLine("{0}{1}关闭王者荣耀，继续工作！",sub.SubjectState,name);
}
}
Compañeros viendo la transmisión en vivo
class ZbObserver
{
private string name;
private Subject sub;
public ZbObserver (string name,Subject sub)
{
this.name = name;
this.sub = sub;
}
//关闭直播
public void CloseZbObserver()
{
Console.WriteLine("{0}{1}关闭直播，继续工作！",sub.SubjectState,name);
}
}
Interfaz de estado del notificador:
interface Subject
{
void Notify();
string SubjectState //通知者状态
{
get;
set;
}
}
patrón:
delegate void EventHandler();
class Boss :Subject //老板是和前台都是通知者
{
//声明一事件Update,委托类型为EventHandler
public event EventHandler Update;
private string action;
public void Notify() //通知
{
Update();
}
public string SubjectState //通知者状态——重写接口方法
{
get {
return action; }
set {
action = value; }
}
}
Cliente:
static void Main(string[] args)
{
Boss laoban = new Boss();
//玩游戏的同事
GameObserver tongshi1 = new GameObserver("秦霜",laoban);
//看直播的同事
ZbObserver tongshi2 = new ZbObserver("楚楚",laoban);
//实例化一个委托，委托的实例是tongshi1的CloseGameMarket
laoban.Update += new EventHandler(tongshi1.CloseGameMarket );
laoban.Update += new EventHandler(tongshi2.CloseZbObserver );
//老板回来
laoban.SubjectState = "老板：我来视察工作了\n";
//发出通知
laoban.Notify();//Notify()方法一运行，里面的Update事件就运行，Notify()方法就委托EventHandler去通知方法tongshi1.CloseGameMarket运行。
}