public interface IMessageDispatcher
    {
        IEsbLogger           EsbLogger{set ;}        
        INetMessageHook       NetMessageHook{set ;}//可为EsbNetMessageHook
        IGatewayMessageSpy GatewayMessageSpy{set;}
        IInnerMessageSpy   InnerMessageSpy{set;}

IContractHelper       ContractHelper{set ;}//必须设置
        INakeDispatcher    NakeDispatcher{set ;} //必须设置

NetMessage DispatchMessage(NetMessage reqMsg) ;
        
        /// <summary>
        /// 如所有的SingleMessage在发送之前必须经过IMessageDispatcher的Hook链和Spy
        /// </summary>        
        NetMessage BeforeSendMessage(NetMessage msg) ;

event CbNetMessage MessageReceived ;
    }

    public class MessageDispatcher :IMessageDispatcher
    {
        #region property
        #region Logger
        private IEsbLogger esbLogger = new EmptyEsbLogger() ;
        public  IEsbLogger EsbLogger
        {
            set
            {
                if(value != null)
                {
                    this.esbLogger = value ;
                }
            }
        }
        #endregion

#region NakeDispatcher    
        private INakeDispatcher nakeDispatcher ;
        public  INakeDispatcher NakeDispatcher
        {
            set
            {
                this.nakeDispatcher = value ;
            }
        }
        #endregion

#region NetMessageHook
        private INetMessageHook netMessageHook = new EmptyNetMessageHook() ;
        public  INetMessageHook NetMessageHook 
        {
            set
            {
                this.netMessageHook = value ;
            }
        }
        #endregion

#region InnerMessageSpy        
        private IInnerMessageSpy innerMessageSpy = new EmptyInnerMessageSpy() ;
        public  IInnerMessageSpy InnerMessageSpy
        {
            set
            {
                if(value != null)
                {
                    this.innerMessageSpy = value ;
                }

}
        }
        #endregion
        
        #region GatewayMessageSpy    
        private IGatewayMessageSpy gatewayMessageSpy = new EmptyGatewayNetMessageSpy() ;
        public  IGatewayMessageSpy GatewayMessageSpy
        {
            set
            {
                if(value != null)
                {
                    this.gatewayMessageSpy = value ;
                }
            }
        }
        #endregion

#region ContractHelper
        private IContractHelper contractHelper = null ;
        public  IContractHelper ContractHelper
        {
            set
            {
                this.contractHelper = value ;
            }
        }
        #endregion

public event CbNetMessage MessageReceived;
        #endregion

#region IMessageDispatcher 成员

public NetMessage DispatchMessage(NetMessage reqMsg)
        {
            try
            {
                if(this.MessageReceived != null)
                {
                    this.MessageReceived(reqMsg) ;
                }

this.gatewayMessageSpy.SpyReceivedMsg(reqMsg) ;

NetMessage msgHooked = this.netMessageHook.CaptureReceivedMsg(reqMsg) ;

this.innerMessageSpy.SpyReceivedMsg(msgHooked) ;                
                NetMessage resMsg = this.nakeDispatcher.DispatchMessage(msgHooked) ;
                if(reqMsg == null)
                {
                    return null ;
                }
                
                return this.BeforeSendMessage(resMsg) ;
            }
            catch(Exception ee)
            {
                this.esbLogger.Log(ee.GetType().ToString() ,ee.Message ,"ESFramework.Network.MessageDispatcher.DispatchMessage" ,ErrorLevel.High) ;
                return this.contractHelper.GetResponseByServiceResultType(reqMsg ,ServiceResultType.HandleFailure) ;                    
            }
        }

public NetMessage BeforeSendMessage(NetMessage msg)
        {
            this.innerMessageSpy.SpyToBeSendedMsg(msg) ;
            NetMessage msgHooked = this.netMessageHook.CaptureBeforeSendMsg(msg) ;
            this.gatewayMessageSpy.SpyToBeSendedMsg(msgHooked) ;

return msgHooked ;            
        }

#endregion
    }

    public interface INakeDispatcher
    {
        NetMessage DispatchMessage(NetMessage msg) ;
    }

    public class NakeDispatcher :INakeDispatcher
    {
        #region DataDealerFactory
        private IDataDealerFactory dataDealerFactory = null ; 
        public  IDataDealerFactory DataDealerFactory
        {
            set
            {
                this.dataDealerFactory = value ;
            }
        }
        #endregion
        
        #region ContractHelper
        private IContractHelper contractHelper = null ; 
        public  IContractHelper ContractHelper
        {
            set
            {
                this.contractHelper = value ;
            }
        }
        #endregion

#region INakeDispatcher 成员

public NetMessage DispatchMessage(NetMessage msg)
        {
            IDataDealer dealer = this.dataDealerFactory.CreateDealer(msg.Header.ServiceKey ,msg.Header.TypeKey) ;
            if(dealer == null)
            {
                return this.contractHelper.GetResponseByServiceResultType(msg ,ServiceResultType.ServiceIsNotExist) ;
            }

return dealer.DealRequestMessage(msg) ;
        }

#endregion
    }