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

using System;
using System.Collections.Generic;

namespace TestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            RedDotManager manager = new RedDotManager();
            manager.Attach(new RedDot(ERedDotType.Friends));
            manager.Attach(new RedDot(ERedDotType.Activity));
            manager.ChangeDotNumber(ERedDotType.Activity, 1);
            manager.ChangeDotNumber(ERedDotType.Activity, -1);
            Console.ReadKey();
        }

        abstract class Observer
        {
            public bool NeedNotify { protected set; get; }
            public abstract void Update();
        }

        abstract class ObserveSubject
        {
            List<Observer> m_Observers = new List<Observer>();

            public virtual void Attach(Observer observer)
            {
                m_Observers.Add(observer);
            }

            public virtual void Detach(Observer observer)
            {
                m_Observers.Remove(observer);
            }

            public virtual void Notify()
            {
                for (int i = 0, length = m_Observers.Count; i < length; i++)
                {
                    var observer = m_Observers[i];
                    if (observer.NeedNotify)
                    {
                        observer.Update();
                    }
                }
            }
        }

        enum ERedDotType
        {
            Friends,
            Activity,
        }

        class RedDotManager : ObserveSubject
        {
            Dictionary<ERedDotType, RedDot> m_RedDotNumbers = new Dictionary<ERedDotType, RedDot>();

            public override void Attach(Observer observer)
            {
                base.Attach(observer);
                var redot = observer as RedDot;
                if (redot == null || m_RedDotNumbers.ContainsKey(redot.RedDotType))
                {
                    return;
                }
                m_RedDotNumbers.Add(redot.RedDotType, redot);
            }

            public override void Detach(Observer observer)
            {
                base.Detach(observer);
                var redot = observer as RedDot;
                if (redot == null || m_RedDotNumbers.ContainsKey(redot.RedDotType))
                {
                    return;
                }
                m_RedDotNumbers.Remove(redot.RedDotType);
            }

            public void ChangeDotNumber(ERedDotType type, int delta)
            {
                if (delta == 0)
                {
                    return;
                }

                RedDot value;
                if (!m_RedDotNumbers.TryGetValue(type, out value))
                {
                    return;
                }
                value.ChangeDotNumber(delta);
                Notify();
            }
        }

        class RedDot : Observer
        {
            public ERedDotType RedDotType { protected set; get; }
            private int m_Number;
            private bool m_ShowRedDot;

            public RedDot(ERedDotType type)
            {
                RedDotType = type;
            }

            public void ChangeDotNumber(int delta)
            {
                m_ShowRedDot = false;
                m_Number += delta;
                if (m_Number < 0)
                {
                    m_Number = 0;
                }
                if (m_Number > 0)
                {
                    m_ShowRedDot = true;
                }
                NeedNotify = true;
            }

            public override void Update()
            {
                NeedNotify = false;
                Console.WriteLine(string.Format("Redot {0} with number: {1}. m_ShowRedDot={2}", RedDotType, m_Number, m_ShowRedDot));
            }
        }
    }
}