苏飞论坛

 找回密码
 马上注册

QQ登录

只需一步,快速开始

扫一扫,访问微社区

分布式系统框架(V2.0) 轻松承载百亿数据,千万流量!讨论专区 - 源码下载 - 官方教程

HttpHelper万能框架(V2.3-含.netcore) HttpHelper官方出品,无敌框架讨论区 - 源码下载 - 在线测试和代码生成

HttpHelper爬虫类(V2.0) 最牛的爬虫类,没有爬不到只有想不到 源码 - 代码生成器 - 讨论区 - 教程- 例子

查看: 540|回复: 2

[学习心得] C#观察者模式介绍

[复制链接]
发表于 2019-1-13 18:13:57 | 显示全部楼层 |阅读模式
一 、  观察者 (Observer ) 模式

      观察者模式又叫做发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器
(Source/Listener)模式或从属者(Dependents)模式。

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

      一个软件系统常常要求在某一个对象的状态发生变化的时候,某些其它的对象做出相应的改变。做到这一点的设
计方案有很多,但是为了使系统能够易于复用,应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统
的复用,但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致,保证高度的协作
(Collaboration)。观察者模式是满足这一要求的各种设计方案中最重要的一种。

二 、  观察者模式的结构

观察者模式的类图如下:

1.png

可以看出,在这个观察者模式的实现里有下面这些角色:

 抽象主题(Subject)角色:主题角色把所有对观察考对象的引用保存在一个聚集里,每个主题都可以有任何数量的观察者。抽象主题提供一个接
口,可以增加和删除观察者对象,主题角色又叫做抽象被观察者(Observable)角色,一般用一个抽象类或者一个接口实现。

 抽象观察者(Observer)角色:为所有的具体观察者定义一个接口,在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者角色一
般用一个抽象类或者一个接口实现。在这个示意性的实现中,更新接口只包含一个方法(即 Update()方法),这个方法叫做更新方法。

 具体主题(ConcreteSubject)角色:将有关状态存入具体现察者对象;在具体主题的内部状态改变时,给所有登记过的观察者发出通知。具体主
题角色又叫做具体被观察者角色(Concrete Observable)。具体主题角色通常用一个具体子类实现。

 具体观察者(ConcreteObserver)角色:存储与主题的状态自恰的状态。具体现察者角色实现抽象观察者角色所要求的更新接口,以便使本身的状
态与主题的状态相协调。如果需要,具体现察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。

      从具体主题角色指向抽象观察者角色的合成关系,代表具体主题对象可以有任意多个对抽象观察者对象的引用。
之所以使用抽象观察者而不是具体观察者,意味着主题对象不需要知道引用了哪些 ConcreteObserver 类型,
而只知道抽象 Observer 类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用,并在需要
的时候调用每一个观察者共有的 Update()方法。这种做法叫做"针对抽象编程"。

三 、  观察者模式的示意性源代码

[C#] 纯文本查看 复制代码
using System;
using System.Collections;

namespace ConsoleApplication1
{
// "Subject"
    abstract class Subject
    {
        // Fields
        private ArrayList observers = new ArrayList();
        // Methods
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }
        public void Notify()
        {
            foreach (Observer o in observers)
                o.Update();
        }
    }
// "ConcreteSubject"
    class ConcreteSubject : Subject
    {
        // Fields
        // Properties
        public string SubjectState { get; set; }
    }
// "Observer"
    abstract class Observer
    {
        // Methods
        public abstract void Update();
    }
// "ConcreteObserver"
    class ConcreteObserver : Observer
    {
        // Fields
        private string name;
        private string _observerState;
        private ConcreteSubject _subject;
        // Constructors
        public ConcreteObserver(ConcreteSubject subject,
            string name)
        {
            _subject = subject;
            this.name = name;
        }
        // Methods
        public override void Update()
        {
            _observerState = _subject.SubjectState;
            Console.WriteLine("Observer {0}'s new state is {1}",
                name, _observerState);
        }
        // Properties
        public ConcreteSubject Subject
        {
            get { return _subject; }
            set { _subject = value; }
        }
    }
    /// <summary>
    /// Client test
    /// </summary>
    public class Client
    {
        public static void Main(string[] args)
        {
            // Configure Observer structure
            ConcreteSubject s = new ConcreteSubject();
            s.Attach(new ConcreteObserver(s, "1"));
            s.Attach(new ConcreteObserver(s, "2"));
            s.Attach(new ConcreteObserver(s, "3"));
            // Change subject and notify observers
            s.SubjectState = "ABC";
            s.Notify();
        }
    }
}


