Question

我有这个课程，我们称之为退款（因为这就是所谓的）。我想验证一下这个Refund及其附属的客户的一些事情，我想让这些验证可以重新订购，因为第一个旅行将被存储为退款的拒绝原因，还有一些是可能比其他人更耗费资源，更有可能被绊倒，所以我希望能够轻松地重新排序他们的执行，以便我可以在需要时挤出一些性能。

所有验证方法都将使用Refund对象并返回一个布尔值，表示验证是通过还是失败。所以，我在想，为什么不建立一个队列（或其他数据结构）来保存委托/ lambdas /匿名函数，每个函数代表一个验证方法？然后，只需将Refund传递给某些Validator类上的某种静态Validate（Refund refundToValidate）方法。这个方法将遍历委托数组，按顺序调用每个委托，如果其中一个产生错误，则返回false。

这是一个好主意还是一个愚蠢的想法？如果这是一个好主意，你能指点我某个地方的资源，或者说出我无意中实施的模式，这样我知道我做得对吗？如果这是一个愚蠢的想法，为什么以及我应该采取哪些不同的做法？

编辑：这是我到目前为止所得到的 -

public static class Validator
    {


        delegate REFUNDDENIALREASONS validationHandler(BatchRefund refundToValidate);

        public static List<REFUNDDENIALREASONS> ValidateRefund(BatchRefund refundToValidate)
        {
            List<Delegate> Validations = new List<Delegate>();
            List<REFUNDDENIALREASONS> DenialReasons = new List<REFUNDDENIALREASONS>();

            Validations = new List<Delegate>();

            validationHandler blockHandler = ValidateBlocks;
            Validations.Add(blockHandler);

            validationHandler accountHandler = ValidateCustomerAccountStatus;
            Validations.Add(accountHandler);

            foreach (validationHandler v in Validations)
            {
                DenialReasons.Add(v(refundToValidate));
            }

            return DenialReasons;
        }

        public static REFUNDDENIALREASONS ValidateCustomerAccountStatus(BatchRefund refundToHandle)
        {
            REFUNDDENIALREASONS denialReason;

            switch (refundToHandle.RefundCustomer.CustStatus)
            {

                case "C":
                    denialReason = REFUNDDENIALREASONS.None;
                    break;
                case "Y":
                    denialReason = REFUNDDENIALREASONS.AccounthasrecentChargebackNSF;
                    break;
                default:
                    denialReason = REFUNDDENIALREASONS.Fraud;
                    break;
            }

            return denialReason;

        }

        public static REFUNDDENIALREASONS ValidateBlocks(BatchRefund refundToHandle)
        {
            List<CustomerBlock> blocks = refundToHandle.RefundCustomer.Blocks;
            //add new codes to block here
            string[] illegalblockcodes = new string[] { "L1", "C1" };

            foreach (string code in illegalblockcodes)
                if (blocks.Exists(b => b.BkClassCode == code))
                {
                    return REFUNDDENIALREASONS.Fraud;
                }

            return REFUNDDENIALREASONS.None;

        }
    }

Answer 1

您基本上是在描述Chain-of-responsibility设计模式的调整。这样做有优点和缺点，但如果您希望在任何时间点都可以灵活地在队列中添加其他操作，那么这是一个很好的选择。

Answer 2

不一定是个坏主意。您是否打算跟踪哪些验证失败？如果您正在使用通过队列运行它的静态方法，您将如何判断？

这种设计对于类的数据验证是一个好主意吗？

2 个答案: