观察者模式-不太理解

简介: 可能最近连续看多了,没有消化吧。 只是机械的打出代码,以及调试错误信息而已。 下一个事件委托实现,要学慢点了。 最近兴趣又要转向WINDOWS AD 2008域更改名称,EXCHANGE架设和3DMAX配合DEADLINE作RENDER FARM渲染农场了。

可能最近连续看多了,没有消化吧。

只是机械的打出代码,以及调试错误信息而已。

下一个事件委托实现,要学慢点了。

最近兴趣又要转向WINDOWS AD 2008域更改名称,EXCHANGE架设和3DMAX配合DEADLINE作RENDER FARM渲染农场了。

/*
 * Created by SharpDevelop.
 * User: home
 * Date: 2013/4/27
 * Time: 15:52
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Observer
{
    class Program
    {
        public static void Main(string[] args)
        {
            Boss huhansan = new Boss();
            //Secretary tongzihe = new Secretary();
            
            StockObserver tongshi1 = new StockObserver("魏关姹", huhansan);
            NBAObserver tongshi2 = new NBAObserver("易管查", huhansan);
            
            huhansan.Attach(tongshi1);
            huhansan.Attach(tongshi2);
            
            huhansan.SubjectState= "我胡汉三又回来啦!!!哈哈哈!!!";
            huhansan.Notify();
            
            Console.ReadKey(true);
        }
    }
    /*class Secretary
    {
        private IList<StockObserver> observers = new List<StockObserver>();
        private string action;
        
        public void Attach(StockObserver observer)
        {
            observers.Add(observer);
        }
        
        public void Notify()
        {
            foreach (StockObserver o in observers)
                o.Update();
        }
        
        public string SecretaryAction
        {
            get { return action; }
            set { action = value; }
        }
    }
    class StockObserver
    {
        private string name;
        private Secretary sub;
        public StockObserver(string name, Secretary sub)
        {
            this.name = name;
            this.sub = sub;
        }
        public void Update()
        {
            Console.WriteLine("{0} {1} 关闭股票行情,继续工作! ",sub.SecretaryAction, name);
        }
    }
    abstract class Observer
    {
        protected string name;
        protected Secretary sub;
        
        public Observer(string name, Secretary sub)
        {
            this.name = name;
            this.sub = sub;
        }
        
        public abstract void Update();
    }
    
    class StockObserver : Observer
    {
        public StockObserver(string name, Secretary sub) : base(name, sub)
        {
            
        }
        public override void Update()
        {
            Console.WriteLine("{0} {1} 关闭股票行情,继续工作! ",sub.SecretaryAction, name);
        }
    }
    class NBAObserver : Observer
    {
        public NBAObserver(string name, Secretary sub) : base(name, sub)
        {
            
        }
        public override void Update()
        {
            Console.WriteLine("{0} {1} 关闭NBA,继续工作! ",sub.SecretaryAction, name);
        }
    }
    
    class Secretary
    {
        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);
        }
        
        public void Notify()
        {
            foreach (Observer o in observers)
                o.Update();
        }
        
        public string SecretaryAction
        {
            get { return action; }
            set { action = value; }
        }
    }*/
    
    interface Subject
    {
        void Attach(Observer observer);
        void Detach(Observer observer);
        void Notify();
        
        string SubjectState
        {
            get;
            set;
        }
    }
    
    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);
        }
        
        public void Notify()
        {
            foreach (Observer o in observers)
                o.Update();
        }
        
        public string SubjectState
        {
            get { return action; }
            set { action = value; }
        }
    }
    
    
    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();
    }
    
    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
    {
        public NBAObserver(string name, Subject sub) : base(name, sub)
        {
            
        }
        public override void Update()
        {
            Console.WriteLine("{0} {1} 关闭NBA,继续工作! ",sub.SubjectState, name);
        }
    }
}

目录
相关文章
|
7月前
|
设计模式 安全
如何用C++11实现观察者模式
观察者模式是一种设计模式,定义了对象之间的一对多关系。当一个对象状态发生改变时,它的依赖者都会收到通知并自动更新。在C++11中,可以通过以下方式实现观察者模式:
|
11天前
|
设计模式 Java
小谈设计模式(15)—观察者模式
小谈设计模式(15)—观察者模式
|
6月前
|
设计模式 算法 Java
解锁设计模式的神秘面纱:编写无懈可击的代码之简单工厂设计模式
解锁设计模式的神秘面纱:编写无懈可击的代码之简单工厂设计模式
28 0
|
4月前
|
设计模式 Java
根据真实业务场景去实现一下设计模式中的装饰者模式
根据真实业务场景去实现一下设计模式中的装饰者模式
18 0
|
6月前
|
设计模式 应用服务中间件 uml
解锁设计模式的神秘面纱:编写无懈可击的代码之外观设计模式
解锁设计模式的神秘面纱:编写无懈可击的代码之外观设计模式
26 1
|
9月前
|
设计模式 算法
设计模式——从简单的程序变化到设计理念
设计模式——从简单的程序变化到设计理念
72 0
|
10月前
|
设计模式 uml
CRUD很无聊?一起学设计模式吧!— 观察者模式(一)
CRUD很无聊?一起学设计模式吧!— 观察者模式(一)
44 0
|
10月前
|
设计模式 Java
CRUD很无聊?一起学设计模式吧!— 观察者模式(二)
CRUD很无聊?一起学设计模式吧!— 观察者模式(二)
42 0
|
12月前
|
设计模式 前端开发
前端通用编程基础的设计模式之观察者
观察者模式是前端开发中非常常见且实用的一种设计模式。该模式可以帮助我们更好地设计和实现一些复杂的应用程序,例如事件处理、数据绑定以及状态管理等。
93 0
|
设计模式 监控
23种设计模式-关系模式-观察者模式(十五)
23种设计模式-关系模式-观察者模式(十五)
23种设计模式-关系模式-观察者模式(十五)