设计模式学习观察者模式

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，他的所有依赖着都会收到通知并自动更新。

设计原则 为了交互对象之间的松耦合设计而努力

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

namespace ObserverPattern
{

//创建发送者的接口
    public interface IObserver
    {
        void update(float temp, float humidity, float pressure);
    }
//主题接口，供注册和解除监听
    public interface ISubject
    {
        void registerObserver(IObserver o);
        void removeObserver(IObserver o);
        void notifyObserver();
    }
        //显示接口
    public interface IDisplayElement
    {
        void display();
    }

//源，实现监听者的添加删除以及发送消息
    public class WeatherData : ISubject
    {
        public ArrayList observers;
        public float temperature;
        public float humidity;
        public float pressure;


        public WeatherData()
        {
            observers = new ArrayList();
        }


        public void registerObserver(IObserver o)
        {
            observers.Add(o);
        }

        public void removeObserver(IObserver o)
        {
            observers.Remove(o);
        }
//给每个监听者发送消息
        public void notifyObserver()
        {
            for (int i = 0; i < observers.Count; i++)
            {
                (observers[i] as IObserver).update(temperature, humidity, pressure);
            }
        }

//触发消息
        public void measurementsChanged()
        {
            notifyObserver();
        }
//设置消息值
        public void setMeasurements(float temperature, float humidity, float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;

            measurementsChanged();
        }

    }

//监听者之一
    public class CurrentConditionsDisplay : IObserver, IDisplayElement
    {



        public float temperature;
        public float humidity;
        public float pressure;
        private ISubject WeatherData;
        public CurrentConditionsDisplay(ISubject WeatherData)
        {
            this.WeatherData = WeatherData;
            WeatherData.registerObserver(this);//把自己注册进去监听
        }

//weather会调用这个方法
        public void update(float temp, float humidity, float pressure)
        {
            this.temperature = temp;
            this.humidity = humidity;
            this.pressure = pressure;
            display();
        }
//显示
        public void display()
        {
            Console.WriteLine("Current conditions:" + temperature + "F degrees and " + humidity + "humidity");
        }


    }
}

微软提供的观察者模式：

发布源要实现 IObservable<T> 接口(定义基于推送的通知的提供程序)

    // 摘要: 
    //     定义基于推送的通知的提供程序。
    //
    // 类型参数: 
    //   T:
    //     提供通知信息的对象。
    public interface IObservable<out T>
    {
        // 摘要: 
        //     通知提供程序：某观察程序将要接收通知。
        //
        // 参数: 
        //   observer:
        //     要接收通知的对象。
        //
        // 返回结果: 
        //     对允许观察者在提供程序发送完通知前停止接收这些通知的接口的引用。
        IDisposable Subscribe(IObserver<T> observer);
    }

订阅者要实现 IObserver<in T>

  // 摘要: 
    //     提供用于接收基于推送的通知的机制。
    //
    // 类型参数: 
    //   T:
    //     提供通知信息的对象。
    public interface IObserver<in T>
    {
        // 摘要: 
        //     通知观察者，提供程序已完成发送基于推送的通知。
        void OnCompleted();
        //
        // 摘要: 
        //     通知观察者，提供程序遇到错误情况。
        //
        // 参数: 
        //   error:
        //     一个提供有关错误的附加信息的对象。
        void OnError(Exception error);
        //
        // 摘要: 
        //     向观察者提供新数据。
        //
        // 参数: 
        //   value:
        //     当前的通知信息。
        void OnNext(T value);
    }

示例代码：

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

namespace ObserverPattern
{
    //坐标结构体
    public struct Location
    {
        double lat, lon;

        public Location(double latitude, double longitude)
        {
            this.lat = latitude;
            this.lon = longitude;
        }

        public double Latitude
        { get { return this.lat; } }

        public double Longitude
        { get { return this.lon; } }
    }


    
    /// <summary>
    /// 这是个订阅者
    /// </summary>
    public class LocationReporter : IObserver<Location>
    {
        private IDisposable unsubscriber;
        private string instName;

        public LocationReporter(string name)
        {
            this.instName = name;
        }

