检查和变异可查询表达式树

public interface ICustomQueryProvider : IQueryProvider
{
    IEnumerable ExecuteEnumerable(Expression expression);
}

这只是主机使用表达式调用的自定义方法。这就是拦截的地方。

public abstract class CustomQueryProvider : ICustomQueryProvider
{
    public CustomQueryProvider(IQueryable sourceQuery)
    {
        Source = sourceQuery;
    }

    protected IQueryable Source { get; }

    public abstract IQueryable CreateQuery(Expression expression);

    public abstract IQueryable CreateQuery(Expression expression);

    public virtual object Execute(Expression expression)
    {
        return Source.Provider.Execute(expression);
    }

    public virtual TResult Execute(Expression expression)
    {
        object result = (this as IQueryProvider).Execute(expression);
        return (TResult)result;
    }

    public virtual IEnumerable ExecuteEnumerable(Expression expression)
    {
        return Source.Provider.CreateQuery(expression);
    }
}

定制提供程序有两个关键功能：它捕获原始查询（因此是原始提供程序），并且在调用“execute”方法时，它将表达式传递给原始提供程序。

public class QueryHost : IQueryHost
{
    public QueryHost(
        IQueryable source)
    {
        Expression = source.Expression;
        CustomProvider = new QueryInterceptingProvider(source);
    }

    public QueryHost(
        Expression expression,
        QueryInterceptingProvider provider)
    {
        Expression = expression;
        CustomProvider = provider;
    }

    public virtual Type ElementType => typeof(T);

    public virtual Expression Expression { get; }

    public IQueryProvider Provider => CustomProvider;

    public IQueryInterceptingProvider CustomProvider { get; protected set; }

    public virtual IEnumerator GetEnumerator() =>
        CustomProvider.ExecuteEnumerable(Expression).GetEnumerator();
}

要注意的主要功能是在构造函数调用中捕获自定义提供程序，并将其GetEnumerator实现的请求传递给自定义提供程序。定制提供程序是什么样的？

public delegate Expression ExpressionTransformer(Expression source);

提供程序需要注意转换。这是定义如何注册的接口：

public interface IQueryInterceptor
{
    void RegisterInterceptor(ExpressionTransformer transformation);
}

现在进入拦截提供程序…

public class QueryInterceptingProvider :
    CustomQueryProvider, IQueryInterceptingProvider
{
    private ExpressionTransformer transformation = null;

    public QueryInterceptingProvider(IQueryable sourceQuery)
        : base(sourceQuery)
    {
    }

    public override IQueryable CreateQuery(Expression expression)
    {
        return new QueryHost(expression, this);
    }

    public override IQueryable CreateQuery(Expression expression)
    {
        if (typeof(TElement) == typeof(T))
        {
            return CreateQuery(expression) as IQueryable;
        }

        var childProvider = new QueryInterceptingProvider(Source);

        return new QueryHost(
            expression, childProvider);
    }

    public void RegisterInterceptor(ExpressionTransformer transformation)
    {
        if (this.transformation != null)
        {
            throw new InvalidOperationException();
        }

        this.transformation = transformation;
    }

    public override object Execute(Expression expression)
    {
        return Source.Provider.Execute(TransformExpression(expression));
    }

    public override IEnumerable ExecuteEnumerable(Expression expression)
    {
        return base.ExecuteEnumerable(TransformExpression(expression));
    }

    private Expression TransformExpression(Expression source) =>
        transformation == null ? source :
        transformation(source);
}

发生什么了？简而言之，定制提供程序将执行三项操作。

public class Thing
{
    private static readonly Random Random = new Random();
    public string Id { get; private set; } = Guid.NewGuid().ToString();
    public int Value { get; private set; } = Random.Next(int.MinValue, int.MaxValue);
    public DateTime Created { get; private set; } = DateTime.Now;
    public DateTime Expires { get; private set; } = DateTime.Now.AddDays(Random.Next(1, 999));
    public bool IsTrue { get; private set; } = Random.NextDouble() < 0.5;
}

静态方法会生成10,000个things。接下来，我设置了拦截器。第一次拦截不会更改表达式。它只是将其写入控制台（ToString()默认覆盖提供了整个表达式树的非常清晰的表示）。

static Expression ExpressionTransformer(Expression e)
{
    Console.WriteLine(e);
    return e;
}

接下来，API设置要使用的查询。它将其包装在查询主机中并注册“转换”。现在可以使用查询了。

var query = new QueryHost(ThingDbQuery);
query.CustomProvider.RegisterInterceptor(ExpressionTransformer);

