将 ExpressionVisitor 与 EF Core Include 连接起来

我有一个ExpressionVisitor我将其添加到 EF Core 中IQueryable<T>。除了 Include 方法之外，一切正常。可能是因为他们强制你IQueryable<T>.Provider成为一个EntityQueryProvider.

每当我尝试立即包含时，都会导致多个查询，从而导致错误“在上一个操作完成之前在此上下文上启动了第二个操作。不保证任何实例成员都是线程安全的。”。

我怎样才能连接我的ExpressionVisitor那么它仍然可以与 EF Core 的 Include 功能一起使用吗？

我的问题类似于this one https://stackoverflow.com/questions/34971376/modify-the-expression-tree-of-iqueryable-include-to-add-condition-to-the-join除了 EF Core 而不是 EF。

我连接我的ExpressionVisitor通过在 DbSet 上调用它：

        return new Translator<TEntity>(
            _dbSet
                .AsNoTracking());

这是我的Translator class:

public class Translator<T> : IOrderedQueryable<T>
{
    private readonly Expression _expression;
    private readonly TranslatorProvider<T> _provider;

    public Translator(IQueryable source)
    {
        _expression = Expression.Constant(this);
        _provider = new TranslatorProvider<T>(source);
    }

    public Translator(IQueryable source, Expression expression)
    {
        if (expression == null)
        {
            throw new ArgumentNullException(nameof(expression));
        }

        _expression = expression;
        _provider = new TranslatorProvider<T>(source);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)_provider.ExecuteEnumerable(_expression)).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return _provider.ExecuteEnumerable(_expression).GetEnumerator();
    }

    public Type ElementType => typeof(T);

    public Expression Expression => _expression;

    public IQueryProvider Provider => _provider;
}

这是我的TranslatorProvider<T>类（我删除了不相关的 Visit 方法以缩短帖子）：

public class TranslatorProvider<T> : ExpressionVisitor, IQueryProvider
{
    private readonly IQueryable _source;

    public TranslatorProvider(IQueryable source)
    {
        if (source == null)
        {
            throw new ArgumentNullException(nameof(source));
        }

        _source = source;
    }

    public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
    {
        if (expression == null)
        {
            throw new ArgumentNullException(nameof(expression));
        }

        return new Translator<TElement>(_source, expression);
    }

    public IQueryable CreateQuery(Expression expression)
    {
        if (expression == null)
        {
            throw new ArgumentNullException(nameof(expression));
        }

        var elementType = expression.Type.GetGenericArguments().First();
        var result = (IQueryable) Activator.CreateInstance(typeof(Translator<>).MakeGenericType(elementType),
            _source, expression);
        return result;
    }

    public TResult Execute<TResult>(Expression expression)
    {
        if (expression == null)
        {
            throw new ArgumentNullException(nameof(expression));
        }

        var result = (this as IQueryProvider).Execute(expression);
        return (TResult) result;
    }

    public object Execute(Expression expression)
    {
        if (expression == null)
        {
            throw new ArgumentNullException(nameof(expression));
        }

        var translated = Visit(expression);
        return _source.Provider.Execute(translated);
    }

    internal IEnumerable ExecuteEnumerable(Expression expression)
    {
        if (expression == null)
        {
            throw new ArgumentNullException(nameof(expression));
        }

        var translated = Visit(expression);
        return _source.Provider.CreateQuery(translated);
    }

    protected override Expression VisitConstant(ConstantExpression node)
    {
        if (node.Type == typeof(Translator<T>))
        {
            return _source.Expression;
        }
        else
        {
            return base.VisitConstant(node);
        }
    }
}

更新（EF Core 3.x）：

内部查询管道基础设施已发生变化。新的查询表达式预处理扩展点是查询翻译预处理器 https://learn.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.query.querytranslationpreprocessor?view=efcore-3.1班级 -Process https://learn.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.query.querytranslationpreprocessor.process?view=efcore-3.1方法。将其插入需要更换IQueryTranslationPreprocessorFactory https://learn.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.query.iquerytranslationpreprocessorfactory?view=efcore-3.1. e.g.

using System.Linq.Expressions;

namespace Microsoft.EntityFrameworkCore.Query
{
    public class CustomQueryTranslationPreprocessor : RelationalQueryTranslationPreprocessor
    {
        public CustomQueryTranslationPreprocessor(QueryTranslationPreprocessorDependencies dependencies, RelationalQueryTranslationPreprocessorDependencies relationalDependencies, QueryCompilationContext queryCompilationContext)
            : base(dependencies, relationalDependencies, queryCompilationContext) { }
        public override Expression Process(Expression query) => base.Process(Preprocess(query));
        private Expression Preprocess(Expression query)
        {
            // query = new YourExpressionVisitor().Visit(query);               
            return query;
        }
    }

    public class CustomQueryTranslationPreprocessorFactory : IQueryTranslationPreprocessorFactory
    {
        public CustomQueryTranslationPreprocessorFactory(QueryTranslationPreprocessorDependencies dependencies, RelationalQueryTranslationPreprocessorDependencies relationalDependencies)
        {
            Dependencies = dependencies;
            RelationalDependencies = relationalDependencies;
        }
        protected QueryTranslationPreprocessorDependencies Dependencies { get; }
        protected RelationalQueryTranslationPreprocessorDependencies RelationalDependencies;
        public QueryTranslationPreprocessor Create(QueryCompilationContext queryCompilationContext)
            => new CustomQueryTranslationPreprocessor(Dependencies, RelationalDependencies, queryCompilationContext);
    }
}

and

optionsBuilder.ReplaceService<IQueryTranslationPreprocessorFactory, CustomQueryTranslationPreprocessorFactory>();

原来的：

显然，自定义查询提供程序不适合当前的 EF Core 可查询管道，因为有几种方法（Include, AsNoTracking等）要求提供者是EntityQueryProvider.

在撰写本文时（EF Core 2.1.2），查询转换过程涉及多项服务 -IAsyncQueryProvider, IQueryCompiler, IQueryModelGenerator和更多。它们都是可替换的，但我看到最容易拦截的地方是IQueryModelGenerator服务 -ParseQuery method.

所以，忘记习惯吧IQueryable / IQueryProvider实现，使用以下类并将表达式访问者插入其中Preprocess method:

using Microsoft.EntityFrameworkCore.Internal;
using Microsoft.EntityFrameworkCore.Query.Internal;
using Remotion.Linq;
using Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation;

class CustomQueryModelGenerator : QueryModelGenerator
{
    public CustomQueryModelGenerator(INodeTypeProviderFactory nodeTypeProviderFactory, IEvaluatableExpressionFilter evaluatableExpressionFilter, ICurrentDbContext currentDbContext)
        : base(nodeTypeProviderFactory, evaluatableExpressionFilter, currentDbContext)
    { }

    public override QueryModel ParseQuery(Expression query) => base.ParseQuery(Preprocess(query));

    private Expression Preprocess(Expression query)
    {
        // return new YourExpressionVisitor().Visit(query);               
        return query;
    }
}

并替换派生上下文中相应的 EF Core 服务OnConfiguring覆盖：

optionsBuilder.ReplaceService<IQueryModelGenerator, CustomQueryModelGenerator>();

缺点是这是使用 EF Core“内部”内容，因此您应该继续监视未来更新中的更改。