设计模式-观察者模式

观察者模式

一.什么是观察者模式？

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

二.观察者模式有哪些角色？

　　1. 抽象主题（Subject）：它把所有观察者对象的引用保存到一个聚集里(集合)，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。

　　　　主题的功能：RegisterObserver（注册观察者），RemoveObserver（移除观察者），NotifyObservers（通知观察者）

        2. 具体主题（ConcreteSubject）：将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。

        3.抽象观察者（Observer）：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。

　　　　观察者的功能：Update（更新）

        4.具体观察者（ConcreteObserver）：实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态协调。

三.观察者模式的优缺点？

　　优点：

　　　　1.当被观察者状态发生改变时，会通知所有的观察者，使他们自动更新自己（广播通信）；

　　　　2.解耦，让依赖的双方都依赖抽象，而不是依赖具体实现；

　　缺点：

　　　　1.当出现循环，容易导致系统崩溃；

四.实现方式：

　　1.接口: 

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

namespace ObServer
{
    class Program
    {
        static void Main(string[] args)
        {
            var weather = new WeatherData();
            var curent = new CurrentConditionDisplay();
            weather.RegisterObserver(curent);
            var curent2 = new CurrentConditionDisplay2();
            weather.RegisterObserver(curent2);
            weather.SetData(new WeatherMessage()
            {
                Temperature = 1,
                Humidity = 2,
                Pressure = 3
            });

            weather.SetData(new WeatherMessage()
            {
                Temperature = 2,
                Humidity = 3,
                Pressure = 4
            });
            Console.ReadKey();
        }
    }

    public class WeatherData : ISubject
    {
        public WeatherData()
        {
            _observerList = new List<IObserver>();
        }
        private readonly List<IObserver> _observerList;
        private WeatherMessage _message;

        public void SetData(WeatherMessage message)
        {
            _message = message;
            NotifyObservers();
        }

        public void NotifyObservers()
        {
            for (int i = 0; i < _observerList.Count; i++)
            {
                var observer = _observerList[i];
                observer.Update(_message);
            }
        }

        public void RegisterObserver(IObserver observer)
        {
            _observerList.Add(observer);
        }

        public void RemoveObserver(IObserver observer)
        {
            if (_observerList.Contains(observer))
            {
                _observerList.Remove(observer);
            }
        }
    }

    public class CurrentConditionDisplay : IObserver
    {
        private WeatherMessage _message;
        
        public void Update(WeatherMessage message)
        {
            _message = message;
            Console.WriteLine($"温度：{_message.Temperature}，湿度：{_message.Humidity}，气压：{_message.Pressure}");
        }
    }

    public class CurrentConditionDisplay2 : IObserver
    {
        private WeatherMessage _message;

        public void Update(WeatherMessage message)
        {
            _message = message;
            Console.WriteLine($"温度：{_message.Temperature}，湿度：{_message.Humidity}，气压：{_message.Pressure}");
        }
    }

    /// <summary>
    /// 主题接口
    /// </summary>
    public interface ISubject
    {
        void RegisterObserver(IObserver observer);
        void RemoveObserver(IObserver observer);
        void NotifyObservers();
    }

    /// <summary>
    /// 观察者接口
    /// </summary>
    public interface IObserver
    {
        void Update(WeatherMessage message);
    }

    public class WeatherMessage
    {
        /// <summary>
        /// 温度
        /// </summary>
        public float Temperature { get; set; }

        /// <summary>
        /// 湿度
        /// </summary>
        public float Humidity { get; set; }

        /// <summary>
        /// 气压
        /// </summary>
        public float Pressure { get; set; }
    }

}

　　2.委托 

using System;
using System.Collections.Generic;
using System.Data.Odbc;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ObServer
{
    class Program
    {
        static void Main(string[] args)
        {
            var sub = new Subject();
            var ob = new Observer();
            sub.NotifyObservers += ob.Update;//观察者，即使没有观察者程序是不影响的（解耦）
            var ob2 = new Observer();
            sub.NotifyObservers += ob2.Update;
            sub.SetData(new WeatherMessage()
            {
                Temperature = 1,
                Humidity = 2,
                Pressure = 3
            });

            sub.SetData(new WeatherMessage()
            {
                Temperature = 1,
                Humidity = 2,
                Pressure = 3
            });
            sub.Complated();
            Console.ReadKey();
        }
    }

    public class Subject
    {
        public delegate void UpdateHandler(WeatherMessage message);
        public event UpdateHandler NotifyObservers;
        public WeatherMessage _message;

        public void SetData(WeatherMessage message)
        {
            _message = message;
            Console.WriteLine("设置数据完成");
            if (NotifyObservers != null)
            {
                NotifyObservers(_message);
            }
        }

        public void Complated()
        {
            NotifyObservers = null;
            Console.WriteLine("完成");
        }
    }

    public class Observer
    {
        public WeatherMessage _message;
        public void Update(WeatherMessage message)
        {
            _message = message;
            Console.WriteLine($"温度：{_message.Temperature}，湿度：{_message.Humidity}，气压：{_message.Pressure}");
        }
    }

    public class Observer2
    {
        public WeatherMessage _message;
        public void Update(WeatherMessage message)
        {
            _message = message;
            Console.WriteLine($"温度：{_message.Temperature}，湿度：{_message.Humidity}，气压：{_message.Pressure}");
        }
    }

    public class WeatherMessage
    {
        /// <summary>
        /// 温度
        /// </summary>
        public float Temperature { get; set; }

        /// <summary>
        /// 湿度
        /// </summary>
        public float Humidity { get; set; }

        /// <summary>
        /// 气压
        /// </summary>
        public float Pressure { get; set; }
    }

}

　　3.使用.net的类库：

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

namespace ObServer
{
    class Program
    {
        static void Main(string[] args)
        {
            var weather = new Observable();
            var ob = new Observer();
            weather.Subscribe(ob);
            var ob2 = new Observer();
            weather.Subscribe(ob2);
            weather.SetData(new WeatherMessage()
            {
                Temperature = 1,
                Humidity = 2,
                Pressure = 3
            });
            weather.SetData(new WeatherMessage()
            {
                Temperature = 2,
                Humidity = 3,
                Pressure = 4
            });
            weather.Completed();
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 主题
    /// </summary>
    public class Observable : IObservable<WeatherMessage>, IDisposable
    {
        public Observable()
        {
            _observerList = new List<IObserver<WeatherMessage>>();
        }

        private readonly List<IObserver<WeatherMessage>> _observerList;
        private IObserver<WeatherMessage> _observer;
        private WeatherMessage _message;
        public IDisposable Subscribe(IObserver<WeatherMessage> observer)
        {
            _observer = observer;
            _observerList.Add(observer);
            return this;
        }

        public void Dispose()
        {
            if (_observerList != null)
            {
                _observerList.Remove(_observer);
            }
        }

        public void SetData(WeatherMessage message)
        {
            _message = message;
            foreach (var item in _observerList)
            {
                if (_message == null)
                {
                    item.OnError(new Exception("出差"));
                }
                else
                {
                    item.OnNext(_message);
                    item.OnCompleted();
                }
            }
        }

        public void Completed()
        {
            _observerList.Clear();
        }
    }

    /// <summary>
    /// 观察者
    /// </summary>
    public class Observer : IObserver<WeatherMessage>
    {
        public void OnCompleted()
        {
            Console.WriteLine("完成");
        }

        public void OnError(Exception error)
        {
            Console.WriteLine(error);
        }

        public void OnNext(WeatherMessage value)
        {
            Console.WriteLine($"温度：{value.Temperature}，湿度：{value.Humidity}，气压：{value.Pressure}");
        }
    }

    /// <summary>
    /// 观察者2
    /// </summary>
    public class Observer2 : IObserver<WeatherMessage>
    {
        public void OnCompleted()
        {
            Console.WriteLine("完成");
        }

        public void OnError(Exception error)
        {
            Console.WriteLine(error);
        }

        public void OnNext(WeatherMessage value)
        {
            Console.WriteLine($"温度：{value.Temperature}，湿度：{value.Humidity}，气压：{value.Pressure}");
        }
    }

    public class WeatherMessage
    {
        /// <summary>
        /// 温度
        /// </summary>
        public float Temperature { get; set; }

        /// <summary>
        /// 湿度
        /// </summary>
        public float Humidity { get; set; }

        /// <summary>
        /// 气压
        /// </summary>
        public float Pressure { get; set; }
    }

}