internal void ProcessRequest( RequestMessage request )
 {
     var result = this._dispatcher.Dispatch( this, request.MessageId, request.Method, request.Arguments );
     this.Transport.Send( this, MessageType.Response, request.MessageId, result.ReturnValue, result.IsVoid, result.Exception );
 }
        /// <summary>
        ///		Deserialize from specified buffer.
        /// </summary>
        /// <param name="input">Buffer which stores serialized request/notification stream.</param>
        /// <param name="result">Deserialied packed message will be stored.</param>
        /// <returns>Error information.</returns>
        /// <exception cref="ArgumentNullException">
        ///		<paramref name="input"/> is null.
        /// </exception>
        /// <exception cref="InvalidOperationException">
        ///		Some filters violate contract.
        /// </exception>
        public RpcErrorMessage Deserialize( IEnumerable<byte> input, out RequestMessage result )
        {
            if ( input == null )
            {
                throw new ArgumentNullException( "input" );
            }

            Contract.EndContractBlock();

            var context = new RequestMessageDeserializationContext( input, this._maxRequestLength );

            var sequence = context.ReadBytes();

            foreach ( var preDeserializationFilter in this._preDeserializationFilters )
            {
                sequence = preDeserializationFilter.GetFilter().Process( sequence, context );
                if ( !context.SerializationError.IsSuccess )
                {
                    result = default( RequestMessage );
                    return context.SerializationError;
                }
            }

            DeserializeCore( context );

            if ( !context.SerializationError.IsSuccess )
            {
                result = default( RequestMessage );
                return context.SerializationError;
            }

            Contract.Assert( !String.IsNullOrWhiteSpace( context.MethodName ) );
            Contract.Assert( context.Arguments != null );

            foreach ( var postDeserializationFilter in this._postDeserializationFilters )
            {
                postDeserializationFilter.GetFilter().Process( context );
                if ( !context.SerializationError.IsSuccess )
                {
                    result = default( RequestMessage );
                    return context.SerializationError;
                }
            }

            if ( String.IsNullOrWhiteSpace( context.MethodName ) )
            {
                throw new InvalidOperationException( "Filter became method null or empty." );
            }

            if ( context.Arguments == null )
            {
                throw new InvalidOperationException( "Filter became arguments null." );
            }

            result = new RequestMessage( context.MessageId, context.MethodName, context.Arguments );
            return RpcErrorMessage.Success;
        }