设计模式的再研究(策略模式和观察者模式的结合)

最新推荐文章于 2023-03-22 19:56:53 发布

xftimes

最新推荐文章于 2023-03-22 19:56:53 发布

阅读量828

点赞数

分类专栏：设计模式文章标签：设计模式观察者

本文链接：https://blog.csdn.net/xftimes/article/details/32701361

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

设计模式的运用在于解决实际问题，是的，不能解决实际问题的模式，是没有用的。当你觉得你运用了某种模式时，先不要骄傲。这不，我现在再看我之前写的装饰者模式，竟然是不对的，时间总会在某一时刻让人顿悟。

我也不敢说我写的这次设计模式是对的，因为我现在我也不知道我用了哪些模式，自我觉得用了策略模式和观察者模式。

场景说明：假设多台机器出现了各种状况，在多个界面显示不同信息。如某个机器出故障了，监控界面说监控到了，操作界面说我派人去修。如某个机器需要移动，监控界面说监控到了，操作界面说好我把它扔出去，（监控界面只会说我监控到）。就是这个简单的场景，需要松耦合，比如多了一种状况，只需扩展，不需要大修改。

是直接上代码呢，还是直接上代码呢？还是直接上代码？？？？

好吧，直接上代码吧：

#region Interface
        public delegate void NotifyHandler(string mname, string info);
        public interface Iobo { }
        public interface INotify
        {
            string Notify();
        }
#endregion