        public string Name
        { get { return this.instName; } }
        /// <summary>
        /// 订阅
        /// </summary>
        /// <param name="provider"></param>
        public virtual void Subscribe(IObservable<Location> provider)
        {
            if (provider != null)
                unsubscriber = provider.Subscribe(this);
        }
        //     通知观察者，提供程序已完成发送基于推送的通知。
        public virtual void OnCompleted()
        {
            Console.WriteLine("The Location Tracker has completed transmitting data to {0}.", this.Name);
            this.Unsubscribe();
        }
        //     通知观察者，提供程序遇到错误情况。
        public virtual void OnError(Exception e)
        {
            Console.WriteLine("{0}: The location cannot be determined.", this.Name);
        }
        //     向观察者提供新数据。
        public virtual void OnNext(Location value)
        {
            Console.WriteLine("{2}: The current location is {0}, {1}", value.Latitude, value.Longitude, this.Name);
        }
        /// <summary>
        /// 解除订阅
        /// </summary>
        public virtual void Unsubscribe()
        {
            unsubscriber.Dispose();
        }
    }

    /// <summary>
    /// 源，实现推送消息的接口 IObservable<Location>
    /// </summary>
    public class LocationTracker : IObservable<Location>
    {
        /// <summary>
        /// 实例化一个通知列表
        /// </summary>
        public LocationTracker()
        {
            observers = new List<IObserver<Location>>();
        }

        private List<IObserver<Location>> observers;
        /// <summary>
        /// 新增订阅者
        /// </summary>
        /// <param name="observer">提供了实现接收者接口的实例</param>
        /// <returns></returns>
        public IDisposable Subscribe(IObserver<Location> observer)
        {
            if (!observers.Contains(observer))
                observers.Add(observer);
            return new Unsubscriber(observers, observer);
        }

        private class Unsubscriber : IDisposable
        {
            private List<IObserver<Location>> _observers;
            private IObserver<Location> _observer;

            public Unsubscriber(List<IObserver<Location>> observers, IObserver<Location> observer)
            {
                this._observers = observers;
                this._observer = observer;
            }

            public void Dispose()
            {
                if (_observer != null && _observers.Contains(_observer))
                    _observers.Remove(_observer);
            }
        }
        /// <summary>
        /// 传送新的消息
        /// </summary>
        /// <param name="loc"></param>
        public void TrackLocation(Nullable<Location> loc)
        {
            foreach (var observer in observers)
            {
                if (!loc.HasValue)
                    observer.OnError(new LocationUnknownException());
                else
                    observer.OnNext(loc.Value);
            }
        }
        /// <summary>
        /// 通知观察者，消息已经发送完了
        /// </summary>
        public void EndTransmission()
        {
            foreach (var observer in observers.ToArray())
                if (observers.Contains(observer))
                    observer.OnCompleted();

            observers.Clear();//清空订阅者
        }
    }
    /// <summary>
    /// 定义发生错误时处理方法
    /// </summary>
    public class LocationUnknownException : Exception
    {
        internal LocationUnknownException()
        { }
    }
}

调用：

            //实例化观察者1
            ObserverPattern.LocationReporter lreporter1 = new ObserverPattern.LocationReporter("Observer1");
            //实例化观察者2
            ObserverPattern.LocationReporter lreporter2 = new ObserverPattern.LocationReporter("Observer2");
            //实例化观察者3
            ObserverPattern.LocationReporter lreporter3 = new ObserverPattern.LocationReporter("Observer3");
            //发布源
            ObserverPattern.LocationTracker ltracker = new ObserverPattern.LocationTracker();

            lreporter1.Subscribe(ltracker);//观察者1订阅了源
            lreporter2.Subscribe(ltracker);//观察者2订阅了源
            lreporter3.Subscribe(ltracker);//观察者3订阅了源
            ltracker.TrackLocation(new ObserverPattern.Location(1, 2));//源发布消息，订阅者们都会收到消息
            ltracker.TrackLocation(new ObserverPattern.Location(3, 32));
            ltracker.TrackLocation(null);
            ltracker.EndTransmission();//完成订阅，清空所有的订阅者

            ltracker.TrackLocation(new ObserverPattern.Location(1, 2));//这个时候将不会有任何人接收到消息了
            Console.ReadLine();