[设计模式]-观察者模式应用

1.观察者模式的概念

观察者模式我们可以想象报纸提供商和报纸订阅者的关系，一个报纸提供商持有一个列表，列表记录着若干个报纸订阅者，每次报纸印刷出来之后，报纸提供商要通知订阅者来取报纸。如果新增一个订阅者，下一次就能被通知到。如果某个订阅者不再订阅，下一次就不再通知该订阅者。

2.观察者模式的例子

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

namespace ObservePatternDemo
{
    class NewsPaperReader
    {
        public string Name;

        public NewsPaperReader(string name)
        {
            this.Name = name;
        }

        public void ReadNewsPaper(NewsPaper newsPaper)
        {
            Console.WriteLine(this.Name +" is reading Newspaer,date is: " + newsPaper.Date + ",title is: " + newsPaper.Title);
        }
    }

    class NewsPaper
    {
        public string Date;
        public string Title;

        public NewsPaper(string date,string title)
        {
            this.Date = date;
            this.Title = title;
        }
    }

    class NewsPaperProvider
    {
        private readonly List<NewsPaperReader> readers = new List<NewsPaperReader>();

        public void AddReader(NewsPaperReader reader)
        {
            if(!readers.Contains(reader))
                readers.Add(reader);
        }

        public void RemoveReader(NewsPaperReader reader)
        {
            if (readers.Contains(reader))
                readers.Remove(reader);
        }

        public void NotifyAll()
        {
            var newsPaper = new NewsPaper("2014-11-14", "Good News");
            foreach (NewsPaperReader reader in readers)
            {
                reader.ReadNewsPaper(newsPaper);
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var newsPaperProvider = new NewsPaperProvider();
            var readerA = new NewsPaperReader("ReaderA");
            var readerB = new NewsPaperReader("ReaderB");

            newsPaperProvider.AddReader(readerA);
            newsPaperProvider.AddReader(readerB);

            newsPaperProvider.NotifyAll();

            newsPaperProvider.RemoveReader(readerB);
            newsPaperProvider.NotifyAll();

            Console.ReadKey();
        }
    }
}

上述观察者模式的例子比较简单，就不画UML图了。

观察者模式的精髓在于发布者持有一个List，里面有订阅者的名单。每次通知的时候，根据订阅者列表，逐一调用通知方法。这种情形非常类似责任链模式，即一个处理的Manager持有一个处理方法的List，针对一个对象依次进行处理。示例如下：

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

namespace ObservePatternDemo2
{
    /// <summary>
    /// Helper interface
    /// </summary>
    interface IHelper
    {
        void DoWork();
    }

    /// <summary>
    /// Build process
    /// </summary>
    class BuildHelper : IHelper
    {
        public void DoWork()
        {
            Console.WriteLine("Build is starting...");
        }
    }

    /// <summary>
    /// Deploy helper
    /// </summary>
    class DeployHelper : IHelper
    {
        public void DoWork()
        {
            Console.WriteLine("Deploy is starting...");
        }
    }

    /// <summary>
    /// Instal helper
    /// </summary>
    class InstallHelper : IHelper
    {
        public void DoWork()
        {
            Console.WriteLine("Install is starting...");
        }
    }

    /// <summary>
    /// Test helper
    /// </summary>
    class TestHelper : IHelper
    {
        public void DoWork()
        {
            Console.WriteLine("Test is starting...");
        }
    }

    /// <summary>
    /// Uninstall helper
    /// </summary>
    class UninstallHelper : IHelper
    {
        public void DoWork()
        {
            Console.WriteLine("Uninstall is starting...");
        }
    }
    
    class HelperProvider
    {
        private List<IHelper> helpers = new List<IHelper>();

        public HelperProvider()
        {

        }

        public HelperProvider(List<IHelper> helpers)
        {
            this.helpers = helpers;
        }

        public void AddReader(IHelper helper)
        {
            if (!helpers.Contains(helper))
                helpers.Add(helper);
        }

        public void RemoveReader(IHelper helper)
        {
            if (helpers.Contains(helper))
                helpers.Remove(helper);
        }

        public void DoProcess()
        {
            foreach (IHelper helper in helpers)
            {
                helper.DoWork();
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var helpers = new List<IHelper>
            {
                new BuildHelper(),
                new DeployHelper(),
                new InstallHelper(),
                new TestHelper(),
                new UninstallHelper()
            };
            var helperProvider = new HelperProvider(helpers);
            helperProvider.DoProcess();
            
            Console.ReadKey();
        }
    }
}

运行结果：

总结：模式并非一成不变，观察者模式灵活运用一下就可以做成责任链模式，类似工作流的处理，灵活运用，事半功倍！