设计模式-观察者模式-观察者模式与事件模型的区别讨论-.Net内置的观察者模式

最新推荐文章于 2022-09-11 21:39:09 发布
最新推荐文章于 2022-09-11 21:39:09 发布
阅读量630 收藏 2
点赞数
文章标签： 观察者模式 .net microsoft
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47472749/article/details/121865607
版权

UP主在这里简要的介绍下观察者模式：（详细的介绍请大家自行阅读相关书籍）
在这里先给出观察者模式的一个简要的定义：
发布者+订阅者=观察者模式
是不是感觉这个事件模型很像，别着急，UP主在最后会进行观察者模式与事件模型的讨论，供大家批评。
观察者的准确定义是：
观察者模式 定义了对象之间的一对多依赖，这样一来，当一个对象发生改变时，他的所有依赖者都会收到通知并会自动更新。
另外，观察者模式可不只是 简单的 主题发布，观察者收到通知并执行 的过程，
观察者也可以从主题处 拉 来信息，不接收主题的某些信息，甚至可以选择不再注册主题。
这些特性请大家看文中给出的两个程序。
具体大家请看书上的简图：
在这里插入图片描述
观察者模式提供了一种对象设计，让主题与观察者之间松耦合，让对象间的依赖降到了最低，建立有弹性的OO系统，能够应对变化。
书中给出了一个松耦合的观察者的例，UP主把它写出来了：
在这里插入图片描述

//为了松耦合，一切对象皆在接口的层面上进行操作
//主测试程序
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPattern
{
    internal class Program
    {
        static void Main(string[] args)
        {
            WeatherData weatherData = new WeatherData();
            FirstConditionDisplay firstConditionDisplay = new FirstConditionDisplay(weatherData);
            SecondConditionDisplay secondConditionDisplay = new SecondConditionDisplay(weatherData);
            ThirdConditionDisplay thirdConditionDisplay = new ThirdConditionDisplay(weatherData);
            weatherData.SetMessurements(37, 25, 1.2f);
            Console.WriteLine("*****************************");
            weatherData.SetMessurements(5, 19, 1.0f);
            Console.WriteLine("*****************************");
            weatherData.RemoveObserver(secondConditionDisplay);
            weatherData.SetMessurements(41, 19, 1.0f);
            Console.WriteLine("*****************************");
            weatherData.RegisterObserver(secondConditionDisplay);
            weatherData.SetMessurements(0, 30, 1.0f);
            Console.WriteLine("*****************************");
            weatherData.NotifyObserver();
            Console.WriteLine("*****************************");
            Console.ReadKey();
        }
    }
}


//天气信息接口
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPattern
{
    public interface ISubject
    {
        void RegisterObserver(IObserver ob);
        void RemoveObserver(IObserver ob);
        void NotifyObserver();
    }
}

//天气数据类，也是主题类
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPattern
{
    public class WeatherData:ISubject
    {
        private ArrayList observers;
        private float temperature;
        private float humidity;
        private float pressure;
        public WeatherData()
        {
            observers = new ArrayList();
        }
        public void NotifyObserver()
        {
            for(int i =0; i <observers.Count; i++)
            {
                IObserver observer = (IObserver)observers[i];
                observer.Update(temperature, humidity, pressure);
            }
        }

        public void RegisterObserver(IObserver ob)
        {
            observers.Add(ob);
        }

        public void RemoveObserver(IObserver ob)
        {
            int i = observers.IndexOf(ob);
            if (i >= 0)
            {
                observers.RemoveAt(i);
            }
        }
        public void MessurementsChanged()
        {
            NotifyObserver();
        }
        public void SetMessurements(float temperature, float humidity, float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            MessurementsChanged();
        }
    }
}


