服务端接口定义另类方法

内部接口的定义与实现各有千秋，本文所提到的是这样的思路：通过内部通用的方法完成“路由”转发，这样做的好处，不言而喻：单点控制风险、通用逻辑校验、流量控制……等等。

直接上代码：

public class MerchantPayment : IMerchantPayment
    {
        #region IPaymentClient 成员

        /// <summary>
        /// 执行API请求
        /// </summary>
        /// <typeparam name="T">领域对象</typeparam>
        /// <param name="request">具体的API请求</param>
        /// <param name="parser">自定义解析器</param>
        /// <returns>领域对象</returns>
        public T Execute<T>(IRequest request, IParser<T> parser) where T : IResponse
        {
            try
            {
                int RetCode = ToolUtils.CheckInvokeParameter(request);
                if (RetCode != Consts.Success)
                {
                    return parser.Parse(RetCode);
                }

                InterfaceFactory factory = new InterfaceFactory();
                factory.ApiName = request.GetApiName();
                return factory.PaymentInstance.Payment<T>(request);
            }
            catch (System.Exception e)
            {
                LogHelper.Error(e);
                return parser.Parse(e.Message);
            }
        }

        public SinglePaymentResponse SingleAccount(SinglePaymentAccount request)
        {
            return this.Execute<SinglePaymentResponse>(request, new SinglePaymentParser());
        }

        public SinglePaymentResponse SingleCard(SinglePaymentCard request)
        {
            return this.Execute<SinglePaymentResponse>(request, new SinglePaymentParser());
        }

        public BatchPaymentResponse BatchPayment(BatchPaymentRequest request)
        {
            ((IApiNameChanger)request).SetName(Consts.ApiName.BatchAccountPay);
            return this.Execute<BatchPaymentResponse>(request, new BatchPaymentParser());
        }

        public CheckPaymentResponse ValidatePayment(BatchPaymentRequest request)
        {
            ((IApiNameChanger)request).SetName(Consts.ApiName.BatchAccountCheck);
            return this.Execute<CheckPaymentResponse>(request, new CheckPaymentParser());
        }

        #endregion
    }

        /// <summary>
        /// 服务类对象
        /// </summary>
        public IPaymentService PaymentInstance
        {
            get
            {
                switch (ApiName)
                {

                    case Consts.ApiName.SinglePay: return new SinglePaymentService();
                    case Consts.ApiName.BatchAccountPay: return new BatchPaymentService();
                    case Consts.ApiName.BatchAccountCheck: return new ValidateService();
                }
                return new NullService();
            }
        }

/// <summary>
    /// 支付服务
    /// </summary>
    public interface IPaymentService
    {
        /// <summary>
        /// 付款
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="request">请求对象</param>
        /// <returns></returns>
        T Payment<T>(IRequest request) where T : IResponse;
    }

    /// <summary>
    /// Summary description for SinglePaymentService
    /// </summary>
    public class SinglePaymentService : IPaymentService
    {

        #region IPaymentService 成员

        public T Payment<T>(IRequest request) where T : IResponse
        {
            SinglePaymentResponse response = new SinglePaymentResponse();

            //.......

            return response as T;

        }

        #endregion
    }

    public class ValidateService : IPaymentService
    {
        T IPaymentService.Payment<T>(IRequest request)
        {
            BatchPaymentRequest req = request as BatchPaymentRequest;

            //......

            return GetResponse(Consts.Success) as T;
        }
    }

    /// <summary>
    /// Summary description for BatchPaymentService
    /// </summary>
    public class BatchPaymentService : IPaymentService
    {
        /// <summary>
        /// 批量付款
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="request"></param>
        /// <returns></returns>
        T Payment<T>(IRequest request) where T : IResponse
        {
            BatchPaymentRequest batch = request as BatchPaymentRequest;

            //.......

            return new BatchPaymentResponse
            {
                RetCode = Consts.Success,
                Message = "success"
            } as T;
        }
    }

    /// <summary>
    /// 默认服务, 异常兼容
    /// </summary>
    public class NullService : IPaymentService
    {

        #region IPaymentService 成员

        T IPaymentService.Payment<T>(IRequest request)
        {
            throw new NotImplementedException();
        }

        #endregion
    }

接口调用时，根据需要可以自行执行解析器、指定验证器等。