c# - 从表达式创建动态 Linq select 子句

Question

假设我定义了以下变量:

IQueryable<MyClass> myQueryable;
Dictionary<string, Expression<Func<MyClass, bool>>> extraFields;
// the dictionary is keyed by a field name

现在，我想将一些动态字段附加到 IQueryable，以便它返回一个 IQueryable<ExtendedMyClass>。 , 其中ExtendedMyClass定义为:

class ExtendedMyClass
{
  public MyClass MyObject {get; set;}
  public IEnumerable<StringAndBool> ExtraFieldValues {get; set;}
}

class StringAndBool
{
  public string FieldName {get; set;}
  public bool IsTrue {get; set;}
}

换句话说，对于 extraFields 中的每个值, 我想在 ExtendedMyClass.ExtraFieldValues 中有一个值表示该表达式对该行的计算结果是否为真。

我觉得这在动态 Linq 和 LinqKit 中应该是可行的，尽管我以前从未认真使用过它。我也乐于接受其他建议，尤其是如果这可以在强类型的 Linq 中完成的话。

我正在使用 Linq to Entities，因此查询需要转换为 SQL。

Answer 1

因此，我们在这里将有很多步骤，但每个步骤都应该相当短、独立、可重用并且相对容易理解。

我们要做的第一件事是创建一个可以组合表达式的方法。它要做的是接受一个接受一些输入并生成一个中间值的表达式。然后它将接受第二个表达式作为输入，接受与第一个相同的输入，即中间结果的类型，然后计算一个新结果。它将返回一个接受第一个输入并返回第二个输出的新表达式。

public static Expression<Func<TFirstParam, TResult>>
    Combine<TFirstParam, TIntermediate, TResult>(
    this Expression<Func<TFirstParam, TIntermediate>> first,
    Expression<Func<TFirstParam, TIntermediate, TResult>> second)
{
    var param = Expression.Parameter(typeof(TFirstParam), "param");

    var newFirst = first.Body.Replace(first.Parameters[0], param);
    var newSecond = second.Body.Replace(second.Parameters[0], param)
        .Replace(second.Parameters[1], newFirst);

    return Expression.Lambda<Func<TFirstParam, TResult>>(newSecond, param);
}

为此，我们只需用第一个表达式的主体替换第二个表达式主体中第二个参数的所有实例。我们还需要确保两个实现对主要参数使用相同的参数实例。

此实现需要一种方法来将一个表达式的所有实例替换为另一个表达式:

internal class ReplaceVisitor : ExpressionVisitor
{
    private readonly Expression from, to;
    public ReplaceVisitor(Expression from, Expression to)
    {
        this.from = from;
        this.to = to;
    }
    public override Expression Visit(Expression node)
    {
        return node == from ? to : base.Visit(node);
    }
}

public static Expression Replace(this Expression expression,
    Expression searchEx, Expression replaceEx)
{
    return new ReplaceVisitor(searchEx, replaceEx).Visit(expression);
}

接下来我们将编写一个方法，它接受一系列接受相同输入并计算相同类型输出的表达式。它将把它转换成接受相同输入的单个表达式，但计算输出的序列作为结果，其中序列中的每个项目代表每个输入表达式的结果。

这个实现相当简单；我们创建一个新数组，使用每个表达式的主体(用一致的参数替换参数)作为数组中的每一项。

public static Expression<Func<T, IEnumerable<TResult>>> AsSequence<T, TResult>(
    this IEnumerable<Expression<Func<T, TResult>>> expressions)
{
    var param = Expression.Parameter(typeof(T));
    var body = Expression.NewArrayInit(typeof(TResult),
        expressions.Select(selector =>
            selector.Body.Replace(selector.Parameters[0], param)));
    return Expression.Lambda<Func<T, IEnumerable<TResult>>>(body, param);
}

既然我们已经准备好了所有这些通用的辅助方法，我们就可以开始处理您的具体情况了。

这里的第一步是将您的字典变成一系列表达式，每个表达式接受一个 MyClass 并创建一个表示该对的 StringAndBool。为此，我们将对字典的值使用 Combine，然后使用 lambda 作为第二个表达式，使用它的中间结果来计算 StringAndBool 对象，在除了关闭对的 key 。

IEnumerable<Expression<Func<MyClass, StringAndBool>>> stringAndBools =
    extraFields.Select(pair => pair.Value.Combine((foo, isTrue) =>
        new StringAndBool()
        {
            FieldName = pair.Key,
            IsTrue = isTrue
        }));

现在我们可以使用我们的 AsSequence 方法将它从一个选择器序列转换为一个选择器来选择一个序列:

Expression<Func<MyClass, IEnumerable<StringAndBool>>> extrafieldsSelector =
    stringAndBools.AsSequence();

现在我们快完成了。我们现在只需要在这个表达式上使用 Combine 来写出用于将 MyClass 选择到 ExtendedMyClass 中的 lambda，同时使用之前生成的选择器选择额外的字段:

var finalQuery = myQueryable.Select(
    extrafieldsSelector.Combine((foo, extraFieldValues) =>
        new ExtendedMyClass
        {
            MyObject = foo,
            ExtraFieldValues = extraFieldValues,
        }));

---

我们可以采用相同的代码，删除中间变量并依靠类型推断将其拉成单个语句，假设您不会觉得它太笨拙:

var finalQuery = myQueryable.Select(extraFields
    .Select(pair => pair.Value.Combine((foo, isTrue) =>
        new StringAndBool()
        {
            FieldName = pair.Key,
            IsTrue = isTrue
        }))
    .AsSequence()
    .Combine((foo, extraFieldValues) =>
        new ExtendedMyClass
        {
            MyObject = foo,
            ExtraFieldValues = extraFieldValues,
        }));

值得注意的是，这种通用方法的一个关键优势是使用更高级别的 Expression 方法生成的代码至少可以合理地理解，而且可以是静态的在编译时验证为类型安全。这里有一些通用的、可重用的、可测试的、可验证的扩展方法，一旦编写完成，我们就可以纯粹通过方法和 lambda 的组合来解决问题，并且不需要任何实际的表达式操作，这既复杂，容易出错，并消除了所有类型的安全性。这些扩展方法中的每一个都以这样的方式设计，只要输入表达式有效，结果表达式将始终有效，并且这里的输入表达式都是有效的，因为它们是 lambda 表达式，编译器会验证这些表达式为了类型安全。