使用数字操作数的字符串值创建自定义谓词

Question

我正在尝试将数字操作数表达式的字符串值（“GreaterThan”、“Equals”等）传递给参数。我已经创建了下面的代码，但它“笨拙”。我不喜欢 if 块，我认为有一种方法可以使用自定义 LINQ 比较谓词来做到这一点。我尝试关注 this post 中的回复，但似乎无法关注。关于如何清理我的方法的任何想法？

这里的代码显示了我想如何将字符串值“GreaterThan”传递给函数

    var myValues = new Dictionary<string, int> {{"Foo", 1}, {"Bar", 6}};
    var failed = DoAnyValuesFail(myValues, "GreaterThan", 4);

这是我写的“笨拙”的示例方法：

    public bool DoAnyValuesFail(Dictionary<string, int> dictionary, string expression, int failureValue)
    {
        var failureValues = new List<KeyValuePair<string, int>>();
        if (expression == "GreaterThan")
            failureValues = dictionary.Where(x => x.Value > failureValue).ToList();
        if (expression == "LessThan")
            failureValues = dictionary.Where(x => x.Value < failureValue).ToList();
        if (expression == "Equals")
            failureValues = dictionary.Where(x => x.Value == failureValue).ToList();
        return failureValues.Any();
    }

--- 更新 - 最终版本 ---

我认为以下回复中的部分困惑在于我对函数、谓词和委托的术语没有那么快。对于那个很抱歉。无论如何，我确实想澄清一件事，那就是“GreaterThan”、“LessThan”和“Equals”的值来自配置文件，因此它们需要是在运行时调整的“Magic Strings”。

因此，根据 Matthew Haugen 和 Enigmativity 的反馈，我提出了以下我认为最适合我需要的代码。如果您认为这是错误的或需要调整，我愿意接受任何建议。

// These values actually come from a configuration file... shown here as hard coded just for illustration purposes
var failureValue = 2;
var numericQualifier = "<";

// This comes from my external data source
var myValues = new Dictionary<string, int> { { "Foo", 1 }, { "Bar", 6 } };

// This is the delegate (am I using that term correctly?) called Compare which is setup as an extension method
var failureValues = myValues.Where(x => numericQualifier.Compare()(x.Value, failureValue)).ToList();
if (failureValues.Any())
    Console.WriteLine("The following values failed: {0}", string.Join(", ", failureValues));

这就是我的Compare扩展方法：

public static class MyExtensions
{
    public static Func<int, int, bool> Compare(this string expression)
    {
        switch (expression)
        {
            case "GreaterThan":
            case ">":
                return (v, f) => v > f;
            case "LessThan":
            case "<":
                return (v, f) => v < f;
            case "Equals":
            case "=":
                return (v, f) => v == f;
            default:
                throw new ArgumentException(string.Format("The expression of '{0}' is invalid.  Valid values are 'GreaterThan', 'LessThan' or 'Equals' or their respective symbols (>,<,=)", expression));
        }
    }
}

Answer 1

鉴于您要求将表达式与字符串匹配，我倾向于这样做：

private Dictionary<string, Func<int, int, bool>> _predicates =
    new Dictionary<string, Func<int, int, bool>>
    {
        { "GreaterThan", (v, f) => v > f },
        { "LessThan", (v, f) => v < f },
        { "Equals", (v, f) => v == f },
    };

public bool DoAnyValuesFail(
    Dictionary<string, int> dictionary,
    string expression,
    int failureValue)
{
    return _predicates.ContainsKey(expression)
        ? dictionary.Any(kvp => _predicates[expression](kvp.Value, failureValue))
        : false;
}

但是，正如其他人所说，我认为这是一个更好的选择：

public bool DoAnyValuesFail(
    Dictionary<string, int> dictionary,
    Func<int, bool> predicate)
{
    return dictionary.Any(kvp => predicate(kvp.Value));
}

然后简单地这样称呼它：

var failed = DoAnyValuesFail(myValues, x => x > 4);

但是你离让它变得更简单只有一步之遥：

var failed = myValues.Any(x => x.Value > 4);

不需要DoAnyValuesFail 方法——这意味着更简单的代码、更少的潜在错误和没有“魔法”字符串。

这段代码比你原来的代码更清晰，实际上也更简洁。

Answer 2

我首先将其设为enum 而不是`字符串。

public enum ComparisonType
{
    GreaterThan,
    LessThan,
    Equal,
}

然后，我会把它改成这样。这也将提高性能，因为只需要返回一个匹配值。

public bool DoAnyValuesFail(Dictionary<string, int> dictionary, ComparisonType expression, int failureValue)
{
    switch (expression)
    {
        case ComparisonType.Equals:
            return dictionary.Any(x => x.Value == failureValue);
        case ComparisonType.GreaterThan:
            return dictionary.Any(x => x.Value > failureValue);
        case ComparisonType.LessThan:
            return dictionary.Any(x => x.Value < failureValue);
        default:
            throw new NotSupportedException();
    }
}

当然，它并没有全部比你所拥有的干净得多。它可能比依赖那些string 输入更可靠，这使它更具可读性。在我看来，不通过List<> 会有所帮助。但我认为除此之外你无能为力。我的意思是，您可以将Func<T, bool> 存储在分配给switch 的值中，然后使用它，这将使return dictionary.Any(...) 正常化，但我觉得这样会减少它可读。

最终我认为这很好。您对 Expression 所做的任何事情都会因为功能如此简单而降低可读性。

Answer 3

您可以重写您的方法签名以使用这样的委托：

public bool DoAnyValuesFail(Dictionary<string, int> dictionary,Func<int,bool> predicate)
{
     var failureValues = new List<KeyValuePair<string, int>>();   
     failureValues = dictionary.Where(x => predicate(x.Value)).ToList();
     return failureValues.Any();
     //instead of the code above you could simply do
     //return dictionary.Any(x => predicate(x.Value));
}

然后，当您调用它时，您可以像这样提供所需的表达式：

var myValues = new Dictionary<string, int> { { "Foo", 1 }, { "Bar", 6 } };
var failed = DoAnyValuesFail(myValues, x => x < 4); //4 is what you had as the failureValue