【C#设计模式-观察者模式】

一时失言乱红尘 2022-08-22 00:24 109阅读 0赞

一.基本简介：观察者设计模式定义了对象间的一种一对多的依赖关系，以便一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动刷新。在现实生活中的可见观察者模式，例如，微信中的订阅号，订阅博客和QQ微博中关注好友，这些都属于观察者模式的应用。

二.实现：比如热水器在烧水的过程中，当水温即将烧开时，会发出报警的声音，显示器上会出现温度监控

public interface IObserver
        {
            /// <summary>
            /// 更新自身状态
            /// </summary>
            void Update(int temp);
        }

/// <summary>
        /// IObserverable接口
        /// </summary>
        public interface IObservable
        {
            /// <summary>
            /// 注册IObserver
            /// </summary>
            /// <param name="obj"></param>
            void Register(IObserver obj);
            /// <summary>
            /// 取消IObserver的注册
            /// </summary>
            /// <param name="obj"></param>
            void Unregister(IObserver obj);
        }

/// <summary>
        /// 抽象基类
        /// </summary>
        public abstract class SubjectBase:IObservable
        {
            private List<IObserver> container = new List<IObserver>();
    
            public void Register(IObserver obj)
            {
                container.Add(obj);
            }
    
            public void Unregister(IObserver obj)
            {
                container.Remove(obj);
            }
    
            /// <summary>
            /// 通知所有注册了的Observe
            /// </summary>
            protected virtual void Notify(int temp)
            {
                foreach (IObserver observer in container)
                {
                    //调用Observer的Update()方法
                    observer.Update(temp); 
                }
            }
        }

public class Heater:SubjectBase
        {
            private int temp;//水温
    
            protected virtual void OnBioiled()
            {
                base.Notify(temp);
            }
    
            public void GetMonitoring()
            {
                for (int i = 0; i <= 99; i++)
                {
                    temp = i + 1;
                    if (temp > 95)
                    {
                        OnBioiled();
                    }
                }
            }
        }

public class Alarm:IObserver
        {
            public void Update(int temp)
            {
                if (temp == 100)
                {
                    Console.WriteLine("水烧开了"+temp);
                }
                else
                {
                    Console.WriteLine("开始报警，水快烧开了>> " + temp);
                }
            }
        }

public class Screen:IObserver
        {
            public void Update(int temp)
            {
                if (temp == 100)
                {
                    Console.WriteLine("水烧开了" + temp);
                }
                else
                {
                    Console.WriteLine("水快烧开了>> " + temp);
                }
            }
        }

/// <summary>
        /// C#设计模式-观察者模式
        /// </summary>
        class Program
        {
            static void Main(string[] args)
            {
                Heater heater = new Heater();
                heater.Register(new Screen());
                heater.Register(new Alarm());
                heater.GetMonitoring();
            }
        }

![20160509125841317][]  
在上面的例子中，热水器是Subject,报警器和显示器是Observer,报警器和显示器关心热水器中的水温。  
优点：  
观察者模式实现了表示层和数据逻辑层的分离，并定义了稳定的更新消息传递机制，并抽象了更新接口，使得可以有各种各样不同的表示层，即观察者。  
观察者模式在被观察者和观察者之间建立了一个抽象的耦合，被观察者并不知道任何一个具体的观察者，只是保存着抽象观察者的列表，每个具体观察者都符合一个抽象观察者的接口。  
观察者模式支持广播通信。被观察者会向所有的注册过的观察者发出通知。  
缺点：  
如果一个被观察者有很多直接和间接的观察者时，将所有的观察者都通知到会花费很多时间。  
虽然观察者模式可以随时使观察者知道所观察的对象发送了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎样发生变化的。  
如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃，在使用观察者模式应特别注意这点。  
  
观察者模式定义了一种一对多的依赖关系，让多个观察者对象可以同时监听某一个主题对象，这个主题对象在发生状态变化时，会通知所有观察者对象，使它们能够自动更新自己，解决的是“当一个对象的改变需要同时改变多个其他对象”的问题。

[20160509125841317]: /images/20220724/256c5063c2fd4b13a42d5faddc3d5d9a.png