- 浏览: 495435 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (1028)
- [发布至博客园首页] (826)
- [随笔分类]个人生活随笔 (14)
- [网站分类]首页候选区 (26)
- [网站分类]SharePoint (15)
- [网站分类]其他技术区 (6)
- [随笔分类]批处理技巧 (6)
- [随笔分类].net 2.0 (3)
- [随笔分类]SharePoint2007(MOSS2007) (0)
- [网站分类].NET新手区 (6)
- [网站分类]ASP.NET (6)
- [网站分类]架构设计 (18)
- [网站分类]程序人生 (2)
- [网站分类]SQL Server (2)
- WCF (3)
- 编程技巧 (2)
- 模式架构 (2)
- 分析设计 (4)
- 生活随笔 (0)
- 软件工程 (1)
- Android实例 (2)
最新评论
-
zilong0536:
楼主您好:
请问发表博文支持图片的功能怎么实现啊,一直没有思路 ...
新浪微博开放平台开发-android客户端(3) -
nicegege:
小弟 学习了
帮助中国移动设计10086的排队小模块 -
zl7824516:
用什么技术没说啊
通告(公告),消息(站内短信),提醒的设计:通告 -
virusswb:
源码下载: SinaWeibo2 源码下载之后,将后缀改为ra ...
新浪微博开放平台开发-android客户端(3) -
Jimmyxu0311:
找不到源码下载
新浪微博开放平台开发-android客户端(3)
今天要接触的是观察者模式Observer。
提到观察者,肯定会想到还应该有被观察者,也就是观察的内容,或者说是观察的主题。
首先让我们看看报纸和杂志的订阅是怎么回事:
- 报社的业务就是出版报纸。
- 向一家报社订阅报纸,只要有新报纸,就会给你送过来。只要你是他们的订阅者,就一直会收到。
- 当你不想继续看报纸的时候,可以取消订阅,他们就不会再送报纸过来。
- 只要报社存在,就会一直有人订阅或者是取消订阅。
上面就是一个典型的观察者模式,你、我、他,这些订阅报纸的人就是观察者Observer,报社就是被观察者,观察的主题Subject。
观察者模式的定义:定义了对象之间的一对多依赖,这样一来,当一个对象改变状态的时候,它的所有依赖者都会收到通知并自动更新。
观察者有很多的实现方式,最常见的是包含Subject与Observer接口的类设计。
上图是我从书中摘取出来的。
-
当两个对象之间松耦合,他们依然可以交互,但是不清楚彼此的细节。观察者模式提供了一种对象设计,实现主题和观察者之间的松耦合。
-
对于观察者的一切,主题只是知道观察者实现了某一个接口(也就是Observer接口)。主题不需要知道观察者具体是做什么的类。
-
任何时候我们都可以添加新的观察者,主题只是依赖于观察者列表,添加观察者也就是在列表中添加元素。同样,也可以删除观察者,也就是删除观察者列表的元素。
-
有新类型的观察者,主题不用修改代码,只要新的观察者实现Observer接口就可以了。只需要在主题中注册观察者,然后就可以收到新通知了。
-
二者是松耦合的,相互之间不影响,只要接口被遵守,就可以自由的改变他们。
设计原则:
为了交互对象之间的松耦合设计而努力。
代码
<!--<br/ /><br/ />Code highlighting produced by Actipro CodeHighlighter (freeware)<br/ />http://www.CodeHighlighter.com/<br/ /><br/ />-->using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BeautyCode.DesignPattern.Head.First.Observer
{
public interface IObserver
{
void Update();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BeautyCode.DesignPattern.Head.First.Observer
{
public interface ISubject
{
IList<IObserver> Observers { get; set; }
void Register(IObserver observer);
void UnRegister(IObserver observer);
void NotifyObserver();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BeautyCode.DesignPattern.Head.First.Observer
{
public class SubjectImpl:ISubject
{
public SubjectImpl()
{
_observers = new List<IObserver>(0);
}
private IList<IObserver> _observers;
public IList<IObserver> Observers
{
get { return _observers; }
set { this._observers=value ; }
}
public void Register(IObserver observer)
{
_observers.Add(observer);
}
public void UnRegister(IObserver observer)
{
_observers.Remove(observer);
}
public void NotifyObserver()
{
if (_observers != null)
{
foreach (IObserver ob in _observers)
{
ob.Update();
}
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BeautyCode.DesignPattern.Head.First.Observer
{
public class ObserverImpl:IObserver
{
private string _name;
public ObserverImpl(string name)
{
_name = name;
}
public void Update()
{
Console.WriteLine("{0}收到通知了",_name );
}
}
}
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BeautyCode.DesignPattern.Head.First.Observer
{
public interface IObserver
{
void Update();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BeautyCode.DesignPattern.Head.First.Observer
{
public interface ISubject
{
IList<IObserver> Observers { get; set; }
void Register(IObserver observer);
void UnRegister(IObserver observer);
void NotifyObserver();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BeautyCode.DesignPattern.Head.First.Observer
{
public class SubjectImpl:ISubject
{
public SubjectImpl()
{
_observers = new List<IObserver>(0);
}
private IList<IObserver> _observers;
public IList<IObserver> Observers
{
get { return _observers; }
set { this._observers=value ; }
}
public void Register(IObserver observer)
{
_observers.Add(observer);
}
public void UnRegister(IObserver observer)
{
_observers.Remove(observer);
}
public void NotifyObserver()
{
if (_observers != null)
{
foreach (IObserver ob in _observers)
{
ob.Update();
}
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BeautyCode.DesignPattern.Head.First.Observer
{
public class ObserverImpl:IObserver
{
private string _name;
public ObserverImpl(string name)
{
_name = name;
}
public void Update()
{
Console.WriteLine("{0}收到通知了",_name );
}
}
}
客户端调用代码
代码
<!--<br/ /><br/ />Code highlighting produced by Actipro CodeHighlighter (freeware)<br/ />http://www.CodeHighlighter.com/<br/ /><br/ />--> Console.WriteLine("====Head.First.Observer=================================================");
Head.First.Observer.ISubject subject = new Head.First.Observer.SubjectImpl();
Head.First.Observer.IObserver ob1 = new Head.First.Observer.ObserverImpl("ob1");
Head.First.Observer.IObserver ob2 = new Head.First.Observer.ObserverImpl("ob2");
Head.First.Observer.IObserver ob3 = new Head.First.Observer.ObserverImpl("ob3");
subject.Register(ob1);
subject.Register(ob2);
subject.Register(ob3);
subject.NotifyObserver();
Head.First.Observer.ISubject subject = new Head.First.Observer.SubjectImpl();
Head.First.Observer.IObserver ob1 = new Head.First.Observer.ObserverImpl("ob1");
Head.First.Observer.IObserver ob2 = new Head.First.Observer.ObserverImpl("ob2");
Head.First.Observer.IObserver ob3 = new Head.First.Observer.ObserverImpl("ob3");
subject.Register(ob1);
subject.Register(ob2);
subject.Register(ob3);
subject.NotifyObserver();
从上面的代码结构中可以看出来如果需要增加一个新的观察者,只需要新观察者实现IObserver接口,然后再主题中register就可以了。
但是上面的观察者模式也还是有一点强依赖的意味,就是主题类依赖于观察者列表,有新的观察者就需要主题类主动注册。又没有可能主题也不关心有没有什么新观察者,只是专注于属于自己的职责-通知主题的内容变化。
其实在.NET中有一种天然存在的设计模式,就是观察者。大家都知道.NET是事件驱动的形式,就是控件的事件引发方法的调用,让触发事件的一方得到信息。我们可以将这个原理引入观察者模式的实现上来。
耗子,猫、狗、主人的故事
<!--<br/ /><br/ />Code highlighting produced by Actipro CodeHighlighter (freeware)<br/ />http://www.CodeHighlighter.com/<br/ /><br/ />-->using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApp
{
public delegate void ObserverEventHandler(object sender, EventObjectArgs e);
/// <summary>
/// 被观察者
/// </summary>
public interface IEventObserable
{
event ObserverEventHandler ObserverEvent;
void OnObserverEvent(EventObjectArgs e);
void RaiseObserverMethod();
}
/// <summary>
/// 观察者
/// </summary>
public interface IEventObserver
{
}
public class EventObjectArgs : EventArgs
{
private string _message;
public string Message
{
get { return _message; }
}
public EventObjectArgs()
{
}
public EventObjectArgs(string message)
{
this._message = message;
}
}
class EventCat : IEventObserable
{
#region IEventObserable 成员
public event ObserverEventHandler ObserverEvent;
public void OnObserverEvent(EventObjectArgs e)
{
if (null != ObserverEvent)
{
ObserverEvent(this, e);
}
}
public void RaiseObserverMethod()
{
Console.WriteLine("猫叫了");
OnObserverEvent(new EventObjectArgs("猫叫了"));
}
#endregion
}
class EventMouse : IEventObserver
{
public EventMouse() { }
public EventMouse(IEventObserable observable)
{
observable.ObserverEvent += new ObserverEventHandler(observable_ObserverEvent);
}
public void observable_ObserverEvent(object sender, EventObjectArgs e)
{
Console.WriteLine(string.Format("{0},所有老鼠被吓跑了", e.Message));
}
}
class EventDog : IEventObserver
{
public EventDog(IEventObserable observable)
{
observable.ObserverEvent += new ObserverEventHandler(observable_ObserverEvent);
}
public void observable_ObserverEvent(object sender, EventObjectArgs e)
{
Console.WriteLine(string.Format("{0},所有老鼠被吓跑了,但是狗拿耗子多管闲事", e.Message));
}
}
class EventMaster : IEventObserver
{
public EventMaster(IEventObserable observable)
{
observable.ObserverEvent += new ObserverEventHandler(observable_ObserverEvent);
}
public void observable_ObserverEvent(object sender, EventObjectArgs e)
{
Console.WriteLine(string.Format("{0},所有老鼠被吓跑了,但是狗拿耗子多管闲事,主人生气了,要打死这些动物", e.Message));
}
}
}
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApp
{
public delegate void ObserverEventHandler(object sender, EventObjectArgs e);
/// <summary>
/// 被观察者
/// </summary>
public interface IEventObserable
{
event ObserverEventHandler ObserverEvent;
void OnObserverEvent(EventObjectArgs e);
void RaiseObserverMethod();
}
/// <summary>
/// 观察者
/// </summary>
public interface IEventObserver
{
}
public class EventObjectArgs : EventArgs
{
private string _message;
public string Message
{
get { return _message; }
}
public EventObjectArgs()
{
}
public EventObjectArgs(string message)
{
this._message = message;
}
}
class EventCat : IEventObserable
{
#region IEventObserable 成员
public event ObserverEventHandler ObserverEvent;
public void OnObserverEvent(EventObjectArgs e)
{
if (null != ObserverEvent)
{
ObserverEvent(this, e);
}
}
public void RaiseObserverMethod()
{
Console.WriteLine("猫叫了");
OnObserverEvent(new EventObjectArgs("猫叫了"));
}
#endregion
}
class EventMouse : IEventObserver
{
public EventMouse() { }
public EventMouse(IEventObserable observable)
{
observable.ObserverEvent += new ObserverEventHandler(observable_ObserverEvent);
}
public void observable_ObserverEvent(object sender, EventObjectArgs e)
{
Console.WriteLine(string.Format("{0},所有老鼠被吓跑了", e.Message));
}
}
class EventDog : IEventObserver
{
public EventDog(IEventObserable observable)
{
observable.ObserverEvent += new ObserverEventHandler(observable_ObserverEvent);
}
public void observable_ObserverEvent(object sender, EventObjectArgs e)
{
Console.WriteLine(string.Format("{0},所有老鼠被吓跑了,但是狗拿耗子多管闲事", e.Message));
}
}
class EventMaster : IEventObserver
{
public EventMaster(IEventObserable observable)
{
observable.ObserverEvent += new ObserverEventHandler(observable_ObserverEvent);
}
public void observable_ObserverEvent(object sender, EventObjectArgs e)
{
Console.WriteLine(string.Format("{0},所有老鼠被吓跑了,但是狗拿耗子多管闲事,主人生气了,要打死这些动物", e.Message));
}
}
}
OO原则:
封装变化
多用组合,少用继承
针对接口编程,不针对实现编程
为交互对象之间的松耦合设计而努力
OO模式
观察者模式-在对象之间定义一对多的依赖,这样一来,当一个对象改变状态,依赖它的对象都会收到通知,并自动更新。
发表评论
-
NET 应用架构指导 V2 学习笔记(十六) 服务层设计指导
2010-06-04 00:13 546如果你的应用是通 ... -
NET 应用架构指导 V2 学习笔记(十七) 组件设计指导
2010-06-05 00:48 668组件提供了一种将 ... -
NET 应用架构指导 V2 学习笔记(十八) 表现层组件设计指导
2010-06-05 21:09 527本章讲述的是你在设计用户界面组件和表现层逻辑组件的时候应该 ... -
NET 应用架构指导 V2 学习笔记(十九) 表现层组件设计指导
2010-06-06 06:15 5895 决定数据绑定的 ... -
NET 应用架构指导 V2 学习笔记(二十) 业务组件设计指导
2010-06-07 06:58 612前言 业务组件 ... -
微软企业库5.0学习笔记(四十二)异常处理模块
2010-06-14 00:04 835企业库的异常处理 ... -
关于程序员在30岁、35岁之后怎么办的新思考
2010-06-14 10:40 623首先给大家问个好 ... -
NET 应用架构指导 V2 学习笔记(二十四) 跨层关注问题
2010-06-17 20:00 592概况 大部分的 ... -
微软企业库5.0学习笔记(四十三)数据验证模块
2010-06-19 08:07 993概况 任何接受用户或者是其他系统输入的应用,一定要确保 ... -
关于项目进度慢的思考----如何提高整体开发效率
2010-06-21 23:42 801我们都是软件行业 ... -
微软企业库5.0学习笔记(四十四)实战数据验证模块
2010-06-23 19:22 8361 在业务对象上添加验证 添加对程序集【Microso ... -
微软企业库5.0学习笔记(四十五)实战数据验证模块----高级篇
2010-06-24 19:41 9681、添加自定义的提示信息 验证失败的提示信息可以自定义 ... -
面向对象类设计的五大原则(一)单一职责原则Single Responsibility Principle
2010-06-29 15:45 776引言 面向对象类设计,或者说是面向对象设计,有五大原则 ... -
《深入浅出设计模式-中文版》读书笔记 开篇乱弹(一)
2010-07-01 06:42 648oreilly的《Head.First ... -
《深入浅出设计模式-中文版》读书笔记-继承与组合(三)
2010-07-03 16:53 603经过上一次的改造 ... -
利用attribute实现简单的ORM
2010-07-09 15:27 681我不知道NH的ORM具 ... -
系统内部模块(子系统)之间的耦合以及模块(子系统)划分
2010-07-14 13:02 807题外话 最近已经在努力学习了,学习基本功,学习设计模式 ... -
《深入浅出设计模式-中文版》读书笔记-工厂模式(五)
2010-07-16 12:46 697今天给大家带来的是:工厂模式。 我们在代码中创建一个对 ... -
Head.First.Object-Oriented.Design.and.Analysis《深入浅出面向对象的分析与设计》读书笔记(一)
2010-07-18 21:47 670题外话 又是一本Head.First系列的书,这个系列 ... -
Head.First.Object-Oriented.Design.and.Analysis《深入浅出面向对象的分析与设计》读书笔记(二)
2010-07-20 07:18 681今天的话题是收集需求。 Gathering Requi ...
相关推荐
《深入浅出设计模式》是一本深受欢迎的设计模式学习书籍,旨在帮助读者理解并熟练运用设计模式。在本文中,我们将重点关注策略模式以及它与三个核心设计原则的关系。策略模式是一种行为设计模式,它使你能在运行时...
在《深入浅出设计模式》的学习笔记中,我们可以看到几种关键的设计模式及其应用,包括策略模式、观察者模式、装饰者模式、工厂模式和抽象工厂模式。 1. **策略模式**: - 策略模式的核心在于将算法族封装在独立的...
观察者模式是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这个模式在很多场景下都有广泛的应用,例如事件处理、...
深入浅出MFC读书笔记3 在MFC中,Document-View架构是一个非常重要的概念。本文将对Document-View架构中的关键组件进行深入探讨,并对其实现思路进行详细的解析。 首先,让我们来看一下Document的概念。在MFC中,...
HeadFirst的设计模式系列书籍以其直观易懂的方式深受程序员喜爱,本笔记将深入探讨观察者模式的概念及其应用。 观察者模式的核心思想是定义对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的...
《深入浅出DPDK》读书笔记 本书读书笔记涵盖了 DPDK 的基本概念、网络编程、虚拟化和 NFV 等方面的知识点。下面是对标题和描述中所说的知识点的详细说明: 1. 传统网卡驱动程序的工作方式:在 Linux 内核中,网卡...
### 深入浅出MFC—笔记关键知识点解析 #### 一、Windows消息机制与回调函数 在深入了解MFC之前,我们首先需要理解Windows操作系统的基本工作原理,尤其是消息驱动模型以及回调函数的概念。 **1.1 Windows消息机制...
Hadoop权威指南----读书笔记
学生读书笔记共享-学生读书笔记共享系统-学生读书笔记共享系统源码-学生读书笔记共享管理系统-学生读书笔记共享管理系统java代码-学生读书笔记共享系统设计与实现-基于springboot的学生读书笔记共享系统-基于Web的...
详细介绍23种设计模式,结合gof设计模式来撰述,通过设计模式定义、组成、适用场景、以及示例等方式来呈现;资源来自设计模式深入浅出整理的笔记
总之,《深入浅出Hibernate》读书笔记涵盖了实体对象生命周期的转换、实体对象的识别机制以及Hibernate的多级缓存策略,这些都是理解并有效使用Hibernate的关键点。通过深入学习这些概念,开发者能够更好地掌握...
另一方面,`深入浅出MFC_简体中文版_侯捷.pdf`则是侯捷的原著,书中详细介绍了MFC的各个组成部分,包括视图(View)、文档(Document)、框架窗口(Frame Window)、对话框(Dialog)、控件(Control)以及动态链接...
云的学习笔记-云的学习笔记系统-云的学习笔记系统源码-云的学习笔记管理系统-云的学习笔记管理系统java代码-云的学习笔记系统设计与实现-基于ssm的云的学习笔记系统-基于Web的云的学习笔记系统设计与实现-云的学习...
通过阅读《深入浅出Cortex-M3——LPC178x.177上下册》,读者不仅可以掌握Cortex-M3和LPC178x/177x的基础知识,还能深入了解嵌入式系统的开发流程和实践技巧,对提升个人或团队的项目开发能力大有裨益。书中的高清PDF...