只需向消费者显示IQueryable即可构建查询（通过QueryHost来实现）。

var list = query.Where(t => t.IsTrue &&
    t.Id.Contains("aa") &&
    t.Expires < DateTime.Now.AddDays(100))
    .OrderBy(t => t.Id).ToList();

Console.WriteLine($"Retrieved {list.Count()} items.");

运行此命令将产生以下输出：

var results = query.Where(t => t.IsTrue &&
    t.Id.Contains("aa") &&
    t.Expires < DateTime.Now.AddDays(100))
    .OrderBy(t => t.Id);

这是注册：

static Expression ExpressionTransformer(Expression e)
{
    Console.WriteLine($"Before: {e}");

    var newExpression = new GuardRailsExpressionVisitor().Visit(e);

    Console.WriteLine($"After: {newExpression}");
    return newExpression;
}

// wrap and intercept
var query = new QueryHost(ThingDbQuery);
query.CustomProvider.RegisterInterceptor(ExpressionTransformer);

请注意，该表达式已传递到GuardRailsExpressionVisitor。ExpressionVisitor类提供了一种遍历和修改表达式树的简便方法。该树由基类递归迭代，然后调用可以重写以检查树上节点的方法。被覆盖的方法将返回原始表达式或修改后的表达式，从而导致树的转换。要实现护栏，有以下三种可能性：

var results = query.Take(10);

使用如下扩展方法：

public static IQueryable Take(this IQueryable source, int count)
{
    if (source == null)
    {
        throw Error.ArgumentNull(nameof(source));
    }

    return source.Provider.CreateQuery(
        Expression.Call(
            null,
            IQueryable(Queryable.Take).GetMethodInfo()
                .GetGenericMethodDefinition().MakeGenericMethod(TSource),
            source.Expression,
            Expression.Constant(count)));
}

这是拦截方法调用并强制执行“take”规则的代码：

protected override Expression VisitMethodCall(MethodCallExpression node)
{
    if (node.Method.Name == nameof(Queryable.Take))
    {
        TakeFound = true;

        if (node.Arguments[1] is ConstantExpression constant)
        {
            if (constant.Value is int valueInt)
            {
                if (valueInt > 10)
                {
                    var expression = node.Update(
                        node.Object,
                        new[] { node.Arguments[0] }
                        .Append(Expression.Constant(10)));
                    return expression;
                }
            }
        }
    }

    return base.VisitMethodCall(node);
}

仅当值超出范围时，才覆盖该表达式。该Update方法（适用于大多数表达式）无需从头开始重建原始表达式，而是使您可以轻松地创建表达式的副本并覆盖所需的参数。第一个参数指向父查询，因此第二个参数是我们覆盖到新值的参数。运行此操作将导致以下结果：

public override Expression Visit(Expression node)
{
    if (first)
    {
        first = false;
        var expr = base.Visit(node);

        if (TakeFound)
        {
            return expr;
        }

        var existing = expr as MethodCallExpression;

        var newExpression = Expression.Call(
            typeof(Queryable),
            nameof(Queryable.Take),
            existing.Method.ReturnType.GetGenericArguments(),
            existing,
            Expression.Constant(10));
        return newExpression;
    }

    return base.Visit(node);
}

请记住，这Visit是递归调用的，因此first标志确保顶级逻辑仅运行一次。解析表达式树，如果遇到了take表达式，则仅返回修改后的表达式。否则，它将创建take表达式。顶级表达式始终是返回结果的调用。要实现take，我们只需创建自己的方法即可，将take应用于包装的方法并返回结果。故事通过Expression.Call参数讲述。

var list = query.Where(
    t => t.IsTrue &&
        t.Id.Contains("aa") &&
        t.Expires < DateTime.Now.AddDays(100))
    .OrderBy(t => t.Id).ToList();

最终看起来像这样的过滤器：

AndAlso(t.IsTrue,
    AndAlso(
        t.Id.Contains("aa"),
        IsLessThan(
            t.Expires,
            DateTime.Now.AddDays(500))))

首先，让我们捕获t的值。

private static object instance;

我创建了一个设置实例的方法：

private static void SetInstance(object instance)
{
    BinaryInterceptorVisitor.instance = instance;
}

为了使构建调用该方法的表达式更加容易，我添加了一些帮助程序方法，这些方法可以解决方法信息的数据结构，称为MethodInfo。这些是找到static方法所需的标志：

private static readonly BindingFlags GetStatic =
    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;

这是获取MethodInfo数据的方法：

private static MethodInfo GetMethod(string methodName) =>
    typeof(BinaryInterceptorVisitor).GetMethod(methodName, GetStatic);