//布告板接口, 也是观察者类的接口，
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPattern
{
    public interface IObserver
    {
        void Update(float temperature, float humidity, float pressure);
    }
}
//展示布告板信息的接口，就一个函数，display
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPattern
{
    public interface IDisplayElement
    {
        void Display();
    }
}
//第一个观察者
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPattern
{
    public class FirstConditionDisplay : IObserver, IDisplayElement
    {
        private float temperature;
        private float humidity;
        private float pressure;
        private ISubject weatherData;
        public FirstConditionDisplay(ISubject weatherData)
        {
            this.weatherData = weatherData;
            weatherData.RegisterObserver(this);
        }
        public void Display()
        {
            Console.WriteLine("1 号布告板：现在天气状况是：温度" + temperature + "°C ， 湿度: " + humidity + "%,  压力："+ pressure+ " * 100000 Pa");
        }

        public void Update(float temperature, float humidity, float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            Display();
        }
    }
}
//第二个观察者
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPattern
{
    public class SecondConditionDisplay : IObserver, IDisplayElement
    {
        private float temperature;
        private float humidity;
        private float pressure;
        private ISubject weatherData;
        public SecondConditionDisplay(ISubject weatherData)
        {
            this.weatherData = weatherData;
            weatherData.RegisterObserver(this);
        }
        public void Display()
        {
            Console.WriteLine("2 号布告板：现在天气状况是：温度" + temperature + "°C ， 湿度: " + humidity + "%,  压力：" + pressure + " * 100000 Pa");
        }

        public void Update(float temperature, float humidity, float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            Display();
        }
    }
}
//第三个观察者
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPattern
{
    public class ThirdConditionDisplay : IObserver, IDisplayElement
    {
        private float temperature;
        private float humidity;
        private float pressure;
        private ISubject weatherData;
        public ThirdConditionDisplay(ISubject weatherData)
        {
            this.weatherData = weatherData;
            weatherData.RegisterObserver(this);
        }
        public void Display()
        {
            Console.WriteLine("3 号布告板：现在天气状况是：温度" + temperature + "°C ， 湿度: " + humidity + "%,  压力：" + pressure + " * 100000 Pa");
        }

        public void Update(float temperature, float humidity, float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            Display();
        }
    }
}
//后面可以新建观察者，并可以在主测试函数里向发布者（主题）订阅。

另外，.NET C# 野提供了内置的观察者模式，有两个接口：
IObservable
IObserver
下面UP主也会一并给出C# 中内置的的观察者模式的应用：
在这里插入图片描述

//主测试函数
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPatternUseObservable
{
    internal class Program
    {
        static void Main(string[] args)
        {
            WeatherDataPublisher publisher = new WeatherDataPublisher();
            CurrentConditionDisplay currentDisplay = new CurrentConditionDisplay();
            StatisticsConditionDisplay statisticsDisplay = new StatisticsConditionDisplay();
            //订阅当前天气展示板
            IDisposable currentDisplayUnsubscriber = publisher.Subscribe(currentDisplay);
            //订阅气温统计展示板
            IDisposable statisticsDisplayUnsubscriber =publisher.Subscribe(statisticsDisplay);

            for (int i = 0;i<3 ; i++)
            {
                WeatherData weatherData = new WeatherData();
                Console.WriteLine("请输入温度,湿度,压力");
                string input = Console.ReadLine();
                var array = input.Split(',');
                weatherData.temperature = array[0];
                weatherData.humility = array[1];
                weatherData.pressure = array[2];
                Console.WriteLine("");
                //将输入的新的天气数据传给天气数据发布器
                publisher.ReciveNewData(weatherData);
                Console.WriteLine("=============================");
            }
        }
    }
}


//天气数据类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPatternUseObservable
{
    public class WeatherData
    {
        /// <summary>
        /// 气温
        /// </summary>
        public string temperature { get; set; }
        /// <summary>
        /// 湿度
        /// </summary>
        public string humility { get; set; }
        /// <summary>
        /// 气压
        /// </summary>
        public string pressure { get; set; }
    }
}


//天气数据发布类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPatternUseObservable
{
    internal class WeatherDataPublisher : IObservable<WeatherData>
    {
        List<IObserver<WeatherData>> observers = new List<IObserver<WeatherData>>();
        /// <summary>
        /// 订阅主题，将观察者添加到列表中
        /// </summary>
        /// <param name="observer"></param>
        /// <returns></returns>
        public IDisposable Subscribe(IObserver<WeatherData> observer)
        {
            observers.Add(observer);
            return new Unsubscribe(this.observers, observer);
        }
       

        /// <summary>
        /// 通知已订阅的观察者
        /// </summary>
        /// <param name="weatherData"></param>
        private void Notify(WeatherData weatherData)
        {
            foreach (var observer in observers)
            {
                observer.OnNext(weatherData);
            }
        }
        /// <summary>
        /// 接收最新的天气数据
        /// </summary>
        /// <param name="weatherData"></param>
        public void ReciveNewData(WeatherData weatherData)
        {
            Notify(weatherData);
        }
    }
}
//观察者向主题取消订阅类：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPatternUseObservable
{
    /// <summary>
    /// 取消订阅类
    /// </summary>
    public class Unsubscribe:IDisposable
    {
        List<IObserver<WeatherData>> observers;
        IObserver<WeatherData> observer;
        public Unsubscribe(List<IObserver<WeatherData>> observers
        , IObserver<WeatherData> observer)
        {
            this.observer = observer;
            this.observers = observers;
        }

        public void Dispose()
        {
            if (this.observers != null)
            {
                this.observers.Remove(observer);
            }
        }
    }
}


