.NET可复用TCP通信层之消息分派器组件

    public interface ITcpReqStreamDispatcher : IReqestStreamDispatcher
    {       
        ArrayList DealRequestMessage(RequestData requestData ,out byte[] leftData ,ref RequestValidation validation) ;//同步回复
        bool      DealRequestMessage(RequestData requestData , NetworkStream userStream ,out byte[] leftData) ; //异步回复       
    }

    //从网络接收到的原始数据的封装
    public class RequestData
    {
        public int  ConnectID=0 ;
        public bool IsFirstMsg=false ; //标志是否为连接建立后的第一条消息
        public byte[] Buff    =null ; //接收数据缓冲区 ,可能其头部包含上次未处理完的数据
        public int ValidCount =0 ; //缓冲区中有效字节的个数 >=本次接收的字节数       
    }

                //处理请求   
                byte[] leftData=null ;               
                ArrayList repondList=this.messageDispatcher.DealRequestMessage(key.RequestData  ,out leftData , ref key.Validation) ;
                if(this.validateRequest)
                {
                    if(key.Validation.gotoCloseConnection)
                    {
                        this.DisposeOneConnection(streamHashCode ,key.Validation.cause) ;
                    }
                }

     /// <summary>
    /// IDataStreamHelper 通信协议的面向流辅助设施。
    /// </summary>
    public interface IDataStreamHelper :IStringEncoder
    {
        int MaxRecieveBuffSize{get ;} //接收缓冲区的大小
        int MessageHeaderLength{get ;} //消息头的长度
        int OffsetOfLengthField{get ;} //表示消息长度的字段在消息头中的偏移
        IDataStreamHeader ParseMessageHeader(byte[] data ,int offset) ; //解析消息头
        LengthTypeInHeader LengthTypeInHeader{get ;}
        byte[] GetRespondWhenFailure(byte[] reqData ,ServiceFailureType failType) ;    //根据服务失败类型获取失败回复消息
        byte[] GetRespondWhenFailure(byte[] reqData ,string errorMsg) ;           
    }
    /// <summary>
    /// StringEncoder 限定字符串编码格式
    /// </summary>
    public interface IStringEncoder
    {
        string GetStrFromStream(byte[] stream ,int offset ,int len) ;
        byte[] GetBytesFromStr(string ss) ;
    }
    /// <summary>
    /// ServiceFailureType 服务失败类型
    /// </summary>
    public enum ServiceFailureType
    {
        InvalidMessge ,ParseFailure ,HandleFailure ,ServiceStopped ,ServiceIsNotExit ,ServerIsBusy
    }

    public interface IDataStreamHeader
    {
        int MessageLength    {get ;set ;} //本消息长度
        int TypeKey            {get ;set ;} //请求的目录类型
        int ServiceKey        {get ;set ;} //请求类型
        int ServiceItemIndex{get ;set ;} //请求细分索引
        int RandomNum        {get ;set ;} //用于将回复与请求一一对应起来       
        int Result            {get ;set ;} //服务结果   
   
        string UserID        {get ;set ;} //发出请求的用户编号

        byte[] ToDataStream() ;              //将消息头转化为流，流的长度位消息头的长度
        void   ToDataStream(byte[] buff ,int offset);   
    }