四 、 C# 中的 Delegate 与 与 Event

实际上在 C#中实现 Observer 模式没有这么辛苦,.NET 中提供了 Delegate 与 Event 机制,我们可以利用这
种机制简化 Observer 模式。关于 Delegate 与 Event 的使用方法请参考相关文档。改进后的 Observer 模式
实现如下:

[C#] 纯文本查看 复制代码
// Observer pattern -- Structural example
using System;
namespace ConsoleApplication1
{
//Delegate
    delegate void UpdateDelegate();
//Subject
    class Subject
    {
        public event UpdateDelegate UpdateHandler;
        // Methods
        public void Attach(UpdateDelegate ud)
        {
            UpdateHandler += ud;
        }
        public void Detach(UpdateDelegate ud)
        {
            UpdateHandler -= ud;
        }
        public void Notify()
        {
            if (UpdateHandler != null) UpdateHandler();
        }
    }
//ConcreteSubject
    class ConcreteSubject : Subject
    {
        // Fields
        // Properties
        public string SubjectState { get; set; }
    }
// "ConcreteObserver"
    class ConcreteObserver
    {
        // Fields
        private readonly string _name;
        private string _observerState;
        private ConcreteSubject _subject;
        // Constructors
        public ConcreteObserver(ConcreteSubject subject,
            string name)
        {
            _subject = subject;
            _name = name;
        }
        // Methods
        public void Update()
        {
            _observerState = _subject.SubjectState;
            Console.WriteLine("Observer {0}'s new state is {1}",
                _name, _observerState);
        }
        // Properties
        public ConcreteSubject Subject
        {
            get { return _subject; }
            set { _subject = value; }
        }
    }
// "ConcreteObserver"
    class AnotherObserver
    {
        // Methods
        public void Show()
        {
            Console.WriteLine("AnotherObserver got an Notification!");
        }
    }
    public class Client
    {
        public static void Main(string[] args)
        {
            ConcreteSubject s = new ConcreteSubject();
            ConcreteObserver o1 = new ConcreteObserver(s, "1");
            ConcreteObserver o2 = new ConcreteObserver(s, "2");
            AnotherObserver o3 = new AnotherObserver();
            s.Attach(new UpdateDelegate(o1.Update));
            s.Attach(new UpdateDelegate(o2.Update));
            s.Attach(new UpdateDelegate(o3.Show));
            s.SubjectState = "ABC";
            s.Notify();
            Console.WriteLine("--------------------------");
            s.Detach(new UpdateDelegate(o1.Update));
            s.SubjectState = "DEF";
            s.Notify();
        }
    }
}


其中,关键的代码如下:
[C#] 纯文本查看 复制代码
delegate void UpdateDelegate();


      定义一个Delegate,用来规范函数结构。不管是ConcreteObserver类的Update方法还是AnotherObserver
类的 Show 方法都符合该 Delegate。这不象用 Observer 接口来规范必须使用 Update 方法那么严格。只要符
合 Delegate 所指定的方法结构的方法都可以在后面被事件所处理。
[C#] 纯文本查看 复制代码
public event UpdateDelegate UpdateHandler;


定义一个事件,一旦触发,可以调用一组符合 UpdateDelegate 规范的方法。
[C#] 纯文本查看 复制代码
public void Attach( UpdateDelegate ud )
{
UpdateHandler += ud;
}



订阅事件。只要是一个满足 UpdateDelegate 的方法,就可以进行订阅操作(如下所示)。
[C#] 纯文本查看 复制代码
s.Attach(new UpdateDelegate(o1.Update));
s.Attach(new UpdateDelegate(o2.Update));
s.Attach(new UpdateDelegate(o3.Show));



在 Notify 方法中:
[C#] 纯文本查看 复制代码
public void Notify()
{
if(UpdateHandler != null) UpdateHandler();
}


只要 UpdateHandler != null(表示有订阅者),就可以触发事件(UpdateHandler()),所有的订阅者便会
接到通知

发表于 2019-1-13 19:24:26 | 显示全部楼层
发表于 2019-1-13 20:34:33 | 显示全部楼层
您需要登录后才可以回帖 登录 | 马上注册

本版积分规则

QQ|手机版|小黑屋|手机版|联系我们|关于我们|广告合作|苏飞论坛 ( 豫ICP备17001017号-1)

GMT+8, 2019-12-7 23:06

© 2017-2018

快速回复 返回顶部 返回列表