//观察者类：布告板类抽象类：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPatternUseObservable
{
    public abstract class WeatherDisplayBase : IObserver<WeatherData>
    {
        public virtual void OnCompleted()
        {
        }
        public virtual void OnError(Exception error)
        {
        }
        public abstract void OnNext(WeatherData value);
    }
}

//第一个观察者类：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPatternUseObservable
{
    public  class StatisticsConditionDisplay : WeatherDisplayBase
    {
        List<float> temperatures = new List<float>();
        public override void OnNext(WeatherData value)
        {
            float temperature;
            if (float.TryParse(value.temperature, out temperature))
            {
                temperatures.Add(temperature);
            }
            Console.WriteLine("------------------");
            Console.WriteLine("温度统计板");
            Console.WriteLine(string.Format("平均温度：{0}\n最高温度：{1}\n最低温度：{2}",
                temperatures.Average(), temperatures.Max(), temperatures.Min()));
            Console.WriteLine("------------------");
        }
    }
}
//第二个观察者类：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverPatternUseObservable
{
    public class CurrentConditionDisplay : WeatherDisplayBase
    {
        public override void OnNext(WeatherData value)
        {
            Console.WriteLine("------------------");
            Console.WriteLine("当前天气状况板");
            Console.WriteLine(string.Format("温度：{0}\n湿度：{1}\n气压：{2}",
                value.temperature, value.humility, value.pressure));
            Console.WriteLine("------------------");
        }
    }
}

那好，如果你都把上面的项目仔细的调试运行，你就会细细的发现文章开头所讲的概念了。
那么，问题来了，像不像事件模型？
是的，很像，我将一个简单的邮局发报纸的事件模型项目给写出来，如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 事件测试Demo
{
	public class Post
	{
		public delegate void EventHandler(object sender);
		public event EventHandler Evt;
		public void Run()
		{
			Console.WriteLine("邮局：新报纸出来喽");
			Evt(this);
		}
	}
	public class PersonA
	{
		public void PersonAReaction(object sender)   //A的事件处理程序
		{
			Console.WriteLine("PersonA：新报纸来啦，赶紧用来垫东西！");
		}
	}
	public class PersonB
	{
		public void PersonBReaction(object sender) //B的事件处理程序
		{
			Console.WriteLine("PersonB：新报纸来啦，赶紧阅读阅读看看有啥新闻！");
		}
	}
	public class PersonC
	{
		public void PersonCReaction(object sender)//C的事件处理程序
		{
			Console.WriteLine("PersonC：新报纸来啦，下一年的报纸费用还得付，怎么办，快没钱了！");
		}
	}
	class Program
	{
		static void Main(string[] args)
		{
			Post p = new Post();  //邮局
			PersonA a = new PersonA();  //订阅者A
			PersonB b = new PersonB();  //订阅者B
			PersonC c = new PersonC();  //订阅者C
			p.Evt += new Post.EventHandler(a.PersonAReaction); //订阅报纸
			p.Evt += new Post.EventHandler(b.PersonBReaction);  //订阅报纸
			p.Evt += new Post.EventHandler(c.PersonCReaction);  //订阅报纸
			//触发事件，发报纸喽
			p.Run();
			Console.ReadKey();
		}
	}
}

对观察者与事件之间做一下小小的讨论：

1.事件就是观察者模式的一种应用
2.观察者模式----> 事件
主题----> 事件源
主题状态----> 事件（事件源发送给监听者的信息）
观察者----> 监听者
3.实际运用中
目前实际运用中，我们的工具基本都提供好了接口调用，一般使用的话，我们只需要知道做三件事
1.定义参数----> 状态、传递个监听者的值
2.监听者的逻辑处理
3.找到发布事件的地方，发布事件即可

以下博客可以参考：
https://blog.csdn.net/qq_23980427/article/details/53443349
https://www.jianshu.com/p/6020dffeceed
https://www.cnblogs.com/aoguren/p/4680692.html

单手搓木亥弓单
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
事件和观察者模式
weixin_48798983的博客
09-23 514
事件 事件是对象用于（向系统中的所有相关组件）广播已发生事情的一种方式。 任何其他组件都可以订阅事件，并在事件引发时得到通知。 类 或对象可以通过事件向其他类或对象通知发生的相关事情。 发送（或引发）事件的类称为“发布者”，接收（或处理）事件的类称为“订阅者”。 简单来总结就是发布与订阅。 在声明一个委托类型前面添加event关键字就是事件。 public delegate void MyDelegate();//这是定义委托 public MyDelegate mydelegate;//声明一个委托类
编程模式·观察者模式、事件通知、消息队列三者区别
cxu123321的博客
10-23 1749
编程模式·观察者模式、事件通知、消息队列三者区别 2017.01.11 19:07:09字数 1050阅读 2016 观察者模式、事件通知、消息队列三者有类似，都有回调函数注册，通知调用的设计，容易混淆。 简述和区别 观察者模式：被观察对象状态改变，所有观察它的对象得到通知。也称订阅模式，英文Observer。 被观察者不依赖观察者，通过依赖注入达到控制反转。 事件通知：事件发生后，通...
观察者模式和事件
Seven的博客
12-03 543
1.介绍什么是观察者模式？ http://www.cnblogs.com/wangjq/archive/2012/07/12/2587966.html 事件？ http://www.cnblogs.com/atyou/archive/2013/01/07/2850321.html 2.个人理解1.事件就是观察者模式的一种应用 2.观察者模式中---->事件 主题---->事件源 主题
观察者模式和事件的不同之处
weixin_33774308的博客
02-26 87
假如有A窗体，有一个计时器 B窗体，也有一个计时器。 要求B窗体的计时器和A窗体同步。   A窗体是主界面，B窗体是子界面   方案1：要使得B窗体和A窗体保持同步的计时器，那么在启动B窗体的时候，可以将A窗体的计时器的间隔作为B窗体的构造函数的参数传递 或者将A窗体的间隔保存到文件中，在B窗体加载之后，从配置中读取 然后，在A窗体改变计时器的间隔时，通过事件的方式通知B窗体。 ...
观察者模式和事件监听模式的区别
热门推荐
旧时光
12-14 1万+
说到事件监听模式,很容易将它和观察者模式联系在一起。 实质上这两者完成同类型的工作。依个人理解，事件监听模式更像是观察者模式的进阶。   用一张图来方便描述它们的区别: 观察者模式中，‘主题’会在特定逻辑下通知所有‘观察者’。 如果这个通知不包含任何信息，那么这种实现就是通常的观察者模式。 class Subject { protected: voi
事件模式与观察者模式
newdayslu的博客
02-18 1327
学习C#的事件模式时Delegate和event这二个概念比较难理解，因为这二个都被设计成关键字，想进一步查看其定义和实现就没有下文了，不过再难也得硬着头皮弄明白，我以前好长时间都是似懂非懂的状态，后来在学习了观察者设计模式和IL后利用这二者的知识来理解就比较容易。下来我就用观察者设计模式和IL来分析一下事件模式中Delegate和event这二
java常用设计模式-观察者模式
最新发布
08-28
观察者模式（Observer Pattern）是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。该模式适用于需要在对象间建立动态的、松散耦合的关系的...
JAVA-设计模式-行为型模式-观察者模式
08-10
JAVA-设计模式-行为型模式-观察者模式
设计模式-观察者模式-作业-observer.zip
08-27
观察者模式（Observer Pattern）是软件设计模式中的行为模式之一，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动或发布-...
c++设计模式-行为型模式-观察者模式
06-21
c++设计模式-行为型模式-观察者模式；qt工程；c++简单源码； 观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式...
C++设计模式--观察者模式 demo
04-14
观察者模式（Observer Pattern）是软件设计模式中的一种行为模式，它在C++中的应用广泛且实用。这种模式的核心思想是“主体”（Subject）与“观察者”（Observer）之间的松耦合关系，允许一个对象（即主体）的状态...
事件机制和观察者模式
隐竹的专栏
03-14 3803
观察者模式中有观察者（Observer）和主体（Subject）两个实体。 Observer   +update() Subject  +addObserver()  +notify() 主体是被观察对象，它将观察者注册到自己的观察者列表中，并在自身状态发生变化时，通知观察者（本质上是调用观察者的update方法）。 基于这样的模型，java实现了事件机制。针对实际情况的复杂
设计模式——观察者模式
菜园子丶For丨丶Tomorrow的博客
10-21 246
观察者模式 概念其实很简单，两个主体，一个观察者，一个被观察者，当被观察者发生变化时，观察者会有相应的动作。举几个例子，和我们日常生活息息相关的红绿灯，灯就相当于被观察者，行人就相当于观察者，当灯发生变化时，行人会有相应的动作：红灯停，绿灯行，黄灯亮了等一等。再比如我们现在玩的公众号，当我们订阅了某个公众号之后，公众号每发表一篇文章，就会向订阅了它的用户发送这篇文章，我们就可以浏览这篇文章了；当我们取消订阅了，它就不会再向我们推送这篇文章了；只要这个公众号一直在运行，就会一直有人订阅它或者取消订阅。这两个
Java事件监听模型与观察者模式
weixin_44959377的博客
01-18 526
前言 对于这两种模式，我们首先应该理解他们各自的含义，最后再来进行一个对比。 事件监听模型 对于事件监听模型，主要分为三部分： 事件源：就是事件发生的地方，比如一个按钮被点击了，那么事件源就是按钮 事件：发生了什么事，比如按钮被点击了，那么点击就是一个事件 监听者：监听发生了什么事，然后我要去做什么。比如按钮被点击了，点击完之后呢？我可以监听他，然后按钮被点击后弹出一些东西。 所以总结一下事件监听模型就有点类似于我们平常玩手机，点击屏幕后得到的反馈。 接下来我们可以通过代码来看看： 我们新建了三个类，分
观察者模式和事件监听机制区别
weixin_33895604的博客
09-29 937
说明 一直很困惑观察者模式和事件监听机制有什么区别,在模型和实现上,两者都出奇的相似,知道看到这个解释 That means: in an Event Driven System you get new semantics by adding new Event types. In an Observer Pattern you usually add semantics by adding a ...
【设计模式】[观察者模式的]程序实例C++ 以及观察者模式与事件监听的区别
小鱼菜鸟的博客
10-25 77
转自：https://www.cnblogs.com/mfrbuaa/p/4364678.html 一、什么是观察者模式 Observer模式也叫观察者模式，它的作用是当一个对象的状态发生变化时，可以自己主动通知其它关联对象，自己主动刷新对象状态。 举个样例，用户界面能够作为一个观察者，业务数据是被观察者，用户界面观察业务数据的变化，发现数...
观察者模式与事件处理
weixin_43301424的博客
09-11 496
观察者模式与事件处理
C#基础16：事件与观察者模式
加载中...
07-23 458
前文：https://blog.csdn.net/Jaihk662/article/details/96895681（委托） 一、事件与委托 其实事件就是委托的一种升级版，和委托的不同如下： 在原有的委托变量的基础上多一个 event 关键字，这个委托变量就称为事件； 在其它类中，事件只能使用 +=、-=来注册方法，而不能使用=为事件关联方法，相对于委托更加安全 一个例子如下（...
观察者模式与事件监听器模式--java设计模式扫盲
打不死的小欣的专栏
08-01 920
最近在开发监控系统，涉及事件监听，所以又把之前的观察者设计模式和事件监听器模式拿了出来重新学习一下，总结内容如下： 观察者模式 1.名词解释 观察者对象：观察者对象是监听被观察者的一个对象，当被观察者状态发生变化的时候，会通知观察者对象，使观察者对象可以自己更新自己，多个观察者对象可以监听同一个被观察者 被观察者对象：也叫主题对象，主要是在自身状态发生变化的时候，会通知所有监听它的观察者
哈尔滨工大深造：2022春设计模式实验-观察者与模板模式详解
实验六实验指导书（2022春）1主要聚焦于面向对象的软件构造导论中两个重要的设计模式：观察者模式和模板模式。本实验共分为4个学时，旨在帮助学生深入理解和应用这些设计模式。 1. 实验目的： - **观察者模式**：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值