public interface IMessageSplitter
    {
        void Initialize(int maxBuffSize ,int headerLen ,int offSetLenField ,LengthTypeInHeader lenType) ;
        ArrayList SplitRequestMsgs(byte[] buff ,int validCount , out byte[] leftData) ;//ArrayList 中每条记录都是是byte[]，表示一个完整的请求
    }
    //消息头中的长度是body长度还是总长度
    public enum LengthTypeInHeader
    {
        TotalLen ,BodyLen
    }

    public interface IRequestDealerFactory
    {
        IRequestDealer CreateDealer(int requestType ,int serverTypeKey)  ;//serverTypeKey 比如城市代号
        event CbackRequestRecieved RequestRecieved ;
    }

    public interface IRequestDealer
    {       
        byte[]  DealRequestMessage(RoundedRequestMsg reqMsg ) ;//同步回复

        event CbackRequestRecieved RequestRecieved ;
    }
    public delegate void CbackRequestRecieved(RoundedRequestMsg roundedMsg) ;
    /// <summary>
    /// RoundedRequestMsg 对应于一条完整的请求
    /// </summary>
    public struct RoundedRequestMsg
    {
        public int ConnectID ; //请求所对应的Tcp连接
        public byte[] Data ;
    }

    /// <summary>
    /// ITcpStreamDispatcherHook 由TcpStreamDispatcher使用，用于对请求消息和回复消息进行截获,然后处理转换这些消息，
    /// 比如加密/解密。 
    /// </summary>
    public interface ITcpStreamDispatcherHook
    {
        //转换消息
        byte[] CaptureRequestMsg(byte[] roundedMsg) ;
        byte[] CaptureRespondMsg(byte[] roundedMsg) ;

        //验证消息，以下验证的消息是还没有被捕获的消息
        bool VerifyFirstMsgOfUser(byte[] roundedMsg ,ref RequestValidation validation) ;
        bool VerifyOtherMessage(byte[]   roundedMsg ,ref RequestValidation validation) ;
    }

      private IMessageSplitter               curMsgSplitter=new MessageSpliter() ;
      private IDataStreamHelper            curMsgHelper ;  //必须设置
      private IRequestDealerFactory       curDealerFactory ;  //必须设置
      private ITcpStreamDispatcherHook tcpStreamDispatcherHook ;

       public ArrayList DealRequestMessage(RequestData requestData, out byte[] leftData, ref RequestValidation validation)
        {
            //消息分裂
            ArrayList respondList=new ArrayList() ;
            ArrayList reqList=this.curMsgSplitter.SplitRequestMsgs(requestData.Buff ,requestData.ValidCount ,out leftData) ;
            if(reqList==null)
            {
                return respondList ;
            }               
            bool verified=true ;
            for(int i=0; i<reqList.Count ;i++)
            {       
                byte[] theData=(byte[])reqList[i] ;
                #region 验证消息               
                if(requestData.IsFirstMsg && (i==0))
                {                       
                    verified=this.tcpStreamDispatcherHook.VerifyFirstMsgOfUser(theData ,ref validation) ;                   
                }
                else
                {                           
                    verified=this.tcpStreamDispatcherHook.VerifyOtherMessage(theData ,ref validation ) ;                   
                }

                if(! verified)
                {
                    if(validation.gotoCloseConnection)
                    {
                        return null ;
                    }

                    this.AddRespondToList(respondList ,this.curMsgHelper.GetRespondWhenFailure(theData ,ServiceFailureType.InvalidMessge)) ;
                    continue ;
                }
                #endregion
               
                //接插，捕获/转换请求消息
                byte[] reqData=this.tcpStreamDispatcherHook.CaptureRequestMsg(theData) ;
                #region 处理消息
                //处理消息
                IDataStreamHeader header=this.curMsgHelper.ParseMessageHeader(reqData ,0);
                IRequestDealer dealer=this.curDealerFactory.CreateDealer(header.ServiceKey ,header.TypeKey) ;
                if(dealer==null)
                {
                    this.AddRespondToList(respondList ,this.curMsgHelper.GetRespondWhenFailure(reqData ,ServiceFailureType.ServiceIsNotExit)) ;
                    continue ;
                }
                RoundedRequestMsg roundReqMsg=new RoundedRequestMsg();
                roundReqMsg.ConnectID=requestData.ConnectID ;
                roundReqMsg.Data=reqData ;   
                try
                {
                    byte[] respondData=dealer.DealRequestMessage(roundReqMsg) ;
                   
                    if(respondData !=null)
                    {
                        this.AddRespondToList(respondList ,respondData) ;
                    }
                }
                catch(Exception ee)
                {                   
                    this.AddRespondToList(respondList , this.curMsgHelper.GetRespondWhenFailure(reqData ,ee.Message)) ;
                }   
                #endregion
            }

            return respondList;
        }
        //将回复消息加密后放入list
        private void AddRespondToList(ArrayList list ,byte[] theRespondData)
        {
            //接插，捕获/转换回复消息
            byte[] respondData=this.tcpStreamDispatcherHook.CaptureRespondMsg(theRespondData) ;
            list.Add(respondData) ;
        }