行为型模式-观察者模式
using System;
using System.Text;
using System.Collections.Generic;
namespace 观察者模式
{
/*
* 观察者模式意图：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
* 观察者模式实现要点：1、需要在状态对象通知者建立容器，管理被通知对象
* 2、实现对容器进行管理
* 3、实现核心的更新方法
*
* 观察者模式优点：1、使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。
* 2、目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。观察者自己决定是否需要订阅通知。目标对象对此一无所知。
* 3、在C#中的Event。委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象，委托是比抽象Observer接口更为松耦合的设计。
*
* 观察者模式适用性：1、一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
* 2、当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
* 3、当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
*/
///<summary>
/// 主题或者抽象通知者,管理所需要的通知（观察的）对象
///</summary>
publicabstractclass Subject
{
private IList<Observer> observers=new List<Observer>();
///<summary>
/// 添加观察对象
///</summary>
///<param name="observer"></param>
publicvoid Attach(Observer observer)
{
observers.Add(observer);
}
///<summary>
/// 移除观察对象
///</summary>
///<param name="observer"></param>
publicvoid Dettach(Observer observer)
{
observers.Remove(observer);
}
///<summary>
/// 观察者模式核心方法，负责更改具体需要通知的对象
///</summary>
publicvoid Notify()
{
foreach (Observer o in observers)
{
o.Update();
}
}
}
///<summary>
/// 需要通知的对象抽象类，为需要通知的对象抽象公共的更新方法
///</summary>
publicabstractclass Observer
{
publicabstractvoid Update();
}
///<summary>
/// 具体通知者，通知其状态发生变化
///</summary>
publicclass ConcreteSubject : Subject
{
privatestring _subjectState;
publicstring SubjectState
{
get { return _subjectState; }
set { _subjectState = value; }
}
}
///<summary>
/// 具体的被通知的对象
///</summary>
publicclass ConcreteObserver : Observer
{
privatestring name;
///<summary>
/// 具体的对象状态
///</summary>
privatestring observerState;
///<summary>
/// 依赖的具体对象
///</summary>
private ConcreteSubject subject;
public ConcreteSubject Subject
{
get { return subject; }
set { subject = value; }
}
///<summary>
/// 根据其依赖的对象来构造
///</summary>
///<param name="subject">所要依赖的通知者具体对象</param>
///<param name="name"></param>
public ConcreteObserver(ConcreteSubject subject,string name)
{
this.Subject = subject;
this.name = name;
}
///<summary>
/// 具体更新方法
///</summary>
publicoverridevoid Update()
{
observerState = subject.SubjectState;
}
}
///<summary>
/// 客户调用
///</summary>
publicclass ClientApp
{
publicstaticvoid Main(string[] args)
{
ConcreteSubject subject =new ConcreteSubject();
subject.Attach(new ConcreteObserver(subject,"observer1"));
subject.Attach(new ConcreteObserver(subject,"observer2"));
subject.SubjectState="subject change it's state!";
subject.Notify();
}
}
}
using System.Text;
using System.Collections.Generic;
namespace 观察者模式
{
/*
* 观察者模式意图：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
* 观察者模式实现要点：1、需要在状态对象通知者建立容器，管理被通知对象
* 2、实现对容器进行管理
* 3、实现核心的更新方法
*
* 观察者模式优点：1、使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。
* 2、目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。观察者自己决定是否需要订阅通知。目标对象对此一无所知。
* 3、在C#中的Event。委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象，委托是比抽象Observer接口更为松耦合的设计。
*
* 观察者模式适用性：1、一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
* 2、当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
* 3、当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
*/
///<summary>
/// 主题或者抽象通知者,管理所需要的通知（观察的）对象
///</summary>
publicabstractclass Subject
{
private IList<Observer> observers=new List<Observer>();
///<summary>
/// 添加观察对象
///</summary>
///<param name="observer"></param>
publicvoid Attach(Observer observer)
{
observers.Add(observer);
}
///<summary>
/// 移除观察对象
///</summary>
///<param name="observer"></param>
publicvoid Dettach(Observer observer)
{
observers.Remove(observer);
}
///<summary>
/// 观察者模式核心方法，负责更改具体需要通知的对象
///</summary>
publicvoid Notify()
{
foreach (Observer o in observers)
{
o.Update();
}
}
}
///<summary>
/// 需要通知的对象抽象类，为需要通知的对象抽象公共的更新方法
///</summary>
publicabstractclass Observer
{
publicabstractvoid Update();
}
///<summary>
/// 具体通知者，通知其状态发生变化
///</summary>
publicclass ConcreteSubject : Subject
{
privatestring _subjectState;
publicstring SubjectState
{
get { return _subjectState; }
set { _subjectState = value; }
}
}
///<summary>
/// 具体的被通知的对象
///</summary>
publicclass ConcreteObserver : Observer
{
privatestring name;
///<summary>
/// 具体的对象状态
///</summary>
privatestring observerState;
///<summary>
/// 依赖的具体对象
///</summary>
private ConcreteSubject subject;
public ConcreteSubject Subject
{
get { return subject; }
set { subject = value; }
}
///<summary>
/// 根据其依赖的对象来构造
///</summary>
///<param name="subject">所要依赖的通知者具体对象</param>
///<param name="name"></param>
public ConcreteObserver(ConcreteSubject subject,string name)
{
this.Subject = subject;
this.name = name;
}
///<summary>
/// 具体更新方法
///</summary>
publicoverridevoid Update()
{
observerState = subject.SubjectState;
}
}
///<summary>
/// 客户调用
///</summary>
publicclass ClientApp
{
publicstaticvoid Main(string[] args)
{
ConcreteSubject subject =new ConcreteSubject();
subject.Attach(new ConcreteObserver(subject,"observer1"));
subject.Attach(new ConcreteObserver(subject,"observer2"));
subject.SubjectState="subject change it's state!";
subject.Notify();
}
}
}
using System;
using System.Text;
using System.Collections.Generic;
namespace 观察者模式
{
/*
* 观察者模式意图：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
* 观察者模式实现要点：1、需要在状态对象通知者建立容器，管理被通知对象
* 2、实现对容器进行管理
* 3、实现核心的更新方法
*
* 观察者模式优点：1、使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。
* 2、目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。观察者自己决定是否需要订阅通知。目标对象对此一无所知。
* 3、在C#中的Event。委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象，委托是比抽象Observer接口更为松耦合的设计。
*
* 观察者模式适用性：1、一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
* 2、当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
* 3、当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
*/
/// <summary>
/// 主题或者抽象通知者,管理所需要的通知（观察的）对象
/// </summary>
public abstract class Subject
{
private IList<Observer> observers=new List<Observer>();
/// <summary>
/// 添加观察对象
/// </summary>
/// <param name="observer"></param>
public void Attach(Observer observer)
{
observers.Add(observer);
}
/// <summary>
/// 移除观察对象
/// </summary>
/// <param name="observer"></param>
public void Dettach(Observer observer)
{
observers.Remove(observer);
}
/// <summary>
/// 观察者模式核心方法，负责更改具体需要通知的对象
/// </summary>
public void Notify()
{
foreach (Observer o in observers)
{
o.Update();
}
}
}
/// <summary>
/// 需要通知的对象抽象类，为需要通知的对象抽象公共的更新方法
/// </summary>
public abstract class Observer
{
public abstract void Update();
}
/// <summary>
/// 具体通知者，通知其状态发生变化
/// </summary>
public class ConcreteSubject : Subject
{
private string _subjectState;
public string SubjectState
{
get { return _subjectState; }
set { _subjectState = value; }
}
}
/// <summary>
/// 具体的被通知的对象
/// </summary>
public class ConcreteObserver : Observer
{
private string name;
/// <summary>
/// 具体的对象状态
/// </summary>
private string observerState;
/// <summary>
/// 依赖的具体对象
/// </summary>
private ConcreteSubject subject;
public ConcreteSubject Subject
{
get { return subject; }
set { subject = value; }
}
/// <summary>
/// 根据其依赖的对象来构造
/// </summary>
/// <param name="subject">所要依赖的通知者具体对象</param>
/// <param name="name"></param>
public ConcreteObserver(ConcreteSubject subject,string name)
{
this.Subject = subject;
this.name = name;
}
/// <summary>
/// 具体更新方法
/// </summary>
public override void Update()
{
observerState = subject.SubjectState;
}
}
/// <summary>
/// 客户调用
/// </summary>
public class ClientApp
{
public static void Main(string[] args)
{
ConcreteSubject subject = new ConcreteSubject();
subject.Attach(new ConcreteObserver(subject,"observer1"));
subject.Attach(new ConcreteObserver(subject,"observer2"));
subject.SubjectState="subject change it's state!";
subject.Notify();
}
}
}
using System.Text;
using System.Collections.Generic;
namespace 观察者模式
{
/*
* 观察者模式意图：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
* 观察者模式实现要点：1、需要在状态对象通知者建立容器，管理被通知对象
* 2、实现对容器进行管理
* 3、实现核心的更新方法
*
* 观察者模式优点：1、使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。
* 2、目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。观察者自己决定是否需要订阅通知。目标对象对此一无所知。
* 3、在C#中的Event。委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象，委托是比抽象Observer接口更为松耦合的设计。
*
* 观察者模式适用性：1、一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
* 2、当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
* 3、当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
*/
/// <summary>
/// 主题或者抽象通知者,管理所需要的通知（观察的）对象
/// </summary>
public abstract class Subject
{
private IList<Observer> observers=new List<Observer>();
/// <summary>
/// 添加观察对象
/// </summary>
/// <param name="observer"></param>
public void Attach(Observer observer)
{
observers.Add(observer);
}
/// <summary>
/// 移除观察对象
/// </summary>
/// <param name="observer"></param>
public void Dettach(Observer observer)
{
observers.Remove(observer);
}
/// <summary>
/// 观察者模式核心方法，负责更改具体需要通知的对象
/// </summary>
public void Notify()
{
foreach (Observer o in observers)
{
o.Update();
}
}
}
/// <summary>
/// 需要通知的对象抽象类，为需要通知的对象抽象公共的更新方法
/// </summary>
public abstract class Observer
{
public abstract void Update();
}
/// <summary>
/// 具体通知者，通知其状态发生变化
/// </summary>
public class ConcreteSubject : Subject
{
private string _subjectState;
public string SubjectState
{
get { return _subjectState; }
set { _subjectState = value; }
}
}
/// <summary>
/// 具体的被通知的对象
/// </summary>
public class ConcreteObserver : Observer
{
private string name;
/// <summary>
/// 具体的对象状态
/// </summary>
private string observerState;
/// <summary>
/// 依赖的具体对象
/// </summary>
private ConcreteSubject subject;
public ConcreteSubject Subject
{
get { return subject; }
set { subject = value; }
}
/// <summary>
/// 根据其依赖的对象来构造
/// </summary>
/// <param name="subject">所要依赖的通知者具体对象</param>
/// <param name="name"></param>
public ConcreteObserver(ConcreteSubject subject,string name)
{
this.Subject = subject;
this.name = name;
}
/// <summary>
/// 具体更新方法
/// </summary>
public override void Update()
{
observerState = subject.SubjectState;
}
}
/// <summary>
/// 客户调用
/// </summary>
public class ClientApp
{
public static void Main(string[] args)
{
ConcreteSubject subject = new ConcreteSubject();
subject.Attach(new ConcreteObserver(subject,"observer1"));
subject.Attach(new ConcreteObserver(subject,"observer2"));
subject.SubjectState="subject change it's state!";
subject.Notify();
}
}
}
using System;
using System.Text;
using System.Collections.Generic;
namespace 观察者模式
{
/*
* 观察者模式意图：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
* 观察者模式实现要点：1、需要在状态对象通知者建立容器，管理被通知对象
* 2、实现对容器进行管理
* 3、实现核心的更新方法
*
* 观察者模式优点：1、使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。
* 2、目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。观察者自己决定是否需要订阅通知。目标对象对此一无所知。
* 3、在C#中的Event。委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象，委托是比抽象Observer接口更为松耦合的设计。
*
* 观察者模式适用性：1、一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
* 2、当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
* 3、当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
*/
///<summary>
/// 主题或者抽象通知者,管理所需要的通知（观察的）对象
///</summary>
publicabstractclass Subject
{
private IList<Observer> observers=new List<Observer>();
///<summary>
/// 添加观察对象
///</summary>
///<param name="observer"></param>
publicvoid Attach(Observer observer)
{
observers.Add(observer);
}
///<summary>
/// 移除观察对象
///</summary>
///<param name="observer"></param>
publicvoid Dettach(Observer observer)
{
observers.Remove(observer);
}
///<summary>
/// 观察者模式核心方法，负责更改具体需要通知的对象
///</summary>
publicvoid Notify()
{
foreach (Observer o in observers)
{
o.Update();
}
}
}
///<summary>
/// 需要通知的对象抽象类，为需要通知的对象抽象公共的更新方法
///</summary>
publicabstractclass Observer
{
publicabstractvoid Update();
}
///<summary>
/// 具体通知者，通知其状态发生变化
///</summary>
publicclass ConcreteSubject : Subject
{
privatestring _subjectState;
publicstring SubjectState
{
get { return _subjectState; }
set { _subjectState = value; }
}
}
///<summary>
/// 具体的被通知的对象
///</summary>
publicclass ConcreteObserver : Observer
{
privatestring name;
///<summary>
/// 具体的对象状态
///</summary>
privatestring observerState;
///<summary>
/// 依赖的具体对象
///</summary>
private ConcreteSubject subject;
public ConcreteSubject Subject
{
get { return subject; }
set { subject = value; }
}
///<summary>
/// 根据其依赖的对象来构造
///</summary>
///<param name="subject">所要依赖的通知者具体对象</param>
///<param name="name"></param>
public ConcreteObserver(ConcreteSubject subject,string name)
{
this.Subject = subject;
this.name = name;
}
///<summary>
/// 具体更新方法
///</summary>
publicoverridevoid Update()
{
observerState = subject.SubjectState;
}
}
///<summary>
/// 客户调用
///</summary>
publicclass ClientApp
{
publicstaticvoid Main(string[] args)
{
ConcreteSubject subject =new ConcreteSubject();
subject.Attach(new ConcreteObserver(subject,"observer1"));
subject.Attach(new ConcreteObserver(subject,"observer2"));
subject.SubjectState="subject change it's state!";
subject.Notify();
}
}
}
using System.Text;
using System.Collections.Generic;
namespace 观察者模式
{
/*
* 观察者模式意图：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
* 观察者模式实现要点：1、需要在状态对象通知者建立容器，管理被通知对象
* 2、实现对容器进行管理
* 3、实现核心的更新方法
*
* 观察者模式优点：1、使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。
* 2、目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。观察者自己决定是否需要订阅通知。目标对象对此一无所知。
* 3、在C#中的Event。委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象，委托是比抽象Observer接口更为松耦合的设计。
*
* 观察者模式适用性：1、一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
* 2、当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
* 3、当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
*/
///<summary>
/// 主题或者抽象通知者,管理所需要的通知（观察的）对象
///</summary>
publicabstractclass Subject
{
private IList<Observer> observers=new List<Observer>();
///<summary>
/// 添加观察对象
///</summary>
///<param name="observer"></param>
publicvoid Attach(Observer observer)
{
observers.Add(observer);
}
///<summary>
/// 移除观察对象
///</summary>
///<param name="observer"></param>
publicvoid Dettach(Observer observer)
{
observers.Remove(observer);
}
///<summary>
/// 观察者模式核心方法，负责更改具体需要通知的对象
///</summary>
publicvoid Notify()
{
foreach (Observer o in observers)
{
o.Update();
}
}
}
///<summary>
/// 需要通知的对象抽象类，为需要通知的对象抽象公共的更新方法
///</summary>
publicabstractclass Observer
{
publicabstractvoid Update();
}
///<summary>
/// 具体通知者，通知其状态发生变化
///</summary>
publicclass ConcreteSubject : Subject
{
privatestring _subjectState;
publicstring SubjectState
{
get { return _subjectState; }
set { _subjectState = value; }
}
}
///<summary>
/// 具体的被通知的对象
///</summary>
publicclass ConcreteObserver : Observer
{
privatestring name;
///<summary>
/// 具体的对象状态
///</summary>
privatestring observerState;
///<summary>
/// 依赖的具体对象
///</summary>
private ConcreteSubject subject;
public ConcreteSubject Subject
{
get { return subject; }
set { subject = value; }
}
///<summary>
/// 根据其依赖的对象来构造
///</summary>
///<param name="subject">所要依赖的通知者具体对象</param>
///<param name="name"></param>
public ConcreteObserver(ConcreteSubject subject,string name)
{
this.Subject = subject;
this.name = name;
}
///<summary>
/// 具体更新方法
///</summary>
publicoverridevoid Update()
{
observerState = subject.SubjectState;
}
}
///<summary>
/// 客户调用
///</summary>
publicclass ClientApp
{
publicstaticvoid Main(string[] args)
{
ConcreteSubject subject =new ConcreteSubject();
subject.Attach(new ConcreteObserver(subject,"observer1"));
subject.Attach(new ConcreteObserver(subject,"observer2"));
subject.SubjectState="subject change it's state!";
subject.Notify();
}
}
}
