职责链的应用

在系统中经常要接收各方面的指令，解析指令后，交付一个处理程序进行统一处理，在这种情况下，如何系统设计不合理，就会出现众多的if-else，代码混乱不易扩展维护，所以采用职责链模式比较适合了！

例如，游戏中可能接受硬件指令，网络指令，手机指令，甚至其他，这都需要统一设计处理程序。

职责链模式本身比较简单。
但是要注意他和Filter模式的区别，Filter模式在处理指令时，是所有队列里面的所有filter处理器都会对指令进行处理。
职责链模式在处理指令的时候是：只要一个处理器处理了，那么程序就返回了，不继续处理了。

职责链基类

public abstract class ActionChainNode
    {
        protected static ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        private ActionChainNode next;

        public ActionChainNode AddChain(ActionChainNode next)
        {
            this.next = next;
            return next;
        }

        public bool Process(IGameState gameState, Action action)
        {
            try
            {
                bool processFlag = Do(gameState, action);
                if (!processFlag && next != null)
                {
                    processFlag = next.Process(gameState, action);
                    return processFlag;
                }
                return processFlag;
            }catch(Exception ex)
            {
                log.Error(ex.Message,ex);
            }
            return false;
        }

        protected abstract bool Do(IGameState gameState, Action action);
    }

一个指令处理器

internal class Action上分:ActionChainNode
    {
        private IPortService logic;
        private IPersistService persist;
        protected override bool Do(IGameState gameState, Action action)
        {
            logic = gameState.PortService;
            if (action.Sender == PlayPort.ControlPanel)
            {
                persist = gameState.PersistService;
                if (action.Command.Code == (short) CommandCode.上分)
                {
                    ThreadPool.QueueUserWorkItem(new WaitCallback(Doo), action);
                    return true;
                }
            }
            return false;
        }

        private void Doo(object state)
        {
        }
}

另一个处理器实例

internal class Action心跳 : ActionChainNode
    {
        private IPortService logic;
        public Action心跳()
        {
            log.Info("**【启动】心跳！！");
            Timer timer = new Timer(1000);
            timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
            timer.Enabled = true;
        }
        protected override bool Do(IGameState gameState, Action action)
        {
            logic = gameState.PortService;
            return true;
        }

        void timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            if(logic!=null)
            {
                ICommand heart = SingleCommand.Instance[CommandCode.心跳];
                heart.Data = new int[] {  };
                logic.Write(new Action(PlayPort.Logic, PlayPort.ControlPanel, heart));
            }
        }
    }

将他们连一块

public class GlobalActionChainFactory
    {
        private static GlobalActionChainFactory globalActionChainFactory = new GlobalActionChainFactory();
        private ActionChainNode root;
        private GlobalActionChainFactory()
        {
            root = new Action1();
            ActionChainNode next = root.AddChain(new Action2())
                .AddChain(new Action3()).AddChain(new Action4())
                .AddChain(new Action5()).AddChain(new Action6())
                .AddChain(new Action7());

            next.AddChain(new Action8());
        }
        public static GlobalActionChainFactory Instance
        {
            get
            {
                return globalActionChainFactory;
            }
        }
        public static ActionChainNode GetChain()
        {
            return Instance.root;
        }
    }

也可以再根据情况构建另一个处理职责链，然后就可以将它们放在系统的不同状态中，接收来自各方面的指令了。
例如，一个系统等待状态，在这等待期间会接受很多指令，她要处理

public class StepWaitingState : AbstractSingleGameState
    {
        public override GameState CurrentState
        {
            get { return GameState.StepWaiting; }
        }
       
        private Timer timer = new Timer(1000);
        private GameWait wait;
        public StepWaitingState()
        {
            timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
        }
        
        public override object Enter(Action action)
        {
            try
            {
                Tag.Clear();
                logic.Write(new Action(PlayPort.Logic, SingleCommand.SimpleCommand("等待期", "等待期")));
                timer.Enabled = true;
                //
                wait = GameWait.Instance;
                wait.Waiting();
                timer.Enabled = false;
                log.Debug("==========waiting finished ==============");
                //
                ActionFilterChainNode filter = StepPostFilterFactory.GetChain();
                filter.Process(this, action);
                //
                ICommand command = SingleCommand.Instance[CommandCode.某指令];
                command.Data = SingleGameContext.WinCard;
                logic.Write(new Action(LOGIC_PORT, command));
                command.Data = SingleGameContext.WinCard.ToColorTextString();
                logic.Write(new Action(LOGIC_PORT, UDP_PORT, command));
                //等待界面回应
                wait = GameWait.Instance;
                Tag.Add("open wait", wait);
                wait.Waiting();

                Transit(action);
            }
            catch (Exception ex)
            {
                log.Error(ex.Message,ex);
            }
            return null;
        }

        protected override void OnPortEvent(object sender, Action action)
        {
            Doo(action);
        }

        private void Doo(object state)
        {
            Action action = (Action) state;
            ActionChainNode controlPanelActionChain = WatingActionChainFactory.GetChain();
            controlPanelActionChain.Process(this, action);
        }

        public override IGameState Transit(Action action)
        {
            if (GameContext.GameState.CurrentState == CurrentState)
                GameContext.SetState(StateFactory.StepPost, action);
            return GameContext.GameState;
        }

    }

其中这行代码

ActionChainNode controlPanelActionChain = WatingActionChainFactory.GetChain();

就是一个职责链实例，

controlPanelActionChain.Process(this, action);

通过process进行处理，处理完毕返回！
其中的基类AbstractSingleGameState是状态模式的一个类型，下一个文章说一下状态模式的应用！

其中的

ActionFilterChainNode filter = StepPostFilterFactory.GetChain();

是Filter模式

public abstract class ActionFilterChainNode
    {
        protected static ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        private ActionFilterChainNode next;

        public ActionFilterChainNode AddChain(ActionFilterChainNode next)
        {
            this.next = next;
            return next;
        }

        public void Process(IGameState gameState, Action action)
        {
            try
            {
                Do(gameState, action);
                if (next != null)
                    next.Process(gameState,action);
            }catch(Exception ex)
            {
                MessagePrompt.Alert(this,"出现异常!" + Environment.NewLine + ex.Message);
            }
        }

        protected abstract void Do(IGameState gameState, Action action);
    }

可以看出来他是连续处理的，直到filter链的最后一个处理器

现在尅看出来，如果要扩展处理器，只要实现一个ActionChainNode就可以了，然后挂到相应的职责链上就可以了，代码清晰，以维护，扩展性强。

完毕！
http://qixin000.iteye.com/blog/1491198