#region Machine
        /// <summary>
        /// 机器类，加载各种异常状况，并触发Notify
        /// </summary>
        public class Machine : Iobo
        {
            public event NotifyHandler NotifyEvent;
            private String _machinename;
            public String MachineName
            {
                get { return _machinename; }
            }


            MoveBehavor _moving;
            ErrorBehavor _erroring;
            DisappearBehavor _disapperaing;
            UnknownBehavor _unknowning;
            public Machine(String machinename)
            {
                this._machinename = machinename;
                _moving = new MoveBehavor(this);
                _erroring = new ErrorBehavor(this);
                _disapperaing = new DisappearBehavor(this);
                _unknowning = new UnknownBehavor(this);
            }
            public void Notify(string type, string info)
            {

                if (type == MachineAction.MOVE.ToString())
                {
                    info = _moving.Notify(type, info);
                }
                else if (type == MachineAction.ERROR.ToString())
                {
                    info = _erroring.Notify(type, info);
                }
                else if (type == MachineAction.DISAPPEAR.ToString())
                {
                    info = _disapperaing.Notify(type, info);
                }
                else
                {
                    info = _unknowning.Notify(type, info);
                }



                if (NotifyEvent != null)
                {
                    NotifyEvent(MachineName, info);
                }
            }
        }
        #endregion

 #region Behavior
        public class BehavorBase : Iobo
        {
        }

        /// <summary>
        /// 移动行为
        /// </summary>
        public class MoveBehavor : BehavorBase, Iobo, INotify
        {
            private Machine machine;
            public MoveBehavor(Iobo mc)
            {
                machine = mc as Machine;
            }

            public string Notify(string type, string info)
            {
                string strinfo = (string.Format("机器{0}:{1}-{2}", machine.MachineName, type, "走走走:" + info));
                Console.WriteLine(strinfo);
                return strinfo;
            }
        }


        /// <summary>
        /// 故障行为
        /// </summary>
        public class ErrorBehavor : BehavorBase, Iobo, INotify
        {
            private Machine machine;
            public ErrorBehavor(Iobo mc)
            {
                machine = mc as Machine;
            }

            public string Notify(string type, string info)
            {
                string strinfo = (string.Format("机器{0}:{1}-{2}", machine.MachineName, type, "错错错:" + info));
                Console.WriteLine(strinfo);
                return strinfo;
            }
        }

        /// <summary>
        /// 消失行为
        /// </summary>
        public class DisappearBehavor : BehavorBase, Iobo, INotify
        {
            private Machine machine;
            public DisappearBehavor(Iobo mc)
            {
                machine = mc as Machine;
            }

            public string Notify(string type, string info)
            {
                string strinfo = (string.Format("机器{0}:{1}-{2}", machine.MachineName, type, "消失消失:" + info));
                Console.WriteLine(strinfo);
                return strinfo;
            }
        }

        public class UnknownBehavor : BehavorBase, Iobo, INotify
        {
            private Machine machine;
            public UnknownBehavor(Iobo mc)
            {
                machine = mc as Machine;
            }

            public string Notify(string type, string info)
            {
                string strinfo = (string.Format("机器{0}:{1}-{2}", machine.MachineName, type, "???????????:" + info));
                Console.WriteLine(strinfo);
                return strinfo;
            }
        }
        #endregion

 #region View
        /// <summary>
        /// 监控界面
        /// </summary>
        public class MonitorView
        {
            private string _name;
            private List<Machine> _mclist;
            public MonitorView(string name, List<Machine> mclist)
            {
                this._name = name;
                this._mclist = mclist;
                foreach (Machine _mc in mclist)
                {
                    _mc.NotifyEvent += new NotifyHandler(machine_NotifyEvent);
                }
            }

            void machine_NotifyEvent(string mname, string info)
            {
                if (info.Contains(MachineAction.ERROR.ToString()))
                {
                    Console.WriteLine(_name + ": 机器 " + mname + " ERROR?好的，我监控到了!");
                }
                else if (info.Contains(MachineAction.MOVE.ToString()))
                {
                    Console.WriteLine(_name + ": 机器 " + mname + " MOVE?好的，我监控到了!");
                }
                else if (info.Contains(MachineAction.DISAPPEAR.ToString()))
                {
                    Console.WriteLine(_name + ": 机器 " + mname + " DISAPPEAR?好的，我监控到了!");
                }
                else
                {
                    Console.WriteLine(_name + ": 机器 " + mname + " UNKNOWN? 监控无法识别该状况!");
                }
            }
        }

        /// <summary>
        /// 操作界面
        /// </summary>
        public class OperView
        {
            private string _name;
            private List<Machine> _mclist;
            public OperView(string name, List<Machine> mclist)
            {
                this._name = name;
                this._mclist = mclist;
                foreach (Machine _mc in mclist)
                {
                    _mc.NotifyEvent += (_mname, _info) =>
                    {
                        if (_info.Contains(MachineAction.ERROR.ToString()))
                        {
                            Console.WriteLine(_name + ": 机器 " + _mname + " ERROR?好吧，我去修一下他!");
                        }
                        else if (_info.Contains(MachineAction.MOVE.ToString()))
                        {
                            Console.WriteLine(_name + ": 机器 " + _mname + " MOVE?好的，我把它带到厕所里");
                        }
                        else if (_info.Contains(MachineAction.DISAPPEAR.ToString()))
                        {
                            Console.WriteLine(_name + ": 机器 " + _mname + " DISAPPEAR?我把它扔出去!");
                        }
                        else
                        {
                            Console.WriteLine(_name + ": 机器 " + _mname + " UNKNOWN? 操作无法进行！");
                        }

                    };
                }

            }


        }
        #endregion

/// <summary>
        /// 测试
        /// </summary>
        class Program
        {
            static void Main(string[] args)
            {
                List<Machine> mclist = new List<Machine>();
                Machine mc1 = new Machine("No01");
                mclist.Add(mc1);

                Machine mc2 = new Machine("No02");
                mclist.Add(mc2);

                Machine mc3 = new Machine("No03");
                mclist.Add(mc3);
                MonitorView monitorview = new MonitorView("监控界面", mclist);
                OperView normalview = new OperView("操作界面", mclist);

                mc1.Notify(MachineAction.DISAPPEAR.ToString(), "我需要消失!");
                Console.WriteLine("------------------------------------------------");
                mc2.Notify(MachineAction.ERROR.ToString(), "我有故障了!");
                Console.WriteLine("------------------------------------------------");
                mc3.Notify(MachineAction.UNKNOWN.ToString(), "我是来测试的!");
                Console.WriteLine("------------------------------------------------");
                mc1.Notify(MachineAction.MOVE.ToString(), "我要去上厕所！");
                Console.ReadLine();
            }


        }

输出结果：