这是该方法的参考：

private static readonly MethodInfo SetInstanceMethod = GetMethod(nameof(SetInstance));

Func Where;

每个实体都传递到筛选器中，最终筛选器是否通过。这是拦截lambda表达式的重载：

protected override Expression VisitLambda(Expression node)

要拦截的表达式具有特定的签名。它将只有一个类型的参数T和一个类型的返回值bool：

if (node.Parameters.Count == 1 &&
    node.Parameters[0].Type == typeof(T) &&
    node.ReturnType == typeof(bool))

截取正确的lambda表达式后，我们的代码会潜入以获取实体：

var returnTarget = Expression.Label(typeof(bool));

var lambda = node.Update(
    Visit(node.Body),
    node.Parameters.Select(p => Visit(p)).Cast());

var innerInvoke = Expression.Return(
    returnTarget, Expression.Invoke(lambda, lambda.Parameters));

var expr = Expression.Block(
    Expression.Call(SetInstanceMethod, node.Parameters),
    innerInvoke,
    Expression.Label(returnTarget, Expression.Constant(false)));

return Expression.Lambda(
    expr,
    node.Parameters);

拦截类型的关键是使用BlockExpression。此表达式使您可以组合顺序运行的多个表达式。结果只使用最终表达式的结果（尽管您可以使用变量捕获其他表达式的结果）。代码中的步骤如下所示：

Func lambda = t => Where(t);

并将其转换为：

Func lambda = t => 
{
    BinaryInterceptorVisitor.SetInstance(t);
    return Where(t);
};

现在已经捕获了该值，下一步是了解哪些二进制表达式成功或失败。

OrElse([our code => return false], [existing code]);

……以及另一条逻辑语句：

AndAlso([existing code], [our code => return true]);

但是我们如何捕捉失败？我们需要的是在先前的逻辑返回false时调用代码以进行失败：

OrElse(AndAlso..., [our code => return false]);

因此，完全拦截需要四个部分：

return Expression.OrElse(
    orLeft,
    Expression.OrElse(
        Expression.AndAlso(binary, andRight),
        orRight));

那么，orLeft和其他拦截器的实现是什么样的呢？定义了两个字段来捕获嵌套级别：

private static int evalLevel = 0;
private int binaryLevel = 0;

在binaryLevel解析表达式时跟踪级别。在定义阶段，随着结构的更新，将使用它。evalLevel在运行时或实现阶段跟踪嵌套的级别。

public static void BeforeEval(int binaryLevel, string node)
{
    if (binaryLevel == 1)
    {
        Console.WriteLine($"with {instance} => {{");
        evalLevel = 0;
    }
    else
    {
        evalLevel++;
    }

    Console.WriteLine($"{Indent}[Eval {node}: ");
}

AfterEval方法写出结果（成功或失败）并降低级别。如果求值在顶部表达式之后，它也会写一个右括号。

public static void AfterEval(int binaryLevel, bool success)
{
    var result = success ? "SUCCESS" : "FAILED";

    Console.WriteLine($"{Indent}{result}]");

    evalLevel--;

    if (binaryLevel == 1)
    {
        Console.WriteLine("}");
    }
}

在BinaryExpression重写方法中，使用适当的参数构建方法调用：

binaryLevel++;

var before = Expression.Call(
    BeforeEvalMethod,
    Expression.Constant(binaryLevel),
    Expression.Constant($"{node}"));

var afterSuccess = Expression.Call(
    AfterEvalMethod,
    Expression.Constant(binaryLevel),
    Expression.Constant(true));

var afterFailure = Expression.Call(
    AfterEvalMethod,
    Expression.Constant(binaryLevel),
    Expression.Constant(false));

接下来，创建二进制表达式输入。这些使用表达式块调用所需方法，然后返回适当的bool。

var orLeft = Expression.Block(
    before,
    Expression.Constant(false));

var andRight = Expression.Block(
    afterSuccess,
    Expression.Constant(true));

var orRight = Expression.Block(
    afterFailure,
    Expression.Constant(false));

现有的二进制表达式被访问left和right节点的调用替换。这确保了下游表达式也被拦截。

var binary = node.Update(
    Visit(node.Left),
    node.Conversion,
    Visit(node.Right));

binaryLevel--;

最后，整个表达式将替换为前面显示的逻辑。

var query = new QueryHost(ThingDbQuery);
query.CustomProvider.RegisterInterceptor(ExpressionTransformer);

简化为：

var query = ThingDbQuery.CreateInterceptedQueryable(ExpressionTranformer);

如果您对表达式感兴趣，请看一下！